类层次结构问题（具有泛型差异！）

Question

问题：

class StatesChain : IState, IHasStateList {
    private TasksChain tasks = new TasksChain();

     ...

    public IList<IState> States {
        get { return _taskChain.Tasks; }
    }

    IList<ITask> IHasTasksCollection.Tasks {
        get { return _taskChain.Tasks; } <-- ERROR! You can't do this in C#!
                                             I want to return an IList<ITask> from
                                             an IList<IStates>.
    }
}

假设返回的IList是只读的，我知道我想要实现的目标是安全的（或者不是？）。有什么办法可以完成我正在尝试的事情吗？我不想尝试自己实现 TasksChain 算法（再次！），因为它很容易出错并且会导致代码重复。也许我可以定义一个抽象链，然后从那里实现 TasksChain 和 StatesChain ？或者也许实现一个 Chain 类？

你会如何处理这种情况？

详细信息： 我定义了一个 ITask 接口：

public interface ITask {
    bool Run();
    ITask FailureTask { get; }
}

以及一个继承自 ITask 的 IState 接口：

public interface IState : ITask {
    IState FailureState { get; }
}

我还定义了一个 IHasTasksList接口：

interface IHasTasksList {
    List<Tasks> Tasks { get; }
}

和一个 IHasStatesList：

interface IHasTasksList {
    List<Tasks> States { get; }
}

现在，我定义了一个 TasksChain，它是一个具有一些代码逻辑的类，可以操作一系列任务（请注意 TasksChain 本身就是一种 ITask！）：

class TasksChain : ITask, IHasTasksList {
    IList<ITask> tasks = new List<ITask>();

    ...

    public List<ITask> Tasks { get { return _tasks; } }

    ...
}

我通过以下方式实现 State：

public class State : IState {
    private readonly TaskChain _taskChain = new TaskChain();

    public State(Precondition precondition, Execution execution) {
        _taskChain.Tasks.Add(precondition);
        _taskChain.Tasks.Add(execution);
    }

    public bool Run() {
        return _taskChain.Run();
    }

    public IState FailureState {
        get { return (IState)_taskChain.Tasks[0].FailureTask; }
    }

    ITask ITask.FailureTask {
        get { return FailureState; }
    }
}

如您所见，它使用显式接口实现“隐藏”FailureTask 并显示 FailureState 属性。

问题来自于我还想定义一个 StatesChain，它继承自 IState 和 IHasStateList （并且这也实现了 >ITask 和 IHasTaskList，作为显式接口实现），我希望它也隐藏 IHasTaskList 的 Tasks 并仅显示 < code>IHasStateList 的 States。 （“问题”部分中包含的内容确实应该在这之后，但我认为将其放在前面会更方便读者阅读）。

（pff..长文本） 谢谢！

Answer 1

简而言之，不，它不安全，因为“只读”IList<> 不存在（合约方面）。只有实现会拒绝条目，但这已经太晚了，因为调用本身需要接口类型参数同时是协变和逆变的。

不过，您可以返回一个 IEnumerable<>，它在 C# 4 中是协变的。由于这足以使用 LINQ，因此这不应该是太大的缺点，并且表示了可读性：只有自然更好。

Answer 2

在出现错误的行上，您尝试返回 IList，就好像它是 IList 类型的实例一样。这不会自动工作，因为两种类型不同（无论通用参数是否相关）。

在 C# 3.0 或更早版本中，无法自动实现这一点。 C# 4.0 添加了对协变和逆变的支持，这正是这个目的。但正如您所指出的，这仅在返回的集合为只读时才有效。 IList 类型不能保证这一点，因此它在 .NET 4.0 中不会被注释为协变。

要使用 C# 4.0 完成此工作，您需要使用真正的只读类型，它在框架中具有协变注释 - 您的情况的最佳选择是 IEnumerable< /code> （尽管您可以使用 out T 修饰符定义自己的）。

要添加更多详细信息，在 C# 4.0 中，您可以将接口声明为协变或逆变。第一种情况意味着编译器将允许您执行示例中所需的转换（另一种情况对于只写类很有用）。这是通过向接口声明添加显式注释来完成的（这些注释已可用于 .NET 4.0 类型）。例如，IEnumerable 的声明具有 out 注释，这意味着它支持协变：

public interface IEnumerable<out T> : IEnumerable { /* ... */ }

现在，编译器将允许您编写：

IEnumerable<IState> states = ...
IEnumerable<ITask> tasks = states;