Getting operators using Reflection

[Plater]

I am having some trouble finding a way to retreive the operators from a custom class.

In a simplified example I have the following:

public class Namespace1.Address
{
    public string City;
    public string State;
 
    public static implicit operator Address(Namespace2.Address value)
    { /* Logic to transform */ }
}
 
public class Namespace2.Address
{
    public string City;
    public string State;
 
    public static implicit operator Address(Namespace1.Address value)
    { /* Logic to transform */ }
}
 

Now I want to use reflection to get the custom operators that exist there (Actually what I want is a bit different, but I *think* this will lead me to THAT goal), and then invoke them?
[code#]
Type myT=Namespace1.Address.GetType();
MemberInfo[] mis=myT.GetMembers(BindingFlags.Public|BindingFlag s.Static);
[/code]
Now after starting this question I figured out that using the Static bindingflag gave me the op_implicit that I had defined.
I think I'm just not thinking this through well enough.

I have a number of classes just like that Address class, and I want to write a conversion function that checks for the existance of an operator (implicit or explicit) between two classes, and then invokes it.
A universal converter if you will.

I have a reflection-based function that uses getFields() that works on the Address classes without the operators being needed. But chokes on classes such as this:

public class Namespace1.Location
{
    public string Name;
    public Address Place;    
}
 
public class Namespace2.Location
{
    public string Name;
    public Address Place;
}
 

(Since the two address classes are not the same, using invokeMember fails).


I'm not sure my question is clear, but if anyone has ideas I can attempt to make it more clear.

[Plater]

I think I may have found what I am looking for:

//EndType is the type I want to PRODUCE
//StartType is the type I am pulling data FROM
MethodInfo mi = EndType.GetMethod(
    "op_Implicit", 
    (BindingFlags.Public | BindingFlags.Static), 
    null, 
    new Type[] { StartType }, 
    new ParameterModifier[0]
);
//Now if mi is NOT null, it means there is an operator that allows for converting StartType to EndType, if it is null, there isn't one
 

[Plater]

So I think I have what I wanted, it's been working well.

public static class ShippingConversion
{
  private static BindingFlags basePropertyFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public;
  public static object ConvertOP(object StartObject, Type EndType)
  {
        object retval = null;
        Type[] SearchTypes = (StartObject != null) ? new Type[] { StartObject.GetType() } : new Type[0];
        MethodInfo mi = EndType.GetMethod("op_Explicit", (BindingFlags.Public | BindingFlags.Static), null, SearchTypes, new ParameterModifier[0]);
        if (mi == null) mi = EndType.GetMethod("op_Implicit", (BindingFlags.Public | BindingFlags.Static), null, SearchTypes, new ParameterModifier[0]);
        if (mi != null)//there is a conversion operator!
        { retval = EndType.InvokeMember(mi.Name, BindingFlags.InvokeMethod | (BindingFlags.Public | BindingFlags.Static), null, null, new object[] { StartObject }); }
        return retval;
  }
    public static object Convert(object StartObject, Type EndType)
    {
        object retval = null;
 
        Type StartType = StartObject.GetType();
        retval = EndType.InvokeMember("", BindingFlags.CreateInstance, null, null, new object[0]);
        PropertyInfo[] pis = EndType.GetProperties(basePropertyFlags);
        foreach (PropertyInfo oI in pis)//you should probably use getFields, in case there is no setter, but in my case this is -safe-(ish)
        {
            PropertyInfo thisFIs = StartType.GetProperty(oI.Name, basePropertyFlags);
            if ((thisFIs != null))
            {
                object cVal = StartType.InvokeMember(thisFIs.Name, basePropertyFlags | BindingFlags.GetProperty, null, StartObject, new object[0]);
                if (thisFIs.PropertyType == oI.PropertyType)
                { EndType.InvokeMember(thisFIs.Name, basePropertyFlags | BindingFlags.SetProperty, null, retval, new object[] { cVal }); }
                else
                {//check for operator for it?
                    object o = ConvertOP(cVal, oI.PropertyType);
                    if (o != null) EndType.InvokeMember(thisFIs.Name, basePropertyFlags | BindingFlags.SetProperty, null, retval, new object[] { o });
                }
            }
        }
 
        return retval;
    }
} //end of class
 

Anything that is the -same- type and -same- name gets set. If they are custom classes, the code checks to see if there are implicit/explict operators for it. (Those are used for type-casting)

I'm pretty pleased that this is working.

[GaryTexmo]

Nifty... nice job :)