[抽象类] 类型的接口属性可以在 C# 中实现为具体类吗？

Question

也许是一个有点奇怪的问题。

我有一个接口 IReservable，它描述了使对象“可保留”的行为。 实现它的类必须有一个保留列表，以及一些处理创建/删除保留的方法。 接口声明了一个保留列表，它是一个抽象类，由2个具体类继承； 一个用于房间，一个用于椅子 (RoomReservation & ChairReservation)。

房间和椅子类都实现了 IReservable，并且它们总是只创建一种类型的实例（Chair -> ChairReservation 和 Room -> RoomReservation）

有没有办法让 IReservable 要求有一个 Reservation 列表，但实现可以决定具体的 Reservation？

代码中解释：

public interface IReservable
{
    ICollection<Reservation> Reservations { get; set; }
    
    // Rest omitted for brevity
}

public class Room : IReservable
{
    // Can I make this RoomReservation only?
    public ICollection<Reservation> Reservations { get; set; }
}

public class Seat : IReservable
{
    // And can I make this ChairReservation only?
    public ICollection<Reservation> Reservations { get; set; }
}

没有必要这样做，但我仍然想知道它是否真的可能； 因为我找不到任何例子。

Answer 1

你可以通过使用泛型来做到这一点。 例如

首先让我们假设你有一些这样的类：

public abstract class Reservation { }

public class ChairReservation : Reservation { }
public class RoomReservation : Reservation { }

现在您的界面将更改为此，请注意类型约束以确保保留始终来自Reservation ：

public interface IReservable<TReservation> 
    where TReservation : Reservation
{
    ICollection<TReservation> Reservations { get; set; }
}

现在你的Room和Seat类将是这样的：

public class Room : IReservable<RoomReservation>
{
    public ICollection<RoomReservation> Reservations { get; set; }
}

public class Seat : IReservable<ChairReservation>
{
    public ICollection<ChairReservation> Reservations { get; set; }
}

Answer 2

即使建议的通用接口技术有效，我通常也很难处理通用接口。 接口的优点之一是多态性。 通过使用通用接口，您的不同实现将不会有共同的基类型，因此您将失去多态性。 即，你不能这样做：

IReservable reservable;
reservable = new Room();
reservable = new Seat();
Console.WriteLine(reservable.Reservations.Count);

如果您从未打算利用多态性，使用通用接口就足够了（但是，您可能会问自己为什么在这种情况下需要接口）。 否则我的建议是使用两种不同的界面，一种用于阅读预订，一种用于阅读和修改：

interface IReservable
{
    IEnumerable<Reservation> Reservations { get; }
}

interface IReservable<TReservation> : IReservable
    where TReservation : Reservation
{
    new ICollection<TReservation> Reservations { get; }

    // Reservation methods
}

public class Room : IReservable<RoomReservation>
{
    public ICollection<RoomReservation> Reservations { get; }

    IEnumerable<Reservation> IReservable.Reservations => Reservations;
}

然后你就可以使用多态了。

Answer 3

我认为这里使用泛型的最佳解决方案是@DavidG在这里展示的

但是如果由于某种原因你不能使用泛型，你可以使用显式接口实现

它会是这样的：

public class Room : IReservable
{
    IEnumerable<Reservation> reservations;
    ICollection<Reservation> IReservable.Reservations { get { return (ICollection<Reservation>)reservations; } set { reservations = value; } }
    public ICollection<RoomReservation> Reservations { get { return (ICollection<RoomReservation>)reservations.Cast<RoomReservation>(); } set { reservations = value; } }
}

public class Seat : IReservable
{
    IEnumerable<Reservation> reservations;
    ICollection<Reservation> IReservable.Reservations { get { return (ICollection<Reservation>)reservations; } set { reservations = value; } }
    public ICollection<SeatReservation> Reservations { get { return (ICollection<SeatReservation>)reservations.Cast<SeatReservation>(); } set { reservations = value; } }
}