Genel tip dönüşüm FROM dizesi

Başka bir sınıf için "özellikleri" depolamak için kullanmak istediğiniz bir sınıf var. Bu özelliklerin bir adı ve değeri vardır. İdeal olarak, ne istiyorum eklemek mümkün olmaktır daktilo döndü "değer" Ben olmak istiyorum hep tiptedir böylece, özellikleri.

Tip her zaman ilkel olmalıdır. Bu sınıf, adı ve değeri temel olarak dize olarak saklayan soyut bir sınıfın alt sınıfını oluşturur. Bu alt sınıfın temel sınıfa bir tür güvenlik ekleyeceği (ve beni bazı dönüşümlerde koruyacağı) fikri.

Yani, (kabaca) bu bir sınıf yarattık:

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

Soru şu:

Dizeden bir ilkele dönüştürmenin "genel" bir yolu var mı?

( ITryParsable gibi bir şey ideal olurdu!) Yönetim Kurulu arasında dönüşüm bağlayan herhangi bir genel arayüzü bulamıyorum .

Niyetlerini doğru anladığımdan emin değilim, ama bunun yardımcı olup olmadığını görelim.

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

lubos hasko'nun yöntemi nullables için başarısız oluyor. Aşağıdaki yöntem nullables için işe yarayacaktır. Yine de gelmedim. Google üzerinden buldum: http://web.archive.org/web/20101214042641/http://dogaoztuzun.com/post/C-Generic-Type-Conversion.aspx "Tuna Toksoz" a Kredi

İlk kullanım:

TConverter.ChangeType<T>(StringValue);  

Sınıf aşağıda.

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

Birçok tür için (tamsayı, çift, DateTime vb.), Statik bir Ayrıştırma yöntemi vardır. Yansımayı kullanarak onu çağırabilirsiniz:

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)

TypeDescriptorGetConvertorbir Typenesneyi kabul eden yönteme sahip sınıftır ve daha sonra belirtilen nesne için ConvertFromdönüştürmek için yöntem çağırabilirsiniz value.

Muhtemelen bir nitelik sınıfı gibi bir yapı kullanabilirsiniz . Bu şekilde, bir dizeyi kendi türünün değerine nasıl dönüştüreceğini bilen parametreli bir yardımcı sınıfınız olur. O zaman alacağınız şöyle görünebilir:

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

Şimdi, parametreli türlerle ilgili deneyimimin C ++ ve şablonlarıyla sınırlı olduğunu belirtmeliyim, ancak C # jeneriklerini kullanarak aynı tür bir şey yapmanın bir yolu olduğunu hayal ediyorum.

Statiği kontrol edin Nullable.GetUnderlyingType. - Temel alınan tür null ise, template parametresi değildir Nullableve bu türü doğrudan kullanabiliriz - Temeldeki tür null değilse, dönüşümde temel alınan türü kullanın.

Benim için iş gibi görünüyor:

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

Bob'un cevabından esinlenerek , bu uzantılar null değer dönüşümünü ve tüm ilkel dönüşümleri dördüncü ve dördüncü olarak destekler.

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

Örnekler

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

Bir nesne üzerinden dönüştürme kullanıyorum. Biraz daha basit.

Lobos cevabını kullandım ve işe yarıyor. Ama kültür ortamından dolayı iki katına dönüşümle ilgili bir sorunum vardı . Ben de ekledim

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

Yine başka bir varyasyon. Nullables öğesinin yanı sıra dizenin boş ve T'nin boş bırakılmadığı durumları işler.

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

Aşağıdaki gibi bir satırda yapabilirsiniz:

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

Mutlu kodlama;)