C # Generics и Коллекции

Question

C # Generics и Коллекции

2

У меня есть два интерфейса, определяемые следующим образом:

public interface IFoo
{
...
}

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

Я хочу, чтобы иметь возможность объявлять коллекцию IFooWrappers, но я не хочу указывать реализацию IFoo.

В идеале я хочу сделать что-то вроде:

IList<IFooWrapper<*>> myList;

Я не могу найти способ обойти это.

Matt S 04 авг. 2009, в 11:48

Источник

0

Смотрите также: stackoverflow.com/questions/833447/833475#833475
Marc Gravell♦ 04 авг. 2009, в 09:49

Теги:

c#

generics

collections

4 ответа

Ещё вопросы

Смотрите также: stackoverflow.com/questions/833447/833475#833475

Preet Sangha · Answer 1 · 2009-08-04T08-29-00.000Z

2

Что случилось с

IList<IFooWrapper<IFoo>> myList?

Preet Sangha 04 авг. 2009, в 08:29

0

На самом деле! List <IFooWrapper <IFoo >> myList = new List <IFooWrapper <IFoo >> ();
redcalx 04 авг. 2009, в 09:54
1

За исключением того, что он не будет работать ... например, IFooWrapper <Foo> не наследует IFooWrapper <IFoo>, даже если Foo реализует IFoo ... (кроме случаев, когда вы используете C # 4, который реализует ковариацию)
Thomas Levesque 04 авг. 2009, в 10:00
1

List <IFooWrapper <IFoo >> fooWrapperList = новый список <IFooWrapper <IFoo >> (); IFooWrapper <IFoo> concreteWrapper = new ConcreteFooWrapper <IFoo> (); fooWrapperList.Add (concreteWrapper);
redcalx 04 авг. 2009, в 10:52
0

Я ценю проблему ковариации. но вопрос был об общем iList.
Preet Sangha 04 авг. 2009, в 20:40

Показать ещё 2 комментария

Arsen Mkrtchyan · Answer 2 · 2009-08-04T08-12-00.000Z

public interface IFoo
{
...
}

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

Это способ сделать то, что вы хотите

kvb · Answer 3 · 2009-08-04T13-54-00.000Z

То, что я собираюсь предложить, является излишним для большинства ситуаций, поскольку обычно вы можете создать интерфейс выше в иерархии, которую вы можете использовать. Однако я считаю, что это наиболее гибкое решение в некотором роде и наиболее точное представление о том, что вы хотите:

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));
    }

...

DanDan · Answer 4 · 2009-08-04T07-01-00.000Z

public class FooWrapper : IFooWrapper<IFoo>