Приведение переменной с использованием переменной типа

В C # я могу привести переменную типа объекта к переменной типа T, где T определена в переменной типа?

Вот пример приведения и преобразования:

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))обеспечивает решение. Convert.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 (кроме реализации интерфейса). Я попробовал что-то немного необычное и сработало для моей ситуации.

Используя пакет Nugets Newtonsoft.Json ...

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

Вред, проблема в том, что у тебя нет T.

у вас есть только переменная типа.

Подсказка для MS, если бы вы могли сделать что-то вроде

TryCast<typeof(MyClass)>

если бы решить все наши проблемы.

Я никогда не пойму, почему вам нужно до 50 репутации, чтобы оставить комментарий, но я просто должен был сказать, что ответ @Curt - это именно то, что я искал, и, надеюсь, кто-то еще.

В моем примере у меня есть атрибут ActionFilterAttribute, который я использовал для обновления значений документа json patch. Я не знал, что такое модель 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));