如何从反射执行显式操作强制转换

本文关键字：操作 转换 反射 执行 | 更新日期: 2023-09-27 18:08:05

我想使用反射并使用反射进行隐式或显式转换。

如果我这样定义Foo 

public class Foo
{
    public static explicit operator decimal(Foo foo)
    {
        return foo.Value;
    }
    public static explicit operator Foo(decimal number)
    {
        return new Foo(number);
    }
    public Foo() { }
    public Foo(decimal number)
    {
        Value = number;
    }
    public decimal Value { get; set; }
    public override string ToString()
    {
        return Value.ToString();
    }
}

当我运行这段代码

decimal someNumber = 42.42m;
var test = (Foo)someNumber;
Console.WriteLine(test);        // Writes 42.42 No problems

当我尝试用Foo定义一个类作为成员类型并使用反射来设置它时。我得到以下异常:

Error     : Object of type 'System.Decimal' cannot be converted to type 'Foo'.
StackTrace:    at System.RuntimeType.TryChangeType(Object value, Binder binder, CultureInfo culture, Boolean needsSpecialCast)
               at System.RuntimeType.CheckValue(Object value, Binder binder, CultureInfo culture, BindingFlags invokeAttr)
               at System.Reflection.MethodBase.CheckArguments(Object[] parameters, Binder binder, BindingFlags invokeAttr, CultureInfo culture, Signature sig)
               at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture, Boolean skipVisibilityChecks)
               at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
               at System.Reflection.RuntimePropertyInfo.SetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, Object[] index, CultureInfo culture)
               at System.Reflection.RuntimePropertyInfo.SetValue(Object obj, Object value, Object[] index)
下面是我用来设置属性与反射 的代码
public class FooComposite
{
    public Foo Bar { get; set; }
}
var properties = typeof(FooComposite).GetProperties();
var testFoo = new FooComposite();
foreach(var propertyInfo in properties)
{
    propertyInfo.SetValue(testFoo, 17.17m, null);  // Exception generated on this line
}
Console.WriteLine(testFoo.Bar);  // Never gets here

我怎么做这个转换?

如何从反射执行显式操作强制转换

这与你的非反射代码没有什么不同，你仍然需要显式地将数字转换为Foo:

propertyInfo.SetValue(testFoo,(Foo)17.17m, null);

实例:http://rextester.com/rundotnet?code=BPQ74480

出于兴趣，我试了几个替代方案。

  1. 使implicit在Foo -不工作，同样的错误Live
  2. 使用Convert.ChangeType(17.17m,typeof(Foo)) -也不工作。<一口>生活

我需要像Ted H这样的功能，但我是这样实现的:

var cast = typeof(dest).GetMethod("op_Explicit", new Type[] { typeof(source) });
var result = cast.Invoke(null, new object[] {value});

编辑:我最近需要一个更先进的版本，这就是我想到的。请注意，它不包括所有可用的转换。

private static object DynamicCast(object source, Type destType) {
    Type srcType = source.GetType();
    if (srcType == destType) return source;
    var paramTypes = new Type[] { srcType };
    MethodInfo cast = destType.GetMethod("op_Implicit", paramTypes);
    if (cast == null) {
        cast = destType.GetMethod("op_Explicit", paramTypes);
    }
    if (cast != null) return cast.Invoke(null, new object[] { source });
    if (destType.IsEnum) return Enum.ToObject(destType, source);
    throw new InvalidCastException();
}

任何事情都可以通过反射来完成。

我的问题是一个反射方法试图在两个类之间做一个深度复制，因为一个复杂的类型。我试图定义一个explicit operator转换，但它似乎没有被调用，所以我想出了一种方法来通过反射得到它。使用其他一些关于调用静态方法的研究，我发现当将存储在pSource中的复杂类型复制到属性pDest中的不同类型时，这对我来说是有效的。pDest中的类型是从pSource的类型转换而来的。


MethodInfo[] static_methods = pDest.PropertyType.GetMethods(System.Reflection.BindingFlags.Static | BindingFlags.Public);
if (static_methods != null)
{
    foreach (MethodInfo method in static_methods)
    {
        if(method.Name== "op_Explicit")                       // this is a constant
        {                                                     // for explicit operators
            ParameterInfo[] paramSet = method.GetParameters();
            if ((paramSet != null) && (paramSet.Length == 1)) 
            {
                if (paramSet[0].ParameterType == pSource.PropertyType) // match the types!
                {
                    pDest.SetValue(                          // Destination prop
                        dstVar,                              // Destination instance
                        method.Invoke(                       // converter method
                              null,                          // static has no 'this'
                              new object[] {                 // value to convert from
                                  pSource.GetValue(source, null) 
                              }                              // source property on
                                                             // source instance
                        )
                    ); // SetValue(...)
                }
            }
        }
    }
}

dstVar是我的目标实例。pDest是目标实例中的当前PropertyInfo。

source是我的源实例。pSource是源实例中的当前PropertyInfo。

用于目标属性的类型与源属性类型有显式转换，这不需要任何

基于Herman的回答…我意识到源类和目标类都可以定义转换操作符。这是我的版本:

private static bool DynamicCast(object source, Type destType, out object result)
{
    Type srcType = source.GetType();
    if (srcType == destType) { result = source; return true; }
    result = null;
    BindingFlags bf = BindingFlags.Static | BindingFlags.Public;
    MethodInfo castOperator = destType.GetMethods(bf)
                                .Union(srcType.GetMethods(bf))
                                .Where(mi => mi.Name == "op_Explicit" || mi.Name == "op_Implicit")
                                .Where(mi =>
                                {
                                    var pars = mi.GetParameters();
                                    return pars.Length == 1 && pars[0].ParameterType == srcType;
                                })
                                .Where(mi => mi.ReturnType == destType)
                                .FirstOrDefault();
    if (castOperator != null) result = castOperator.Invoke(null, new object[] { source });
    else return false;
    return true;
}
典型用途:

object a = new A();
object o;
if (DynamicCast(a, typeof(B), out o))
{
    B b = (B)o;
    ...
}

注意以下内容:

  • 如果源和目的都定义了转换，则目的转换操作符方法优先
  • 函数返回一个bool值，表示成功/失败，并在out变量中实际转换值(类似于TryParse方法)

感谢以上所有人为我提供了一个良好的开端。我借了，也加了。在我的情况下，我需要上述所有功能，还需要搜索源和目标类型的所有祖先基类型，以查看它们是否包含到目标类型的隐式或显式转换。加上这个额外的要求，我产生了下面的代码:

    private static bool TryCast(object source, Type destType, out object result)
    {
        Type srcType = source.GetType();
        if (srcType == destType)
        {
            result = source;
            return true;
        }
        MethodInfo cast = null;
        while (cast == null && srcType != typeof(object))
        {
            cast = GetCastMethod(srcType, srcType, destType);
            if (cast == null) cast = GetCastMethod(destType, srcType, destType);
            srcType = srcType.BaseType;
        }
        if (cast != null)
        {
            result = cast.Invoke(null, new object[] { source });
            return true;
        }
        if (destType.IsEnum)
        {
            result = Enum.ToObject(destType, source);
            return true;
        }
        result = null;
        return false;
    }
    private static MethodInfo GetCastMethod(Type typeWithMethod, Type srcType, Type destType)
    {
        while (typeWithMethod != typeof(object))
        {
            foreach (MethodInfo method in typeWithMethod.GetMethods(BindingFlags.Static | BindingFlags.Public))
            {
                if (method.ReturnType == destType && (method.Name == "op_Explicit" || method.Name == "op_Implicit"))
                {
                    ParameterInfo[] parms = method.GetParameters();
                    if (parms != null && parms.Length == 1 && parms[0].ParameterType == srcType)
                        return method;
                }
            }
            typeWithMethod = typeWithMethod.BaseType;
        }
        return null;
    }
相关文章：