Casting variabel menggunakan variabel Type

Dalam C # dapatkah saya melemparkan variabel tipe objek ke variabel tipe T di mana T didefinisikan dalam variabel Type?

Berikut adalah contoh pemeran dan orang yang insaf:

using System;

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

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

Edit:

Beberapa orang di komentar mengatakan bahwa jawaban ini tidak menjawab pertanyaan. Tapi jalurnya (T) Convert.ChangeType(input, typeof(T))menyediakan solusi. The Convert.ChangeTypeMetode mencoba untuk mengkonversi Obyek apapun untuk Type disediakan sebagai argumen kedua.

Sebagai contoh:

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

Aku sudah menulis jawaban dengan obat generik, karena saya pikir itu adalah sangat mungkin menandatangani kode bau ketika Anda ingin cor a somethinguntuk a something elsetanpa penanganan jenis yang sebenarnya. Dengan antarmuka yang tepat yang seharusnya tidak perlu 99,9% dari waktu. Mungkin ada beberapa kasus tepi ketika datang ke refleksi bahwa itu mungkin masuk akal, tetapi saya akan merekomendasikan untuk menghindari kasus-kasus itu.

Edit 2:

Beberapa tips tambahan:

• Cobalah untuk menjaga kode Anda seaman mungkin. Jika kompiler tidak mengetahui jenisnya, maka ia tidak dapat memeriksa apakah kode Anda benar dan hal-hal seperti pelengkapan otomatis tidak akan berfungsi. Secara sederhana: jika Anda tidak dapat memprediksi tipe pada waktu kompilasi, lalu bagaimana kompiler dapat melakukannya ?
• Jika kelas yang Anda gunakan mengimplementasikan antarmuka umum , Anda bisa memberikan nilai ke antarmuka itu. Kalau tidak, pertimbangkan untuk membuat antarmuka Anda sendiri dan minta kelas mengimplementasikan antarmuka itu.
• Jika Anda bekerja dengan perpustakaan eksternal yang Anda impor secara dinamis, maka periksa juga antarmuka umum. Kalau tidak, pertimbangkan untuk membuat kelas pembungkus kecil yang mengimplementasikan antarmuka.
• Jika Anda ingin melakukan panggilan pada objek, tetapi tidak peduli tentang jenisnya, maka simpan nilai dalam variabel objectatau dynamic.
• Generik dapat menjadi cara yang bagus untuk membuat kode yang dapat digunakan kembali yang berlaku untuk banyak jenis berbeda, tanpa harus mengetahui jenis persisnya.
• Jika Anda mengalami masalah maka pertimbangkan pendekatan atau refactor kode yang berbeda. Apakah kode Anda benar-benar harus dinamis? Apakah harus memperhitungkan jenis apa pun yang ada?

Jawaban lain tidak menyebutkan tipe "dinamis". Jadi, untuk menambahkan satu jawaban lagi, Anda dapat menggunakan tipe "dinamis" untuk menyimpan objek yang dihasilkan tanpa harus membuang objek yang dikonversi dengan tipe statis.

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

Perlu diingat bahwa dengan menggunakan "dinamis" kompiler melewati pemeriksaan tipe statis yang dapat memperkenalkan kemungkinan kesalahan runtime jika Anda tidak hati-hati.

Berikut adalah metode saya untuk melemparkan objek tetapi tidak ke variabel tipe generik, bukan ke System.Typedinamis:

Saya membuat ekspresi lambda pada saat run-time menggunakan System.Linq.Expressions, tipe Func<object, object>, yang membuka kotak inputnya, melakukan konversi tipe yang diinginkan kemudian memberikan hasilnya kotak. Yang baru diperlukan tidak hanya untuk semua jenis yang dicasting, tetapi juga untuk jenis yang dicasting (karena langkah unboxing). Menciptakan ekspresi ini sangat memakan waktu, karena refleksi, kompilasi dan metode dinamis yang dilakukan di bawah tenda. Untungnya sekali dibuat, ekspresi dapat dipanggil berulang kali dan tanpa overhead tinggi, jadi saya cache masing-masing.

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

Perhatikan bahwa ini bukan sihir. Casting tidak terjadi dalam kode, seperti halnya dengan dynamickata kunci, hanya data yang mendasari objek yang akan dikonversi. Pada waktu kompilasi kita masih harus bersusah payah mencari tahu dengan tepat apa jenis objek kita, membuat solusi ini tidak praktis. Saya menulis ini sebagai peretasan untuk memanggil operator konversi yang ditentukan oleh jenis arbitrer, tetapi mungkin seseorang di luar sana dapat menemukan use case yang lebih baik.

Mengesampingkan tinju dan unboxing untuk kesederhanaan, tidak ada tindakan runtime khusus yang terlibat dalam casting di sepanjang hierarki warisan. Ini sebagian besar waktu kompilasi. Pada dasarnya, seorang pemeran memberi tahu kompiler untuk memperlakukan nilai variabel sebagai tipe lain.

Apa yang bisa Anda lakukan setelah para pemain? Anda tidak tahu jenisnya, jadi Anda tidak akan dapat memanggil metode apa pun di dalamnya. Tidak akan ada hal khusus yang dapat Anda lakukan. Secara khusus, ini dapat berguna hanya jika Anda mengetahui jenis yang mungkin pada waktu kompilasi, melemparkannya secara manual dan menangani setiap kasus secara terpisah dengan ifpernyataan:

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

Bagaimana Anda bisa melakukan itu? Anda memerlukan variabel atau bidang tipe T di mana Anda dapat menyimpan objek setelah pemain, tetapi bagaimana Anda bisa memiliki variabel atau bidang tersebut jika Anda tahu T hanya saat runtime? Jadi, tidak, itu tidak mungkin.

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?

Ketika datang untuk casting ke tipe Enum:

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

        return null;
    }

Dan Anda akan menyebutnya seperti itu:

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

Ini penting bagi saya jika mendapatkan nilai atribut Deskripsi beberapa tipe enum berdasarkan nilai int:

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

lalu:

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

Atau (pendekatan yang lebih baik), casting seperti itu bisa terlihat seperti itu:

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

Setelah tidak menemukan apa pun untuk berkeliling "Objek harus menerapkan IConvertible" pengecualian ketika menggunakan jawaban Zyphrax (kecuali untuk mengimplementasikan antarmuka). Saya mencoba sesuatu yang sedikit tidak konvensional dan bekerja untuk situasi saya.

Menggunakan paket nuget Newtonsoft.Json ...

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

Harm, masalahnya adalah Anda tidak memiliki T.

Anda hanya memiliki variabel Type.

Petunjuk ke MS, jika Anda bisa melakukan sesuatu seperti

TryCast<typeof(MyClass)>

jika mau menyelesaikan semua masalah kita.

Saya tidak akan pernah mengerti mengapa Anda perlu hingga 50 reputasi untuk meninggalkan komentar, tetapi saya hanya harus mengatakan bahwa jawaban @Curt persis seperti yang saya cari dan semoga orang lain.

Dalam contoh saya, saya memiliki ActionFilterAttribute yang saya gunakan untuk memperbarui nilai-nilai dokumen patch json. Saya tidak tahu apa model T untuk dokumen tambalan yang harus saya masukkan bersambung & deserialize ke dokumen JsonPatchDocument, modifikasi, lalu karena saya punya jenisnya, sambungkan & deserialisasi kembali ke jenis itu lagi.

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

lebih bersih:

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

        t = (T)o;
        return true;
    }

Jika Anda perlu melemparkan objek saat runtime tanpa mengetahui tipe tujuan, Anda dapat menggunakan refleksi untuk membuat konverter dinamis.

Ini adalah versi yang disederhanakan (tanpa metode caching yang dihasilkan):

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

maka Anda dapat menyebutnya:

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