如何将泛型类型转换为非泛型类型

Question

I have a method that looks like this (assume that I have the necessary method GetMySerializedDataArry() and my serializer JsonSerializer):

    public static List<T> GetMyListOfData<T>()
    {
        var msgList = new List<T>();

        foreach (string s in GetMySerializedDataArray())
        {
            msgList.Add(JsonSerializer.Deserialize<T>(s));
        }

        return msgList;
    }

This works fine and as expected.

However, I want to use the same method to optionally, if and only if the generic type is specified as string, return the data unserialized like this (which does not compile and has syntax problems):

    public static List<T> GetMyListOfData<T>(bool leaveSerialized)
    {
        if (typeof (T) != typeof(string) && leaveSerialized)
        {
            throw new ArgumentException("Parameter must be false when generic type is not List<string>", "leaveSerialized");
        }

        var msgList = new List<T>();

        foreach (string s in GetMySerializedDataArray())
        {
            if (leaveSerialized)
            {
                // Casting does not work:  "Cannot cast expression of type 'System.Collections.Generic.List<T>' to type 'List<string>'"
                // I've tried various permutations of "is" and "as"... but they don't work with generic types
                // But I know in this case that I DO have a list of strings..... just the compiler doesn't.
                // How do I assure the compiler?

                ((List<string>)msgList).Add(s);
            }
            else
            {
                msgList.Add(JsonSerializer.Deserialize<T>(s));
            }
        }

        return msgList;
    }

My questions are in the inline comment.... basically though the compiler clearly doesn't like the cast of generic to non-generic, it won't let me use permutations of "is" and "are" operators either, I know I actually have the correct string in this case.... how to assure the compiler it is OK?

Many thanks in advance.

EDIT: SOLUTION

Thanks to Lee and Lorentz, both. I will be creating two public methods, but implementing the code in a private method with the admittedly icky decision tree about whether to leave serialization. My reason is that my real-world method is far more complex than what I posed here to SO, and I don't want to duplicate those business rules.

FINAL EDIT: CHANGED SOLUTION

Although both answers were very helpful, I have now been able to detangle business rules, and as a result the "correct" answer for me is now the first -- two different methods. Thanks again to all.

Answer 1

You should not return a list of strings as a list of T. I would suggest that you use two separate methods and skip the parameter:

public static List<T> GetMyListOfData<T>()

public static List<string> GetSerializedMyListOfData()

The advantages of this approach is

1. It's more readable (imo) GetSerializedMyListOfData() vs GetMyListOfData<string>(true)
2. You also know the intent of the caller at compile time and don't have to throw an exception when the type argument don't match the intent to leave the data serialized

Answer 2

You can cast to object first:

((List<string>)(object)msgList).Add(s);

however a cleaner solution could be to create another method for dealing with strings, this would also allow you to remove the leaveSerialized parameter.