Conversión de tipo genérico A PARTIR DE una cadena

El método de Lubos hasko falla para nullables. El método a continuación funcionará para nullables. Pero no se me ocurrió. Lo encontré a través de Google: http://web.archive.org/web/20101214042641/http://dogaoztuzun.com/post/C-Generic-Type-Conversion.aspx Crédito a"Tuna Toksoz"

Uso primero:

TConverter.ChangeType<T>(StringValue);  

La clase está abajo.

public static class TConverter
{
    public static T ChangeType<T>(object value)
    {
        return (T)ChangeType(typeof(T), value);
    }

    public static object ChangeType(Type t, object value)
    {
        TypeConverter tc = TypeDescriptor.GetConverter(t);
        return tc.ConvertFrom(value);
    }

    public static void RegisterTypeConverter<T, TC>() where TC : TypeConverter
    {

        TypeDescriptor.AddAttributes(typeof(T), new TypeConverterAttribute(typeof(TC)));
    }
}

Para muchos tipos (integer, double, DateTime, etc.), hay un método de análisis estático. Puedes invocarlo usando reflexión:

MethodInfo m = typeof(T).GetMethod("Parse", new Type[] { typeof(string) } );

if (m != null)
{
    return m.Invoke(null, new object[] { base.Value });
}

TypeDescriptor.GetConverter(PropertyObject).ConvertFrom(Value)

TypeDescriptor es la clase que tiene el método GetConvertor que acepta un objeto Type y luego puede llamar al método ConvertFrom para convertir el value para ese objeto especificado.

Posiblemente podría usar una construcción como una clase traits. De esta manera, tendría una clase helper parametrizada que sabe cómo convertir una cadena a un valor de su propio tipo. Entonces su getter podría verse así:

get { return StringConverter<DataType>.FromString(base.Value); }

Ahora, debo señalar que mi experiencia con tipos parametrizados se limita a C++ y sus plantillas, pero imagino que hay alguna manera de hacer el mismo tipo de cosas usando genéricos de C#.

Compruebe la estática Nullable.GetUnderlyingType. - Si el tipo subyacente es null, entonces el parámetro de la plantilla no es Nullable, y podemos usar ese tipo directamente - Si el tipo subyacente no es null, utilice el tipo subyacente en la conversión.

Parece funcionar para mí:

public object Get( string _toparse, Type _t )
{
    // Test for Nullable<T> and return the base type instead:
    Type undertype = Nullable.GetUnderlyingType(_t);
    Type basetype = undertype == null ? _t : undertype;
    return Convert.ChangeType(_toparse, basetype);
}

public T Get<T>(string _key)
{
    return (T)Get(_key, typeof(T));
}

public void test()
{
    int x = Get<int>("14");
    int? nx = Get<Nullable<int>>("14");
}

public class TypedProperty<T> : Property
{
    public T TypedValue
    {
        get { return (T)(object)base.Value; }
        set { base.Value = value.ToString();}
    }
}

Uso la conversión a través de un objeto. Es un poco más simple.

Usé lobos answer y funciona. Pero tuve un problema con la conversión de dobles debido a la configuración de la cultura. Así que añadí

return (T)Convert.ChangeType(base.Value, typeof(T), CultureInfo.InvariantCulture);

Otra variación. Maneja Nullables, así como situaciones donde la cadena es null y T es no nullable.

public class TypedProperty<T> : Property where T : IConvertible
{
    public T TypedValue
    {
        get
        {
            if (base.Value == null) return default(T);
            var type = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
            return (T)Convert.ChangeType(base.Value, type);
        }
        set { base.Value = value.ToString(); }
    }
}