Typowa konwersja typu z ciągu

Mam klasę, której chcę użyć do przechowywania „właściwości” innej klasy. Te właściwości mają po prostu nazwę i wartość. Idealnie, chciałbym móc dodawać właściwości pisane na maszynie , tak aby zwracana „wartość” była zawsze zgodna z typem, jaki chcę.

Ten typ powinien zawsze być prymitywny. Ta klasa podklasuje klasę abstrakcyjną, która zasadniczo przechowuje nazwę i wartość jako ciąg znaków. Pomysł polega na tym, że ta podklasa doda pewne bezpieczeństwo typu do klasy bazowej (a także uratuje mnie przy pewnej konwersji).

Stworzyłem klasę, która jest (z grubsza) tym:

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

Pytanie brzmi:

Czy istnieje „ogólny” sposób na konwersję łańcucha znaków z powrotem na prymityw?

Nie mogę znaleźć żadnego ogólnego interfejsu, który łączy konwersję na całym forum (coś takiego jak ITryParsable byłoby idealne!).

Nie jestem pewien, czy poprawnie zrozumiałem twoje intencje, ale zobaczmy, czy to pomaga.

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

Metoda lubos hasko zawodzi w przypadku wartości zerowych. Poniższa metoda będzie działać w przypadku wartości zerowych. Jednak nie wpadłem na to. Znalazłem go za pośrednictwem Google: http://web.archive.org/web/20101214042641/http://dogaoztuzun.com/post/C-Generic-Type-Conversion.aspx Kredyt dla „Tuna Toksoz”

Pierwsze użycie:

TConverter.ChangeType<T>(StringValue);  

Klasa jest poniżej.

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

Dla wielu typów (liczba całkowita, podwójna, data i godzina itp.) Istnieje statyczna metoda analizy składni. Możesz go wywołać za pomocą odbicia:

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)

TypeDescriptorjest klasą posiadającą metodę, GetConvertorktóra akceptuje Typeobiekt, a następnie można wywołać ConvertFrommetodę konwersji valuetego określonego obiektu.

Możesz użyć konstrukcji takiej jak klasa cech . W ten sposób uzyskałbyś sparametryzowaną klasę pomocnika, która wie, jak przekonwertować ciąg znaków na wartość własnego typu. Wtedy twój getter może wyglądać następująco:

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

Teraz muszę zaznaczyć, że moje doświadczenie ze sparametryzowanymi typami jest ograniczone do C ++ i jego szablonów, ale wyobrażam sobie, że jest jakiś sposób na zrobienie tego samego za pomocą generycznych C #.

Sprawdź statyczny Nullable.GetUnderlyingType. - Jeśli typ bazowy ma wartość NULL, parametr szablonu nie jest Nullablei możemy użyć tego typu bezpośrednio - Jeśli typ bazowy nie ma wartości NULL, użyj typu bazowego w konwersji.

Wydaje się dla mnie pracować:

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

Z inspiracji odpowiedzią Boba te rozszerzenia obsługują również konwersję wartości zerowej i wszystkie pierwotne konwersje wstecz i czwarte.

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

Przykłady

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

Korzystam z konwersji za pomocą obiektu. To jest trochę prostsze.

Użyłem odpowiedzi lobos i to działa. Miałem jednak problem z konwersją podwójnych z powodu ustawień kultury. Więc dodałem

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

Kolejna odmiana. Obsługuje wartości zerowalne, a także sytuacje, w których ciąg jest zerowy, a liter T nie ma wartości zerowej .

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

Możesz to zrobić w jednym wierszu, jak poniżej:

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

Szczęśliwego kodowania;)