Кастинг змінної за допомогою змінної Type

Чи можу я занести змінну об'єкта типу до змінної типу T, де T визначено в змінній Type?

Ось приклад анонсу та перетворення:

using System;

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

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

Редагувати:

Деякі люди в коментарях кажуть, що ця відповідь не відповідає на питання. Але лінія (T) Convert.ChangeType(input, typeof(T))забезпечує рішення. TheConvert.ChangeTypeМетод намагається перетворити будь-який об'єкт типу при умови в якості другого аргументу.

Наприклад:

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

Я написав відповідь із дженериками, тому що я думаю, що це дуже ймовірний ознака запаху коду, коли ви хочете a somethingперейти a something elseбез обробки фактичного типу. З належним інтерфейсом, який не повинен бути необхідним у 99,9% разів. Можливо, є кілька крайніх випадків, коли мова йде про роздуми, що це може мати сенс, але я б рекомендував уникати цих випадків.

Редагувати 2:

Кілька додаткових порад:

• Постарайтеся зберегти свій код максимально безпечним для типу. Якщо компілятор не знає тип, він не може перевірити, чи правильний ваш код, і такі речі, як автозаповнення, не працюватимуть. Простіше сказати: якщо ви не можете передбачити тип (и) типу під час компіляції, то як би компілятор міг би це зробити ?
• Якщо класи, з якими ви працюєте, реалізують загальний інтерфейс , ви можете передати значення цьому інтерфейсу. В іншому випадку розгляньте можливість створення власного інтерфейсу та запропонуйте класам реалізувати цей інтерфейс.
• Якщо ви працюєте із зовнішніми бібліотеками, які ви динамічно імпортуєте, то також перевірте наявність загального інтерфейсу. В іншому випадку розгляньте можливість створення невеликих класів обгортки, які реалізують інтерфейс.
• Якщо ви хочете здійснювати дзвінки по об'єкту, але вам не байдужий тип, збережіть значення у objectабо dynamicзмінній.
• Генерика може бути чудовим способом створення коду для багаторазового використання, який застосовується до багатьох різних типів, без необхідності знати точні типи.
• Якщо ви застрягли, то розгляньте інший підхід або рефактор коду. Чи дійсно ваш код повинен бути таким динамічним? Чи має він враховувати будь-який тип?

В інших відповідях не згадується "динамічний" тип. Отже, щоб додати ще одну відповідь, ви можете використовувати тип "динамічний", щоб зберігати отриманий об'єкт без необхідності викидати перетворений об'єкт зі статичним типом.

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

Майте на увазі, що за допомогою "динамічного" компілятор обходить перевірку статичного типу, яка може ввести можливі помилки виконання, якщо ви не будете обережні.

Ось мій метод передавання об'єкта, але не до загальної змінної типу, а System.Typeдинамічно:

Я створюю лямбда-вираз під час виконання, використовуючи System.Linq.Expressions, типу Func<object, object>, який розпаковує його введення, виконує перетворення потрібного типу, а потім дає результат в полі. Новий потрібен не лише для всіх типів, на які потрапляють касти, а й для типів, які отримують кастинг (через крок розпакування). Створення цих виразів забирає багато часу через відображення, компіляцію та побудову динамічного методу, що робиться під кришкою. На щастя, колись створені, вирази можна викликати неодноразово і без великих накладних витрат, тому я кешую кожен з них.

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

Зауважте, що це не магія. Кастинг не відбувається в коді, як це робиться з dynamicключовим словом, перетворюються лише основні дані об'єкта. Під час компіляції нам залишається кропітко розібратися, яким саме типом може бути наш об’єкт, що робить це рішення непрактичним. Я написав це як хак, щоб викликати операторів перетворення, визначених довільними типами, але, можливо, хтось там може знайти кращий варіант використання.

Відкладаючи бокс і розблокування для простоти, немає конкретних дій виконання, пов'язаних з кастингом за ієрархією спадкування. Це здебільшого час компіляції. По суті, команда вказує компілятору трактувати значення змінної як інший тип.

Що ви могли зробити після акторського складу? Ви не знаєте типу, тому ви не зможете зателефонувати на нього. Не було б нічого особливого, що ви могли б зробити. Зокрема, він може бути корисним лише у тому випадку, якщо ви знаєте можливі типи під час компіляції, передайте їх вручну та обробляйте кожен випадок окремо із ifзаявами:

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

Як ти міг це зробити? Вам потрібна змінна або поле типу T, де ви можете зберігати об’єкт після виступу, але як ви можете мати таку змінну чи поле, якщо ви знаєте T лише під час виконання? Отже, ні, це неможливо.

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:

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

        return null;
    }

І ви назвете це так:

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

Для мене це було важливим у випадку отримання значення атрибута Description для кількох типів перерахунків за значенням 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();
    }

і потім:

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

Як варіант (кращий підхід), такий кастинг може виглядати так:

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

Не знайшовши нічого, щоб обійти виняток "Об'єкт повинен реалізувати IConvertible" виняток при використанні відповіді Zyphrax (за винятком реалізації інтерфейсу). Я спробував щось трохи нетрадиційне і працював у своїй ситуації.

Використання нукетного пакету Newtonsoft.Json ...

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

Шкода, проблема в тому, що ти не маєш Т.

у вас є лише змінна типу.

Підкажіть MS, якщо ви могли зробити щось подібне

TryCast<typeof(MyClass)>

якби вирішити всі наші проблеми.

Я ніколи не зрозумію, чому вам потрібно до 50 репутації, щоб залишити коментар, але я просто повинен був сказати, що відповідь @Curt - це саме те, що я шукав і, сподіваюся, хтось інший.

У своєму прикладі у мене є ActionFilterAttribute, який я використовував для оновлення значень патч-документа json. Я не зробив те, що було T-моделлю для патч-документа, мені довелося серіалізувати та десеріалізувати його до звичайного JsonPatchDocument, змінити його, а тому, що я мав тип, серіалізувати та десеріалізувати його знову до типу.

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

ще чистіше:

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

        t = (T)o;
        return true;
    }

Якщо вам потрібно викидати об'єкти під час виконання, не знаючи тип призначення, ви можете використовувати відображення для створення динамічного перетворювача.

Це спрощена версія (без кешованого створеного методу):

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

тоді ви можете назвати це:

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