Mi tarea es escribir un método StringToType () que convierte una cadena al tipo especificado T.

Para tipos primitivos, utilizo el método Convert.ChangeType ()Para tipos de enumeración - Enum.TryParse ()Para todos los demás tipos personalizados, creé una interfaz "IConvertibleFromString" que contiene un método "FromString ()" para convertir la cadena al tipo especificado. Cualquier clase que necesite convertir desde una cadena debe implementar esta interfaz.

Pero a mí no me gusta la forma en que implementé el método StringToType (). Me gustaría usar menos que el reflejo y asegurar el máximo rendimiento posible.

Por favor aconseje la mejor manera de implementarlo / cambiarlo.

class Program
{
    static bool StringToType<T>(string str, ref T value)
    {
        Type typeT = typeof(T);
        bool isSuccess = false;
        if (typeT.GetInterface("IConvertibleFromString") != null)
        {
            return (bool)typeT.GetMethod("FromString").Invoke(value, new object[] { str });
        }
        else if (typeT.IsEnum)
        {
            MethodInfo methodTryParse = typeT.GetMethod("TryParse").MakeGenericMethod(typeT);
            return (bool)methodTryParse.Invoke(null, new object[] { str, value });
        }
        else if (typeT.IsPrimitive)
        {
            value = (T)Convert.ChangeType(str, typeT);
            return true;
        }
        return isSuccess;
    }

    static void Main(string[] args)
    {
        string intStr = "23";
        int val1 = 0;
        bool res = StringToType<int>(intStr, ref val1);
        Class1 c1;
        res = StringToType<Class1>(intStr, ref c1);
        Console.ReadKey();
    }
}

interface IConvertibleFromString
{
    bool FromString(string str);
}

class MySomeClass : IConvertibleFromString
{
    int someVal;

    public bool FromString(string str)
    {
        return int.TryParse(str, out someVal);
    }
}