Type değişkeni kullanarak bir değişkeni döküm

C # 'da tip nesnesinin bir değişkenini T tipinde bir değişkene atabilir miyim; burada T, Type değişkeninde tanımlanır mı?

İşte bir cast ve convert örneği:

using System;

public T CastObject<T>(object input) {   
    return (T) input;   
}

public T ConvertObject<T>(object input) {
    return (T) Convert.ChangeType(input, typeof(T));
}

Düzenle:

Yorumlardaki bazı insanlar bu cevabın soruya cevap vermediğini söylüyor. Ancak hat (T) Convert.ChangeType(input, typeof(T))çözüm sağlar. Convert.ChangeTypeYöntem, ikinci argüman olarak verilen Tip herhangi Nesne çevirmeye çalışır.

Örneğin:

Type intType = typeof(Int32);
object value1 = 1000.1;

// Variable value2 is now an int with a value of 1000, the compiler 
// knows the exact type, it is safe to use and you will have autocomplete
int value2 = Convert.ChangeType(value1, intType);

// Variable value3 is now an int with a value of 1000, the compiler
// doesn't know the exact type so it will allow you to call any
// property or method on it, but will crash if it doesn't exist
dynamic value3 = Convert.ChangeType(value1, intType);

Cevabı jeneriklerle yazdım, çünkü gerçek bir tür kullanmadan döküm a somethingyapmak istediğinizde kod kokusunun çok muhtemel bir işareti olduğunu düşünüyorum a something else. % 99.9'unun gerekli olmaması gereken uygun arayüzlerle. Belki de mantıklı olabileceği düşüncesine gelince birkaç son durum vardır, ancak bu davalardan kaçınmanızı tavsiye ederim.

Düzenleme 2:

Birkaç ekstra ipucu:

• Kodunuzu olabildiğince tipte güvenli tutmaya çalışın. Derleyici türü bilmiyorsa, kodunuzun doğru olup olmadığını kontrol edemez ve otomatik tamamlama gibi şeyler çalışmaz. Basitçe söylemek gerekirse : derleme zamanında tür (ler) i tahmin edemezseniz, derleyici nasıl yapabilir ?
• Birlikte çalıştığınız sınıflar ortak bir arabirim uyguluyorsa , değeri o arabirime atabilirsiniz. Aksi takdirde kendi arayüzünüzü oluşturmayı düşünün ve sınıfların bu arayüzü uygulamasını sağlayın.
• Dinamik olarak içe aktardığınız harici kitaplıklarla çalışıyorsanız, ortak bir arabirim olup olmadığını da denetleyin. Aksi takdirde, arabirimi uygulayan küçük sarıcı sınıfları oluşturmayı düşünün.
• Nesne üzerinde arama yapmak istiyorsanız, ancak türle ilgilenmiyorsanız, değeri bir objectveya dynamicdeğişkeninde saklayın .
• Jenerikler , dahil olan kesin tipleri bilmeden birçok farklı tip için geçerli yeniden kullanılabilir kod oluşturmanın harika bir yolu olabilir.
• Sıkışırsanız, farklı bir yaklaşım veya kod refactoru düşünün. Kodunuzun gerçekten bu dinamik olması gerekiyor mu? Var olan herhangi bir türü hesaba katmak zorunda mı?

Diğer cevaplar "dinamik" tipten bahsetmez. Bir cevap daha eklemek için, dönüştürülen nesneyi statik türle yayınlamak zorunda kalmadan sonuç nesnenizi saklamak için "dinamik" türü kullanabilirsiniz.

dynamic changedObj = Convert.ChangeType(obj, typeVar);
changedObj.Method();

"Dinamik" kullanımıyla derleyicinin, dikkatli değilseniz olası çalışma zamanı hataları oluşturabilecek statik tür denetimini atladığını unutmayın.

İşte benim nesne bir System.Typedinamik değil, genel bir tür değişkenine değil, bir nesne döküm yöntemi :

Girdi kutusundan, türünü istenen tür dönüşüm gerçekleştirir System.Linq.Expressionstürünü kullanarak türünü kullanarak çalışma zamanında lambda ifade oluşturmak Func<object, object>sonra sonuç kutulu verir. Sadece dökülen tüm tipler için değil, aynı zamanda dökülen tipler için de (kutu açma adımı nedeniyle) yeni bir tane gereklidir. Bu ifadelerin oluşturulması, kaputun altında yapılan yansıma, derleme ve dinamik yöntem oluşturma nedeniyle oldukça zaman alıcıdır. Neyse ki oluşturulduktan sonra, ifadeler tekrar tekrar ve yüksek ek yük olmadan çağrılabilir, bu yüzden her birini önbelleğe alırım.

private static Func<object, object> MakeCastDelegate(Type from, Type to)
{
    var p = Expression.Parameter(typeof(object)); //do not inline
    return Expression.Lambda<Func<object, object>>(
        Expression.Convert(Expression.ConvertChecked(Expression.Convert(p, from), to), typeof(object)),
        p).Compile();
}

private static readonly Dictionary<Tuple<Type, Type>, Func<object, object>> CastCache
= new Dictionary<Tuple<Type, Type>, Func<object, object>>();

public static Func<object, object> GetCastDelegate(Type from, Type to)
{
    lock (CastCache)
    {
        var key = new Tuple<Type, Type>(from, to);
        Func<object, object> cast_delegate;
        if (!CastCache.TryGetValue(key, out cast_delegate))
        {
            cast_delegate = MakeCastDelegate(from, to);
            CastCache.Add(key, cast_delegate);
        }
        return cast_delegate;
    }
}

public static object Cast(Type t, object o)
{
    return GetCastDelegate(o.GetType(), t).Invoke(o);
}

Bunun sihir olmadığını unutmayın. Kodda, dynamicanahtar kelimeyle olduğu gibi, yalnızca nesnenin temel verileri dönüştürülür. Derleme zamanında, nesnemizin ne tür olabileceğini titizlikle anlamaya devam ediyoruz ve bu çözümü pratik yapmıyoruz. Bunu rastgele türler tarafından tanımlanan dönüşüm operatörlerini çağırmak için bir hack olarak yazdım, ancak belki de birileri daha iyi bir kullanım durumu bulabilir.

Boks ve kutuyu basitleştirmek için bir kenara bıraktığınızda, miras hiyerarşisi boyunca dökümle ilgili belirli bir çalışma zamanı eylemi yoktur. Çoğunlukla derleme zamanı. Esasen, bir kadro, derleyiciye değişkenin değerini başka bir tür olarak ele almasını söyler.

Oyunculardan sonra ne yapabilirsiniz? Türü bilmiyorsunuz, bu yüzden üzerinde herhangi bir yöntem çağıramazsınız. Yapabileceğin özel bir şey olmazdı. Özellikle, yalnızca derleme zamanında olası türleri biliyorsanız, manuel olarak yayınlar ve her bir vakayı ififadelerle ayrı ayrı ele alırsanız yararlı olabilir :

if (type == typeof(int)) {
    int x = (int)obj;
    DoSomethingWithInt(x);
} else if (type == typeof(string)) {
    string s = (string)obj;
    DoSomethingWithString(s);
} // ...

Bunu nasıl yapabildin? Dökümden sonra nesneyi depolayabileceğiniz T tipi bir değişkene veya alana ihtiyacınız vardır, ancak T'yi yalnızca çalışma zamanında biliyorsanız, böyle bir değişkene veya alana nasıl sahip olabilirsiniz? Yani, hayır, bu mümkün değil.

Type type = GetSomeType();
Object @object = GetSomeObject();

??? xyz = @object.CastTo(type); // How would you declare the variable?

xyz.??? // What methods, properties, or fields are valid here?

Enum tipine döküm söz konusu olduğunda:

private static Enum GetEnum(Type type, int value)
    {
        if (type.IsEnum)
            if (Enum.IsDefined(type, value))
            {
                return (Enum)Enum.ToObject(type, value);
            }

        return null;
    }

Ve şöyle diyeceksiniz:

var enumValue = GetEnum(typeof(YourEnum), foo);

İnt değerine göre birkaç enum türünün Description özniteliği değerini almak durumunda bu benim için önemliydi:

public enum YourEnum
{
    [Description("Desc1")]
    Val1,
    [Description("Desc2")]
    Val2,
    Val3,
}

public static string GetDescriptionFromEnum(Enum value, bool inherit)
    {
        Type type = value.GetType();

        System.Reflection.MemberInfo[] memInfo = type.GetMember(value.ToString());

        if (memInfo.Length > 0)
        {
            object[] attrs = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), inherit);
            if (attrs.Length > 0)
                return ((DescriptionAttribute)attrs[0]).Description;
        }

        return value.ToString();
    }

ve sonra:

string description = GetDescriptionFromEnum(GetEnum(typeof(YourEnum), foo));
string description2 = GetDescriptionFromEnum(GetEnum(typeof(YourEnum2), foo2));
string description3 = GetDescriptionFromEnum(GetEnum(typeof(YourEnum3), foo3));

Alternatif olarak (daha iyi yaklaşım), bu tür dökümler şöyle görünebilir:

 private static T GetEnum<T>(int v) where T : struct, IConvertible
    {
        if (typeof(T).IsEnum)
            if (Enum.IsDefined(typeof(T), v))
            {
                return (T)Enum.ToObject(typeof(T), v);
            }

        throw new ArgumentException(string.Format("{0} is not a valid value of {1}", v, typeof(T).Name));
    }

Zyphrax'ın cevabını (arayüzün uygulanması hariç) kullanırken "Nesne IConvertible uygulamalıdır" istisnası etrafında bir şey bulamadıktan sonra .. Biraz alışılmadık bir şey denedim ve durumum için çalıştı.

Newtonsoft.Json nuget paketini kullanarak ...

var castedObject = JsonConvert.DeserializeObject(JsonConvert.SerializeObject(myObject), myType);

Zarar, sorun şu ki T yok.

yalnızca bir Type değişkeniniz var.

MS'e ipucu, eğer böyle bir şey yapabilirsen

TryCast<typeof(MyClass)>

eğer tüm sorunları çözecekti.

Bir yorum bırakmak için neden 50'ye kadar itibara ihtiyacınız olduğunu asla anlamayacağım ama sadece @Curt cevabının tam olarak aradığım şey olduğunu ve umarım bir başkası olduğunu söylemek zorundaydım.

Örneğimde, json düzeltme eki belgesinin değerlerini güncellemek için kullandığım ActionFilterAttribute var. T modeli için yama belgesi ne oldu ben seri hale getirmek ve düz bir JsonPatchDocument onu serileştirmek zorunda kaldı, onu değiştirmek, sonra türü vardı, tekrar serileştirmek ve serisini tekrar türüne.

Type originalType = //someType that gets passed in to my constructor.

var objectAsString = JsonConvert.SerializeObject(myObjectWithAGenericType);
var plainPatchDocument = JsonConvert.DeserializeObject<JsonPatchDocument>(objectAsString);

var plainPatchDocumentAsString= JsonConvert.SerializeObject(plainPatchDocument);
var modifiedObjectWithGenericType = JsonConvert.DeserializeObject(plainPatchDocumentAsString, originalType );

public bool TryCast<T>(ref T t, object o)
{
    if (
        o == null
        || !typeof(T).IsAssignableFrom(o.GetType())
        )
        return false;
    t = (T)o;
    return true;
}

daha temiz:

    public static bool TryCast<T>(ref T t, object o)
    {
        if (!(o is T))
        {
            return false;
        }

        t = (T)o;
        return true;
    }

Hedef türünü bilmeden çalışma zamanında nesneleri yayınlamanız gerekiyorsa, dinamik bir dönüştürücü yapmak için yansımayı kullanabilirsiniz.

Bu basitleştirilmiş bir sürümdür (oluşturulan yöntemi önbelleğe almadan):

    public static class Tool
    {
            public static object CastTo<T>(object value) where T : class
            {
                return value as T;
            }

            private static readonly MethodInfo CastToInfo = typeof (Tool).GetMethod("CastTo");

            public static object DynamicCast(object source, Type targetType)
            {
                return CastToInfo.MakeGenericMethod(new[] { targetType }).Invoke(null, new[] { source });
            }
    }

o zaman arayabilirsiniz:

    var r = Tool.DynamicCast(myinstance, typeof (MyClass));