Как я могу выполнить явное кастинг с размышлением?

https://stackoverflow.com/questions/7351289

28-10-2019
|

Вопрос

Я хочу использовать отражение и сделать либо неявную, либо явную обложку, используя отражение.

Учитывая, что я определил Фу таким образом

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

Из интереса я попробовал несколько альтернатив.

Сделать это implicit сбрасывать в Foo - не работает, та же ошибка ^Жить
Использовать Convert.ChangeType(17.17m,typeof(Foo)) - Также не работает. ^Жить

Другие советы

Я посмотрел на этот вопрос сегодня, пытаясь скопировать поля по имени между объектами. Я был совершенно разочарован, увидев выбранный ответ: «Вы можете только явно вызвать явного оператора». В конце концов, все остальное может быть сделано по отражению.

Моя проблема была методом отражения, пытающимся сделать глубокую копию между двумя классами из -за сложного типа. Я попытался определить explicit operator Преобразование, но, похоже, его не вызвали, поэтому я выяснил способ получить его по размышлению. Используя некоторые другие исследования о вызове статических методов, я обнаружил, что это работает для меня при копировании сложного типа, хранящегося в Psource в другой тип PDEST Property. Тип в 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 является текущим свойством в экземпляре назначения.

Источник - мой экземпляр исходного источника. PSOURCE является текущим свойством в экземпляре Source.

Тип, используемый для свойства моего назначения, имеет явное преобразование из типа свойства источника, это работает без необходимости

Мне нужна была функциональность, как Тед 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();

}

Строительство на Ответ Германа... Я понял, что как исходный, так и класс назначения могут определить оператора конверсии. Итак, вот моя версия:

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

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow