Ayrıştırmayı kullanarak bir dizeyi herhangi bir türe dönüştürecek genel Parse () işlevi var mı?

Bir dizeyi genel dönüş türüne göre intveya dateveya buna longgöre genel bir türe dönüştürmek istiyorum .

Temelde böyle bir işlev Parse<T>(String), bir tür öğe döndürür T.

Örneğin, bir int geçirildiyse, işlev int.parsedahili olarak yapmalıdır .

System.Convert.ChangeType

Örneğinize göre şunları yapabilirsiniz:

int i = (int)Convert.ChangeType("123", typeof(int));
DateTime dt = (DateTime)Convert.ChangeType("2009/12/12", typeof(DateTime));

"Genel dönüş türü" gereksiniminizi karşılamak için kendi uzantı yönteminizi yazabilirsiniz:

public static T ChangeType<T>(this object obj)
{
    return (T)Convert.ChangeType(obj, typeof(T));
}

Bu, şunları yapmanıza izin verecektir:

int i = "123".ChangeType<int>();

Görünüşe göre bu konuya cevap vermek için çok geç kaldım. Ama işte benim uygulamam:

Temel olarak, Object sınıfı için bir Extention yöntemi oluşturdum. Null yapılabilir, sınıflar ve yapı gibi tüm türleri işler.

 public static T ConvertTo<T>(this object value)
           {
               T returnValue;

               if (value is T variable)
                   returnValue = variable;
               else
                   try
                   {
                       //Handling Nullable types i.e, int?, double?, bool? .. etc
                       if (Nullable.GetUnderlyingType(typeof(T)) != null)
                       {
                           TypeConverter conv = TypeDescriptor.GetConverter(typeof(T));
                           returnValue = (T) conv.ConvertFrom(value);
                       }
                       else
                       {
                           returnValue = (T) Convert.ChangeType(value, typeof(T));
                       }
                   }
                   catch (Exception)
                   {
                       returnValue = default(T);
                   }

               return returnValue;
           }

System.Convert.ChangeTypeherhangi bir türe dönüşmez. Aşağıdakileri düşünün:

• null yapılabilir türler
• numaralandırmalar
• Kılavuz vb.

Bu dönüşümler, ChangeType'ın bu uygulamasıyla mümkündür .

Pranay'ın cevabının daha temiz versiyonu

public static T ConvertTo<T>(this object value)
{
    if (value is T variable) return variable;

    try
    {
        //Handling Nullable types i.e, int?, double?, bool? .. etc
        if (Nullable.GetUnderlyingType(typeof(T)) != null)
        {
            return (T)TypeDescriptor.GetConverter(typeof(T)).ConvertFrom(value);
        }

        return (T)Convert.ChangeType(value, typeof(T));
    }
    catch (Exception)
    {
        return default(T);
    }
}

.NET'te nesneleri bir türden diğerine dönüştürmek için kullanılan birkaç kural vardır.

• Convert.ChangeType tip aletlerin eğer IConvertible
• Türde TypeConverterAttribute varsa TypeDescriptor.GetConverter

Ancak bu yöntemler, tipik yöntemlerden çok daha yavaştır T.Parse(string), kutulamaya neden olur ve tek bir değeri her dönüştürmek istediğinizde çok sayıda ayırma gerektirir.

İçin ValueString , ben, yansıma kullanarak tipte uygun, statik ayrıştırma yöntemi bulmak çağırmak lambda ifade inşa etmek ve ileride kullanılmak üzere derlenmiş temsilci (Bkz önbelleğe seçti bu cevabı bir örnek için).

Ayrıca, türün uygun bir ayrıştırma yöntemi yoksa yukarıda bahsettiğim yöntemlere de geri dönüyor ( Benioku dosyasındaki performans bölümüne bakın ).

var v = new ValueString("15"); // struct
var i = v.As<int>(); // Calls int.Parse.