Conversione di tipo generico DA stringa

Ho una classe che voglio usare per memorizzare "proprietà" per un'altra classe. Queste proprietà hanno semplicemente un nome e un valore. Idealmente, ciò che vorrei è poter aggiungere proprietà tipizzate , in modo che il "valore" restituito sia sempre del tipo che voglio che sia.

Il tipo dovrebbe essere sempre un primitivo. Questa classe subclasse una classe astratta che sostanzialmente memorizza il nome e il valore come stringa. L'idea è che questa sottoclasse aggiungerà un po 'di sicurezza del tipo alla classe base (oltre a salvarmi su qualche conversione).

Quindi, ho creato una classe che è (approssimativamente) questa:

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

Quindi la domanda è:

Esiste un modo "generico" per convertire da stringa a una primitiva?

Non riesco a trovare alcuna interfaccia generica che colleghi la conversione su tutta la linea (qualcosa come ITryParsable sarebbe stato l'ideale!).

Non sono sicuro di aver capito bene le tue intenzioni, ma vediamo se questo aiuta.

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

Il metodo di lubos hasko fallisce per nullable. Il metodo seguente funzionerà per nullable. Non mi è venuto in mente, però. L'ho trovato tramite Google: http://web.archive.org/web/20101214042641/http://dogaoztuzun.com/post/C-Generic-Type-Conversion.aspx Credito a "Tuna Toksoz"

Primo utilizzo:

TConverter.ChangeType<T>(StringValue);  

La lezione è sotto.

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

Per molti tipi (intero, doppio, DateTime ecc.), Esiste un metodo Parse statico. Puoi invocarlo usando reflection:

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è una classe con metodo GetConvertorche accetta un Typeoggetto e quindi è possibile chiamare il ConvertFrommetodo per convertire l' valueoggetto specificato.

È possibile utilizzare un costrutto come una classe di tratti . In questo modo, avresti una classe helper parametrizzata che sa come convertire una stringa in un valore del suo stesso tipo. Quindi il tuo getter potrebbe apparire così:

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

Ora, devo sottolineare che la mia esperienza con i tipi con parametri è limitata a C ++ e ai suoi modelli, ma immagino che ci sia un modo per fare lo stesso tipo di cose usando C # generics.

Controlla la statica Nullable.GetUnderlyingType. - Se il tipo sottostante è nullo, il parametro template non lo èNullable e possiamo usarlo direttamente - Se il tipo sottostante non è null, utilizzare il tipo sottostante nella conversione.

Sembra funzionare per me:

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

Ispirandosi alla risposta di Bob , queste estensioni supportano anche la conversione di valore null e tutta la conversione primitiva indietro e quarta.

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

Esempi

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

Sto usando la conversione tramite un oggetto. È un po 'più semplice.

Ho usato lobos answer e funziona. Ma ho avuto un problema con la conversione dei doppi a causa delle impostazioni della cultura. Quindi ho aggiunto

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

Ancora un'altra variazione. Gestisce nullullabili, nonché situazioni in cui la stringa è nulla e T non è 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(); }
    }
}

Puoi farlo in una riga come di seguito:

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

Buona codifica;)