Wie führe ich die explizite operation casting von Reflexion?

Will ich mit Reflexion und entweder eine implizite oder explizite coversion mit der spiegelung.

Gegeben, die ich definiert haben, Foo diese Weise

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

Wenn ich diesen code ausführen

decimal someNumber = 42.42m;

var test = (Foo)someNumber;

Console.WriteLine(test);        //Writes 42.42 No problems

Wenn ich versuche, eine Klasse zu definieren, die mit Foo als Mitglied geben und reflektion verwenden, um es zu setzen. Ich bekomme die folgende Ausnahme.

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)

Hier ist der code, den ich verwenden, um die Eigenschaft der reflektion

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

Wie kann ich diese Konvertierung?

Wenn Sie wollen, um dies dynamisch und nicht code der Besetzung, Marc Tat etwas, was sehr nahe an dem, was du suchst über auf MSDN-Foren, die mithilfe von Ausdrücken (Lesen Sie die ganze Diskussion, nicht nur die Antwort). Siehe: social.msdn.microsoft.com/Forums/eu/csharplanguage/thread/...

InformationsquelleAutor David Basarab | 2011-09-08

c#explicit-conversion implicit-conversion operators

5

Nun, es ist wirklich nicht anders als Ihre nicht-Reflex-code, müssen Sie noch explizit umgewandelt, die Zahl in eine Foo:
```
propertyInfo.SetValue(testFoo,(Foo)17.17m, null);
```
Live-Beispiel: http://rextester.com/rundotnet?code=BPQ74480

Aus Interesse habe ich versucht ein paar alternativen.
1. Machen es zu einem implicit cast in Foo - funktioniert nicht, gleiche Fehlermeldung ^Live
2. Verwenden Convert.ChangeType(17.17m,typeof(Foo)) - auch nicht funktioniert. ^Live
- Dies ist ein guter blog-post, dass die Gespräche mehr über dieses Thema boxing und unboxing. philosopherdeveloper.wordpress.com/2010/05/05/...
InformationsquelleAutor Jamiec

Sah ich diese Frage heute zu stellen, während Sie versuchen, kopieren Sie Felder, die mit Namen zwischen zwei Objekten. Ich war ziemlich enttäuscht zu sehen, die gewählte Antwort war "Sie kann nur explizit aufgerufen werden, einen expliziten operator." Nach allem, was sonst getan werden kann, durch Reflexion.

Mein problem war ein Spiegelbild-Methode versuchen, um eine Tiefe Kopie zwischen zwei Klassen, weil von einem komplexen Typ. Ich habe versucht, zu definieren, eine explicit operator Konvertierung, aber es schien nicht genannt, bekommen, so habe ich herausgefunden, einen Weg, um es durch Reflexion. Mit einigen anderen Forschungseinrichtungen über den Aufruf von statischen Methoden, die ich fand, das funktioniert für mich beim kopieren eines komplexen Typs in pSource in eine andere Eigenschaft pDest. der Typ in pDest hat eine Wandlung von pSource Typ.


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 ist mein Ziel-Instanz.
pDest ist die aktuelle PropertyInfo in die Ziel-Instanz.

Quelle ist meine Quell-Instanz.
pSource ist die aktuelle PropertyInfo in der Quell-Instanz.

Der Typ, für mein Ziel-Eigenschaft hat, eine explizite Konvertierung aus der Eigenschaft source geben, das funktioniert ohne

InformationsquelleAutor Ted H

4

Ich benötigte Funktionalität, wie Ted H, aber ich setzte es so:
```
var cast = typeof(dest).GetMethod("op_Explicit", new Type[] { typeof(source) });
var result = cast.Invoke(null, new object[] {value});
```
Edit: ich brauchte eine weiter entwickelte version vor kurzem, und dies ist, was ich kam mit. Beachten Sie, dass es nicht für alle verfügbaren Konvertierungen.
```
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();

}
```
- Beachten Sie, dass sowohl die Quell-und Ziel-Typen erlauben kann, Konvertierungs-Operatoren. So, zum Beispiel, wenn Sie eine explizite Konvertierung von A nach B ist, dann kann dies definiert werden, die in Klasse A oder Klasse B, oder beide.
- Ich glaube ich habe es umgesetzt, wie dies absichtlich. Vielleicht so, dass es stimmt, so funktioniert es in statische c# - code, aber ich bin mir nicht sicher. Wenn Sie wirklich wollen, zu tun umfangreiche Konvertierungen, die Sie möchten vielleicht auch einen Blick in die Convert Klasse und TypeConverter's.
InformationsquelleAutor Herman

Gebäude auf Herman ' s Antwort... ich erkannte, dass sowohl die Quell-und Ziel-Klasse definieren kann, die conversion operator. So, hier ist meine version:

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

Typische Verwendung:

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

Ist Folgendes zu beachten:

Wenn die Konvertierung definiert ist, in dem Quell-und dem Ziel, die Ziel-conversion-operator-Methode hat Vorrang
Die Funktion gibt einen booleschen Wert, der angibt, Erfolg/Misserfolg, und der tatsächliche Wert umgewandelt in eine out variable (ähnlich TryParse-Methoden)

InformationsquelleAutor Michael Bray

Danke an alle, die oben für ein toller start für das, was ich brauchte. Ich lieh mir und auch Hinzugefügt. In meiner situation, die ich brauchte, alle der oben genannten und auch gebraucht Suche alle Vorfahren Basis-Typen für die Quell-und Ziel-Typ zu sehen, wenn einer von Ihnen enthalten eine implizite oder explizite Konvertierung zu meinem Ziel-Typen. Das hinzufügen dieser zusätzlichen Bedingung, die ich produziert die unten.

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

InformationsquelleAutor Shawn

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.