C# Collection of Different Generic Types Without Casting

Question

I've found couple of questions on the same topic here, however I couldn't find what I need. Basically I am searching for this kind of magic:

public class BaseClass
{
    public int DerivedТype { get; set; }
}

public class DerivedClass<T> : BaseClass
{
    public DerivedClass(T initialValue)
    {
        DerivedТype = 1;
        Property = initialValue;
    }

    public T Property { get; set; }
}

public class OtherDerivedClass<T> : BaseClass
{
    public OtherDerivedClass(T initialValue)
    {
        DerivedТype = 2;
        OtherProperty = initialValue;
    }

    public T OtherProperty { get; set; }
    public int OtherProperty2 { get; set; }
    public float OtherProperty { get; set; }
}

public class Program
{
    public static void Main()
    {
        List<BaseClass> baseClassList = new List<BaseClass>();
        baseClassList.Add(new DerivedClass<int>(5));
        baseClassList.Add(new OtherDerivedClass<float>(6));
        foreach (var derived in baseClassList)
        {
            if (derived.DerivedТype == 1)
            {
                Console.WriteLine(derived.Property);
            }
            else if (derived.DerivedТype == 2)
            {
                Console.WriteLine(derived.OtherProperty);
            }
        }
    }
}

I want a list of BaseClass where I can insert instances of DerivedClass and OtherDerivedClass. So far so good.

DerivedClass and OtherDerivedClass hold different properties so I really have no idea how access them. Also I don't want to use any weired casts. So this part of the code prevents me from building.

if (derived.DerivedТype == 1)
{
    Console.WriteLine(derived.Property);
}
else if (derived.DerivedТype == 2)
{
    Console.WriteLine(derived.OtherProperty);
}

Any ideas would be appreciated. Thank you in advance!

Answer 1

This looks like a problem that can be solved with polymorphism. I'll make a version of your app that does exactly what you seem to be doing in your example, but if there was more information as to what your target goal is, the solution may be different.

public abstract class BaseClass
{
    public abstract void DoSomething();
    public abstract void GetData(Dictionary<string,string> container);
}

public class DerivedClass<T> : BaseClass
{
    public DerivedClass(T initialValue)
    {
        Property = initialValue;
    }

    public T Property { get; set; }
    public override void DoSomething()
    {
        Console.WriteLine(Property);
    }

    public override void GetData(Dictionary<string,string> container)
    {
        container.Add(nameof(Property), "{Property}");
    }
}

public class OtherDerivedClass<T> : BaseClass
{
    public OtherDerivedClass(T initialValue)
    {
        OtherProperty = initialValue;
    }

    public T OtherProperty { get; set; }
    public int OtherProperty2 { get; set; }

    public override void DoSomething()
    {
        Console.WriteLine(OtherProperty);
    }

    public override void GetData(Dictionary<string,string> container)
    {
        container.Add(nameof(OtherProperty), "{OtherProperty}");
        container.Add(nameof(OtherProperty2), "{OtherProperty2}");
    }
}

Your foreach loop could then be as simple as:

foreach(var derived in baseClassList) derived.DoSomething();

This is the proper way to do something like this using OO. There's no need for the DerivedType integer since the object knows what type of class it is and what to do. This is why one would use polymorphism. It's simple and elegant and OO. Extend or change the DoSomething to be more appropriate for what you're trying to do.

The OP came up with his own solution, but if the goal is to do something with the data that is more meaningful, you could also pass in an object to an abstract method that allows you to do this. I added a GetData method that will return all of the property values as strings. The second type of the dictionary could also be object with the actual value stored in the dictionary.

BaseClass could also be a regular class with a method in it to return an IDictionary of object values with string keys. The method could use reflection to get all property values for whatever class it is the base of. Reflection has much more overhead, though, so is not the most efficient way to do this from an execution standpoint.

The correct way to check if an object is a certain type is to use the is operator such as:

if(derived is DerivedType<int>)
{
    // Do what you need to do with the specific object type
}

If you know you're going to cast the object, as pointed out by Adosi, you would use:

var castedValue = derived as DerivedType<int>;
if(castedValue != null)
{
    // Do what you need to do with castedValue
}

A null will be returned if the object isn't of type DerivedType<int>. Trying to use (DerivedType)derived would cause an invalid cast exception.

Answer 2

Thank you all for the awesome support! I decided to go simple and just use a cast.

public class BaseClass
{
    public int DataТype { get; set; }

    public object Data { get; set; }
}

public class DataClass<T>
{
    public DataClass(T initialValue)
    {
        Property = initialValue;
    }
    public T Property { get; set; }
}

public class Program
{
    public static void Main(string[] args)
    {
        List<BaseClass> listBaseClass = new List<BaseClass>();
        BaseClass dummy = new BaseClass();
        dummy.DataТype = 1;
        dummy.Data = new DataClass<int>(50);
        listBaseClass.Add(dummy);
        if (listBaseClass[0].DataТype == 1)
        {
            DataClass<int> casted = (DataClass<int>)listBaseClass[0].Data;     
            Console.WriteLine(casted.Property);
        }      
    }
}

Answer 3

To the best of my knowledge what you want is between impossible and not a good idea. Typechecking is done at compile time. Stuff like Dynamic can move those checks to runtime, but it results in all kinds of issues (functions that take dynamic parameters also return dynamic).

If you got at least C# 7.0, you can at least write a switch for it. Old switch only supported values vs constants for a few select value types and string. But C# 7.0 introduces pattern matching. With that you could even use a is check as part of a case.