Generische Typkonvertierung FROM Zeichenfolge

Ich habe eine Klasse, mit der ich "Eigenschaften" für eine andere Klasse speichern möchte. Diese Eigenschaften haben einfach einen Namen und einen Wert. Im Idealfall möchte ich typisierte Eigenschaften hinzufügen können , damit der zurückgegebene "Wert" immer von dem Typ ist, den ich möchte.

Der Typ sollte immer ein Grundelement sein. Diese Klasse unterklassifiziert eine abstrakte Klasse, in der Name und Wert grundsätzlich als Zeichenfolge gespeichert sind. Die Idee ist, dass diese Unterklasse der Basisklasse eine gewisse Typensicherheit hinzufügt (und mich bei einigen Konvertierungen erspart).

Also habe ich eine Klasse erstellt, die (ungefähr) so lautet:

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

Die Frage ist also:

Gibt es eine "generische" Möglichkeit, von einem String zurück in ein Grundelement zu konvertieren?

Ich kann anscheinend keine generische Schnittstelle finden, die die Konvertierung auf der ganzen Linie verknüpft (so etwas wie ITryParsable wäre ideal gewesen!).

Ich bin nicht sicher, ob ich Ihre Absichten richtig verstanden habe, aber mal sehen, ob dies hilft.

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

Die Methode von lubos hasko schlägt für nullables fehl. Die folgende Methode funktioniert für Nullables. Ich habe es mir aber nicht ausgedacht. Ich habe es über Google gefunden: http://web.archive.org/web/20101214042641/http://dogaoztuzun.com/post/C-Generic-Type-Conversion.aspx Gutschrift für "Tuna Toksoz"

Verwendung zuerst:

TConverter.ChangeType<T>(StringValue);  

Die Klasse ist unten.

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

Für viele Typen (Integer, Double, DateTime usw.) gibt es eine statische Parse-Methode. Sie können es mit Reflection aufrufen:

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)

TypeDescriptorist eine Klasse mit einer Methode, GetConvertordie ein TypeObjekt akzeptiert. Anschließend können Sie eine ConvertFromMethode aufrufen , um die valuefür das angegebene Objekt zu konvertieren .

Sie könnten möglicherweise ein Konstrukt wie eine Merkmalsklasse verwenden . Auf diese Weise hätten Sie eine parametrisierte Hilfsklasse, die weiß, wie eine Zeichenfolge in einen Wert ihres eigenen Typs konvertiert wird. Dann könnte Ihr Getter so aussehen:

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

Nun muss ich darauf hinweisen, dass meine Erfahrung mit parametrisierten Typen auf C ++ und seine Vorlagen beschränkt ist, aber ich stelle mir vor, dass es eine Möglichkeit gibt, mit C # -Generika dasselbe zu tun.

Überprüfen Sie die statische Aufladung Nullable.GetUnderlyingType. - Wenn der zugrunde liegende Typ null ist, ist der Vorlagenparameter nicht null, Nullableund wir können diesen Typ direkt verwenden. - Wenn der zugrunde liegende Typ nicht null ist, verwenden Sie den zugrunde liegenden Typ bei der Konvertierung.

Scheint für mich zu arbeiten:

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

Inspiriert von der Antwort von Bob unterstützen diese Erweiterungen auch die Nullwertkonvertierung und alle primitiven Konvertierungen zurück und viertens.

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

Beispiele

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

Ich benutze die Konvertierung über ein Objekt. Es ist ein bisschen einfacher.

Ich habe Lobos Antwort verwendet und es funktioniert. Aber ich hatte ein Problem mit der Umwandlung von verdoppelt wegen der Kultureinstellungen. Also habe ich hinzugefügt

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

Noch eine Variation. Behandelt Nullables sowie Situationen, in denen die Zeichenfolge null und T nicht nullable ist.

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

Sie können dies in einer Zeile wie folgt tun:

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

Viel Spaß beim Codieren;)