返回具有公共基类的不同类型的列表

Question

I'm designing a method that should return a List of instances, each instance is actually of a different data type.

The following is my draft design, I need a recommendation for it

public class abstract Base
{
    //DataType is an enum
    public abstract DataType Type { get; set; }

    public abstract BaseType Value { get; set; }
}

public abstract class BaseType
{
}     

public class MyString:BaseType
{
}     

public class MyInt:BaseType
{
}     

 //string for example    
public class Type1:Base
{
    public override DataType Type
    {
        get { return DataType.Type1; }
        set;
    }

    public override BaseType Value
    {
        get { return new MyString("a"); }
        set;
    }
}

public class Type2:Base
{
    public override DataType Type
    {
        get { return DataType.Type2; }
        set;
    }

    public override BaseType Value
    {
        //MyInt for example
        get { return new MyInt(10); }
        set;
    }
}

Method should be

List<Base> GetValues();

Caller is expected to write something like that

List<Base> values = GetValues();

foreach(var value in values)
{
    switch(value.Type)
    {
        case DataType.MyString:
            MyString str = value.Value as MyString;
            break;

        case DataType.MyInt:
            MyInt str = value.Value as MyInt;
            break;
    }
}

My question is what is the best design for that? Can I use generics better, how?

Answer 1

I would recommend a generic base class:

public abstract class Base<T>
    where T : BaseType
{
    public abstract DataType Type { get; }

    public abstract T Value { get; set; }
}

Type1 is now:

public class Type1 : Base<MyString>
{
    public override DataType Type
    {
        get { return DataType.MyString; }
    }

    public override MyString Value
    {
        get;
        set;
    }
}

However, I don't know what GetValues is. If it returns a list of values of the same type it should also be generic:

public List<Base<T>> GetValues<T>()
    where T : BaseType
{
    return theList;
}

If it returns elements of different types you can use another non-generic base class:

public abstract class Base
{
    public abstract DataType Type { get; }
}

public abstract class Base<T> : Base
    where T : BaseType
{
    public abstract T Value { get; set; }
}

The GetValues method would be:

public List<Base> GetValues()
{
    return theList;
}

Note that I moved the non-generic part into the non-generic base class so that you can still use the DataType property.

You need to cast the values to the respective types in order to access the Value property:

List<Base> values = GetValues();

foreach (Base value in values)
{
    switch (value.DataType)
    {
        case DataType.MyString:
            MyString myString = value as MyString;
            ...

        case DataType.MyInt:
            MyInt myInt = value as MyInt;
            ...
    }
}

It seems that you only use the DataType property to get information about the type of an object. This is not necessary. You can use the is operator:

foreach (Base value in values)
{
    if (value is MyString)
    {
        MyString myString = value as MyString;
        ...
    }
    else if (value is MyInt)
    {
        MyInt myInt = value as MyInt;
        ...
    }
}