Conversion de type générique FROM chaîne

J'ai une classe que je veux utiliser pour stocker des "propriétés" pour une autre classe. Ces propriétés ont simplement un nom et une valeur. Idéalement, ce que j'aimerais, c'est pouvoir ajouter des propriétés typées , de sorte que la "valeur" retournée soit toujours du type que je veux qu'elle soit.

Le type doit toujours être une primitive. Cette classe sous-classe une classe abstraite qui stocke essentiellement le nom et la valeur sous forme de chaîne. L'idée étant que cette sous-classe va ajouter une certaine sécurité de type à la classe de base (ainsi que me sauver sur une conversion).

J'ai donc créé une classe qui est (à peu près) la suivante:

public class TypedProperty<DataType> : Property
{
    public DataType TypedValue
    {
        get { // Having problems here! }
        set { base.Value = value.ToString();}
    }
}

La question est donc:

Existe-t-il un moyen "générique" de reconvertir une chaîne en une primitive?

Je n'arrive pas à trouver d'interface générique qui relie la conversion à tous les niveaux (quelque chose comme ITryParsable aurait été idéal!).

Je ne sais pas si j'ai bien compris vos intentions, mais voyons si celle-ci aide.

public class TypedProperty<T> : Property where T : IConvertible
{
    public T TypedValue
    {
        get { return (T)Convert.ChangeType(base.Value, typeof(T)); }
        set { base.Value = value.ToString();}
    }
}

La méthode de lubos hasko échoue pour les nullables. La méthode ci-dessous fonctionnera pour nullables. Mais je ne l'ai pas inventé. Je l'ai trouvé via Google: http://web.archive.org/web/20101214042641/http://dogaoztuzun.com/post/C-Generic-Type-Conversion.aspx Crédit à "Tuna Toksoz"

Utilisation d'abord:

TConverter.ChangeType<T>(StringValue);  

La classe est ci-dessous.

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)));
    }
}

Pour de nombreux types (entier, double, DateTime, etc.), il existe une méthode Parse statique. Vous pouvez l'invoquer en utilisant la réflexion:

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)

TypeDescriptorest une classe ayant une méthode GetConvertorqui accepte un Typeobjet et vous pouvez ensuite appeler la ConvertFromméthode pour convertir le valuepour cet objet spécifié.

Vous pouvez éventuellement utiliser une construction telle qu'une classe de traits . De cette façon, vous auriez une classe d'assistance paramétrée qui sait convertir une chaîne en une valeur de son propre type. Ensuite, votre getter pourrait ressembler à ceci:

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

Maintenant, je dois souligner que mon expérience avec les types paramétrés est limitée au C ++ et à ses modèles, mais j'imagine qu'il existe un moyen de faire la même chose en utilisant des génériques C #.

Vérifiez la statique Nullable.GetUnderlyingType. - Si le type sous-jacent est nul, alors le paramètre de modèle ne l'est pas Nullable, et nous pouvons utiliser ce type directement - Si le type sous-jacent n'est pas nul, alors utilisez le type sous-jacent dans la conversion.

Semble fonctionner pour moi:

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");
}

En s'inspirant de la réponse de Bob , ces extensions prennent également en charge la conversion de valeur nulle et toutes les conversions primitives de retour et quatrième.

public static class ConversionExtensions
{
        public static object Convert(this object value, Type t)
        {
            Type underlyingType = Nullable.GetUnderlyingType(t);

            if (underlyingType != null && value == null)
            {
                return null;
            }
            Type basetype = underlyingType == null ? t : underlyingType;
            return System.Convert.ChangeType(value, basetype);
        }

        public static T Convert<T>(this object value)
        {
            return (T)value.Convert(typeof(T));
        }
}

Exemples

            string stringValue = null;
            int? intResult = stringValue.Convert<int?>();

            int? intValue = null;
            var strResult = intValue.Convert<string>();

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

J'utilise la conversion via un objet. C'est un peu plus simple.

J'ai utilisé la réponse lobos et cela fonctionne. Mais j'ai eu un problème avec la conversion des doubles à cause des paramètres de culture. J'ai donc ajouté

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

Encore une autre variation. Gère les valeurs Nullables, ainsi que les situations où la chaîne est nulle et T ne l' est pas .

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(); }
    }
}

Vous pouvez le faire sur une seule ligne comme ci-dessous:

YourClass obj = (YourClass)Convert.ChangeType(YourValue, typeof(YourClass));

Bon codage;)