C# Generics and Collections

Question

I have an two interfaces defined as follows:

public interface IFoo
{
...
}

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

I want to be able to declare a collection of IFooWrappers but I don't want to specify the implementation of IFoo.

Ideally I want to do something like the:

IList<IFooWrapper<*>> myList;

I can't figure out a way around this.

See also: http://stackoverflow.com/questions/833447/833475#833475 — Marc Gravell, Aug 04 '09 at 09:49

score 2 · Answer 1 · answered Aug 04 '09 at 09:48

2

public interface IFoo
{
...
}

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

this is a way to do what you want

answered Aug 04 '09 at 09:48

Arsen Mkrtchyan

49,896
32
148
184

score 2 · Answer 2 · answered Aug 04 '09 at 09:48

2

What's wrong with

IList<IFooWrapper<IFoo>> myList?

answered Aug 04 '09 at 09:48

Preet Sangha

64,563
18
145
216

Indeed! List> myList = new List>(); – redcalx Aug 04 '09 at 09:54
1

Except that it won't work... for instance, IFooWrapper doesn't inherit IFooWrapper, even if Foo implements IFoo... (except if you're using C# 4 which implements covariance) – Thomas Levesque Aug 04 '09 at 10:00
1

List> fooWrapperList = new List>(); IFooWrapper concreteWrapper = new ConcreteFooWrapper(); fooWrapperList.Add(concreteWrapper); – redcalx Aug 04 '09 at 10:52
I appreciate the covariance issue. but the question was about a general iList. – Preet Sangha Aug 04 '09 at 20:40

score 0 · Answer 3 · answered Aug 04 '09 at 09:52

0

public class FooWrapper : IFooWrapper<IFoo>

answered Aug 04 '09 at 09:52

DanDan

10,462
8
53
69

score 0 · Answer 4 · answered Aug 04 '09 at 15:13

What I'm about to suggest is overkill for most situations, since usually you can create an interface higher up in the hierarchy that you can use. However, I think this is the most flexible solution in some ways, and the most faithful representation of what you want:

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

Now you can create an instance of an IList<IExistsFooWrapper> which can be used as if it's an IList<IFooWrapper<*>>. The downside is you'll need to create a class to encapsulate the logic you want to run on each element:

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

...

C# Generics and Collections

4 Answers4