C＃泛型和集合

Question

我有两个定义如下的接口：

public interface IFoo
{
...
}

Public interface IFooWrapper<T> where T : IFoo
{
  T Foo {get;}
}

我希望能够声明IFooWrappers的集合，但是我不想指定IFoo的实现。

理想情况下，我想执行以下操作：

IList<IFooWrapper<*>> myList;

我找不到解决办法。

Answer 1

public interface IFoo
{
...
}

public interface IFooWrapper : IFoo
{
...
}
public interface IFooWrapper<T> : IFooWrapper
 where T : IFoo
{
...
}
IList<IFooWrapper> myList;

这是做你想要的一种方式

Answer 2

怎么了

IList<IFooWrapper<IFoo>> myList?

Answer 3

public class FooWrapper : IFooWrapper<IFoo>

Answer 4

在大多数情况下，我要建议的是过度使用，因为通常您可以在可以使用的层次结构中创建一个更高级别的接口。 但是，我认为这在某些方面是最灵活的解决方案，也是您想要的最忠实的表示：

public interface IFooWrapperUser<U> {
    U Use<T>(IFooWrapper<T> wrapper);
}

public interface IFooWrapperUser {
    void Use<T>(IFooWrapper<T> wrapper);
}

public interface IExistsFooWrapper {
    U Apply<U>(IFooWrapperUser<U> user);
    void Apply(IFooWrapperUser user);
}

public class IExistsFooWrapper<T> : IExistsFooWrapper {
    private IFooWrapper<T> wrapper;
    public IExistsFoo(IFooWrapper<T> wrapper) {
        this.wrapper = wrapper;
    }

    public U Apply<U>(IFooWrapperUser<U> user) {
        return user.Use(foo);
    }

    public void Apply(IFooWrapperUser user) {
        user.Use(foo)
    }
}

现在，您可以创建一个IList<IExistsFooWrapper>的实例，该实例可以像IList<IFooWrapper<*>> 。 缺点是您需要创建一个类来封装要在每个元素上运行的逻辑：

private class FooPrinter : IFooWrapperUser<string> {
    public string Apply<T>(IFooWrapper<T> wrapper) {
        return wrapper.Foo.ToString();
    }
}

...
    IFooWrapperUser<string> user = new FooPrinter();
    foreach (IExistFooWrapper wrapper in list) {
        System.Console.WriteLine(wrapper.Apply(user));
    }

...