Tip Generic de conversie DIN șir

Nu sunt sigur dacă am înțeles corect intențiile, dar las's a vedea dacă acesta ajută.

{
    public T TypedValue
    {
        get { return (T)Convert.ChangeType(base.Value, typeof(T)); }
        set { base.Value = value.ToString();}
    }
}

lubos hasko's metoda eșuează pentru nullables. Metoda de mai jos va lucra pentru nullables. Am't să vină cu ea, deși. Am găsit-o prin intermediul Google: http://web.archive.org/web/20101214042641/http://dogaoztuzun.com/post/C-Generic-Type-Conversion.aspx Credit pentru a "Ton Toksoz"

Utilizare prima:

Clasa este mai jos.

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

Pentru mai multe tipuri (integer, double, DateTime, etc), există o Analiza statică metodă. Puteți invoca ajutorul de reflecție:

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

TypeDescriptor este clasa a avea metoda GetConvertor care accepta un " Tip "object și apoi puteți suna ConvertFrom` metoda de a converti "valoare" pentru că obiectul specificat.

Ai putea folosi, eventual, un construct precum trăsături clasa. În acest fel, ar avea o parametrizat helper class care știe cum de a converti un șir de caractere la o valoare de propriul său tip. Apoi getter ar putea arata astfel:

Acum, trebuie să subliniez faptul că experiența mea cu parametrizat tipuri este limitată la C++ și template-uri, dar îmi imaginez că există o modalitate de a face același lucru folosind C# generice.

Verificați static poate fi nul.GetUnderlyingType.

• În cazul în care tip de fond al sistemului este nul, atunci modelul parametru nu este Null, și putem folosi acest tip direct
• Dacă-suport tip nu este null, atunci folosesc fond al sistemului de tip în conversie.

Pare să funcționeze pentru mine:

{
    // 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 T TypedValue
    {
        get { return (T)(object)base.Value; }
        set { base.Value = value.ToString();}
    }
}

Eu folosesc de conversie prin intermediul unui obiect. Este un pic mai simplu.

Am folosit lobos răspuns și funcționează. Dar am avut o problema cu conversia camere duble, din cauza culturii setări. Așa că am adăugat

Încă o altă variantă. Mânere Nullables, precum și situațiile în care șirul este nulă și T nu este null.

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

Cu inspirație de la Bob's a răspunde, aceste extensii sprijini, de asemenea, null valoarea de conversie și toate primitiv de conversie a întors și a patra.

``CSHARP public static class ConversionExtensions { public static object Converti(acest obiect de valoare, de Tip t) { Tip underlyingType = Null.GetUnderlyingType(t);

dacă (underlyingType != null && valoare == null) { return null; } Tip basetype = underlyingType == null ? t : underlyingType; Sistemul de returnare.Converti.ChangeType(valoare, basetype); }

public static T Converti(acest obiect de valoare) { întoarcere (T)de valoare.Conversia(typeof(T)); } } `` Exemple

``CSHARP string stringValue = null; int? intResult = stringValue.Converti<int?>();

int? intValue = null; var strResult = intValue.Converti(); ``