Trouble defining an IList<T> where T is an generic interface

Question

I am attempting to declare and use an interface like this:

public interface IItem<T>
{
  string Name { get; set; }
  T Value { get; set; }
}

This works fine until I attempt to create a list of these items. This fails to compile:

public interface IThing
{
    string Name { get; }
    IList<IItem<T>> ThingItems { get; }
}

so I am not certain where the issue is. The items value is not defined until runtime, and I need to have collections of the items. I figure that this is a fairly standard pattern, but I can not see where I am falling down.

Answer 1

Your class needs to be generic too (Thing<T>) or else the list can't know what type to use.

public interface Thing<T>
{
    string Name { get; }
    IList<IItem<T>> thingItems { get; }
}

EDIT It compiles now.

EDIT It seems you want your IItem<T> to be in terms of any type. This won't work in C#. You could create IList> here, but that is less than ideal, since you loose your typing when you want to get the items out.

Answer 2

• Interfaces cannot contain fields (data members)
• A type containing a generic type is also a generic type

Answer 3

Two problems:

1. You can't declare fields in an interface. (rationale: a field is considered an implementation detail, which is the thing interfaces are designed to abstract away)
2. You can't have a generic field without specifying the type parameter (unless you have a type parameter on the declaring type too).

Answer 4

You're falling down because the compiler wants to know what kind of items are in your list. So if you don't know yet, just create a non-generic base interface, and derive a generic more specific interface:

Maybe this helps you out:

public interface IItem
{
  string Name { get; set; }
}

public interface IItem<T>: IItem
{
  T Value { get; set; }
}

public interface IThing
{
    string Name { get; }
    IList<IItem> Items { get; }
}

public interface IThing<T>: IThing
{
    string Name { get; }
    IList<IItem<T>> Items { get; }
}

Answer 5

When you create an instace of Thing you have to know what the type of Thing.thingItems is. So the following is the correct way.

public interface Thing<T>
{
    String Name { get; }
    IList<IItem<T>> thingItems { get; }
}

If you do not know the concret type at the point of instanciating Thing you can only use a common base class or a common interface for the type.

public interface Thing<T>
{
    String Name { get; }
    IList<IItem<ThingParameterBase>> thingItems { get; }
}

Or with a common interface.

public interface Thing<T>
{
    String Name { get; }
    IList<IItem<IThingParameter>> thingItems { get; }
}