Storing a list of different generic types in a class

Question

I've attached a picture of what I'm trying to do. Let's say I have a list of T in a class

public class MyClass<T> 
    where T : IMyInterface
{
    public List<T> list = new List<T>;
}

Now, another class has a list of MyClass.

public class AnotherClass
{
    public List<MyClass<IMyInterface>> list = new List<MyClass<IMyInterface>>;
}

What is the T that I should put for MyClass? If I put T, then it assumes all types in that class are the same, but it isn't. If I put IMyInterface, I couldn't cast IMyInterface to T when accessing these classes.

new AnotherClass().list.Add(new MyClass<T>());

What is the type here right now? The list in AnotherClass generic type is IMyInterface but the thing I want to add in is T, which T I want to be dynamic but they are still under IMyInterface.

The problem is you're describing a solution to a problem, and not the actual problem. What are you trying to solve??? (XY Problem). — Erik Philips
– Erik Philips, Commented Apr 7, 2016 at 6:07
I haven't been working with c# for a while now, but I would not use generics. If you know you are putting only objects implementing your interface in it, why don't you use polymorphy. That means: public List<IMyInterface> list=new List<IMyInterface>; — Johannes91
– Johannes91, Commented Apr 7, 2016 at 6:13
you seem to be confusing things. generics are not dynamically typed. everything in C# is statically typed except statements/declarations that involve the dynamic keyword, but that has nothing to do with generics. a List<int> is a list containing ONLY ints. a List<IMyInterface> is a list containing ONLY objects implementing IMyInterface. — sara
– sara, Commented Apr 7, 2016 at 6:49

Thomas Andreè Wang · Accepted Answer · 2016-04-08 06:28:52Z

7

The T in a generic must be the same through out its lifetime.

for an example

var a = new MyClass<int>();
a.list.Add(1); //since a's generic T is declared as int the list is now also int

var b = new MyClass<string>()
b.list.Add("string"); //in b its now declared as a string and avccepts only string

So when you are doing this.

var c = new MyClass<IMyInterface>();
c.list.Add(ObjectImplementingIMyInterface); //You must add something that implements IMyInterface

The only thing you know about the content is that it implements IMyInterface now if you want to split the execution of the object then you must check the type of the object via reflection.

if(c.list[i].GetType() == typeof(ClassA_IMyInterface)
{
    //Execute on ClassA_IMyInterface
    //If you are after the ClassA 
    //and want to run something speciffic for it the cast
    ClassA clA = = (ClassA)c.list[i];
    //Now you have access to the implementation of ClassA instead of just the interface 
}
else if (c.list[i].GetType() == typeof(ClassB_IMyInterface)
{
    //Execute on ClassB_IMyInterface
}

Here is an example i made in ConsoleApplication showing how it lays out.

public class MyClass<T> where T : IMyInterface
{
    public List<T> list = new List<T>();
}
public interface IMyInterface
{
}
public class Foo : IMyInterface
{
}
public class Bar : IMyInterface
{
}
public class FooBar
{
    public void Test()
    {
        var content = new MyClass<IMyInterface>();
        content.list.Add(new Foo());
        if (content.list[0] is Foo)
        {
            //Execute on Foo 
            var g = (Foo)content.list[0];
            //Now you can access Foo's methods and not only the Interfaces
            Console.WriteLine("Foo");
        }
        else if (content.list[0] is Bar)
        {
            //Execute on Bar
            var g = (Bar)content.list[0];
            //Now you can access Bar's methods and not only the Interfaces
            Console.WriteLine("Bar");
        }
    }
}

edited Apr 8, 2016 at 6:28

answered Apr 7, 2016 at 6:20

Thomas Andreè Wang

3,4416 gold badges41 silver badges55 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Taemyr Over a year ago

c.list[0] is dd1. This allows subclasses of dd1 to be treated with the code for dd1.

Thomas Andreè Wang Over a year ago

@Taemyr is is a bool evaluator (and i could probably use it instead of GetType/typeof. Are you thinking of as (close to casting, but allows for the result to be null)

Taemyr Over a year ago

I mean instead of GetType(). In your example using as would not make sense.

Thomas Andreè Wang Over a year ago

yes using is like that, would make it a little nicer as it is a syntactic sugar.

Steve Harris · Accepted Answer · 2016-04-07 09:41:59Z

6

I think your issue is that you do not need to use generics for this. If you specify your class as:

public class MyClass
{
    public IList<IMyInterface> list = new List<IMyImterface>();
}

Then you can add to this any instance of any class implementing the interface.

public class DummyClass : IMyInterface {}

public class AnotherClass {
{
    IList<MyClass> anotherList = new List<MyClass>();

    public void AMethod()
    {
        MyClass myList = new MyClass();
        myList.Add(new DummyClass());

        anotherList.Add(myList);
    }
}

Then you can access all items from the list as IMyInterface directly, or if you want items of a specific class, you can use LINQ:

foreach (IMyImterface item in myList.Where(x => x is DummyClass))
{
    DummyClass dummy = (DummyClass)item;
}

// or
foreach (IMyImterface item in myList.OfType<DummyClass>())
{
    DummyClass dummy = (DummyClass)item;
}

Or you can just try casting and check if null:

foreach (IMyIntetface item in myList)
{
    DummyClass dummy = item as DummyClass;
    if (dummy != null)
    {
        // do something
    }
}

edited Apr 7, 2016 at 9:41

answered Apr 7, 2016 at 6:49

Steve Harris

5,1571 gold badge13 silver badges26 bronze badges

4 Comments

sara Over a year ago

the canonical way of getting all instances of a specific subtype from a sequence is seq.OfType<T>() (your version does two type checks). although you shouldn't be downcasting stuff in 99 out of 100 cases anyway.

Steve Harris Over a year ago

Thanks for the tip. I expect that would be faster?

sara Over a year ago

well I would assume the time-complexity is the same, but I wouldn't really worry about the performance, both are fast enough to never ever be the bottle-neck in your app. it's just cleaner to say what you want, rather than saying what something should do, knowing it will result in what you want. it's kind of a declarative vs imperative thing.

Andy Nichols Over a year ago

@SteveHarris I think the cast (DummyClass)item will throw an exception rather than return null. It should be item as DummyClass.

Tim Rutter · Accepted Answer · 2016-04-07 06:22:43Z

I think you mean that you want to have multiple generic types in one list eg:

var ac = new AnotherClass();
ac.list.Add(new MyClass<int>()); 
ac.list.Add(new MyClass<bool>()); 
ac.list.Add(new MyClass<double>());

A simple way to do this is to define your list as a list of object:

public class AnotherClass
{
    public List<object> list = new List<object>();
}

The issue here is you could anything you like to that list, not just your generic class. The following would also be possible:

list.Add(1); 
list.Add("hello");

The only way you could restrict what you can add is to use an abstract base class.

public class MyClassBase 
{

}
public class MyClass<T> : MyClassBase
    where T : IMyInterface
{
    public List<T> list = new List<T>();
}

And then have a list of those:

public class AnotherClass
{
    public List<MyClassBase> list = new List<MyClassBase>();
}

You'll still have to do some type checking when accessing those objects but at least you'll know that the objects are restricted to those inheriting MyClassBase

Eric · Accepted Answer · 2016-04-07 08:24:50Z

3

Using covariant?

public interface IMyInterface { }
public class A : IMyInterface { }
public class B : IMyInterface { }

// Covariant interface
public interface IMyClass<out T> { }

// Inherit IMyClass
public class MyClass<T> : IMyClass<T> where T : IMyInterface 
{ 
    public List<T> list = new List<T>(); 
}

public class AnotherClass
{
    // Note the list using IMyClass instead of the concrete MyClass type
    // The covariant interface type would allow any IMyInterface conversion
    public List<IMyClass<IMyInterface>> list = new List<IMyClass<IMyInterface>>();

    public AnotherClass()
    {
        this.list.Add(new MyClass<A>());
        this.list.Add(new MyClass<B>());
    }
}

edited Apr 7, 2016 at 8:24

answered Apr 7, 2016 at 8:11

Eric

5,74319 silver badges26 bronze badges

Collectives™ on Stack Overflow

Storing a list of different generic types in a class

4 Answers 4

4 Comments

4 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

4 Comments

4 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related