Conversion générique de type FROM string

Question

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 je voudrais c'est de pouvoir ajouter dactylographié afin que la "valeur" renvoyée soit toujours du type que je souhaite.

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 est que cette sous-classe ajoutera une certaine sécurité de type à la classe de base (ainsi qu'une économie sur la conversion).

J'ai donc créé une classe qui est (en gros) la suivante :

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

La question est donc la suivante :

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

Je n'arrive pas à trouver d'interface générique qui lie la conversion à travers le tableau (quelque chose comme ITryParsable aurait été idéal !).

Answer 1

Je ne suis pas sûr d'avoir bien compris vos intentions, mais voyons si celle-ci est utile.

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

Answer 2

La méthode de lubos hasko échoue pour les nullables. La méthode ci-dessous fonctionnera pour les nullables. Ce n'est pas moi qui l'ai inventée. Je l'ai trouvée via Google : http://web.archive.org/web/20101214042641/http://dogaoztuzun.com/post/C-Generic-Type-Conversion.aspx Credit to "Toksoz au thon"

Utilisation en premier :

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

Answer 3

Pour de nombreux types (integer, 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 });
}

Answer 4

Vous pouvez éventuellement utiliser une construction telle qu'un classe de traits . Ainsi, vous disposez d'une classe d'aide paramétrée qui sait comment convertir une chaîne de caractères en une valeur de son propre type. Votre getter pourrait alors ressembler à ceci :

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

Je dois préciser que mon expérience des types paramétrés est limitée au C++ et à ses templates, mais j'imagine qu'il existe un moyen de faire le même genre de chose en utilisant les génériques du C#.

Answer 5

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.