使用类型变量转换变量

在C＃中，我可以将类型为object的变量转换为类型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方法尝试将任何Object转换为作为第二个参数提供的Type。

例如：

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类型为的Lambda表达式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?

当涉及到枚举类型时：

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

对于通过int值获取多个枚举类型的Description属性值的情况，这对我来说至关重要：

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

在使用Zyphrax的答案没有找到解决方法后，“对象必须实现IConvertible”异常（实现接口除外）。我尝试了一些非常规的方法，并针对我的情况进行了工作。

使用Newtonsoft.Json nuget包...

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

有害，问题在于您没有T。

您只有一个Type变量。

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