将C＃泛型用于特定类型支持而无需硬编码类型比较

Question

I have function which takes in a serialized string, breaks the string apart to build however many objects it defines, and then returns a generic list. Here is the function and it is working exactly as I need it to:

// 'T' only supports specific types - those derived from BaseObject.
internal static T[] DeserializeData<T>(string serializedData)
{
    var data = new List<T>();

    // Break into individual serialized items and decode each.
    foreach (var serializedItem in (serializedData ?? "").Split(','))
    {
        // Skip empty entries.
        if (serializedItem == "")
        {
            continue;
        }

        // Base class which 'T' will always be derived from.
        BaseObject item = null;

        // Initialize object based on the generic type provided.
        if (typeof(T) == typeof(BaseObjectSpecific1))
        {
            item = new BaseObjectSpecific1();
        }
        else if (typeof(T) == typeof(BaseObjectSpecific2))
        {
            item = new BaseObjectSpecific2();
        }
        // Add additional checks for BaseObjectSpecific3, etc.


        item.BuildFromSerializedValue(serializedItem);

        data.Add((T)Convert.ChangeType(item, typeof(T)));
    }

    return data.ToArray();
}

For lack of better words, I'm trying to do some "reverse polymorphism" without explicitly comparing each supported type 'T'. For example, I would like to do this instead of the if , else if , ... :

// Create a new object and then convert it to the generic type T.
// Then cast it back to the base object so we can access the deserialize method.
var item = (BaseObject)Convert.ChangeType(new BaseObject(), typeof(T));
item.BuildFromSerializedValue(serializedItem);

data.Add((T)Convert.ChangeType(item, typeof(T)));

Of course this does not work because a new BaseObject cannot be cast "forward" to an inherited class.

I have tried having the function return an array of BaseObject s:

internal static BaseObject[] DeserializeData(string serializedData)

But this doesn't work when I am merging the return value into a List<BaseObjectSpecific1> (etc.)

I feel like am I missing something or making this more complicated than required. Is there a way I can support any type of BaseObject using generics without having to explicitly compare T to each inherited class type?

Answer 1

You can simply use Generics Constraints along with the new() constraint:

internal static T[] DeserializeData<T>(string serializedData)
     where T : BaseObject, new()
{
    var data = new List<T>();

    // Break into individual serialized items and decode each.
    foreach (var serializedItem in (serializedData ?? "").Split(','))
    {
        // Skip empty entries.
        if (serializedItem == "")
            continue;

        T item = new T();

        // Add additional checks for BaseObjectSpecific3, etc.

        item.BuildFromSerializedValue(serializedItem);

        data.Add(item);
    }

    return data.ToArray();
}

This way, the compiler already knows that each T is deriving from BaseObject (hence having the BuildFromSerializedValue() method). And, by using the new() constraint it also knows that it's possible to create new instances of T because it's having a parameter-less constructor.

Also, you no longer need to explicitly cast item to T since the compiler already knows it is a T .

More on MSDN