Jak uzyskać zdefiniowane operatory dla typu w .net

Question

Próbuję uzyskać listę zdefiniowanych operatorów dla określonego typu, aby zobaczyć, jakie operacje można zastosować do tego typu.

Na przykład, typ Guid obsługuje operacje == i ! =.

Tak więc, jeśli użytkownik chce zastosować operację < = dla typu Guid, mogę obsłużyć tę sytuację przed wystąpieniem wyjątku.

Jeśli mogę mieć listę operatorów, mogę zmusić użytkownika do używania tylko operacji na liście.

Operatory są widoczne w przeglądarce obiektów, więc może istnieć sposób dostępu do nich za pomocą odbicia, ale nie mogłem tego znaleźć.

Każda pomoc zostanie doceniona.

Answer 1

Get metody z Type.GetMethods, a następnie użyć MethodInfo.IsSpecialName odkryć operatorów, konwersje itd. Oto przykład:

using System; 
using System.Reflection; 

public class Foo 
{ 
    public static Foo operator +(Foo x, Foo y) 
    { 
     return new Foo(); 
    } 

    public static implicit operator string(Foo x) 
    { 
     return ""; 
    } 
} 

public class Example 
{ 

    public static void Main() 
    { 
     foreach (MethodInfo method in typeof(Foo).GetMethods()) 
     { 
      if (method.IsSpecialName) 
      { 
       Console.WriteLine(method.Name); 
      } 
     } 
    } 
} 

Answer 2

C# 4.0 jest funkcja dynamicznego środowiska wykonawczego języka, tak jak o użyciu typu dynamic?

using Microsoft.CSharp.RuntimeBinder; 

namespace ListOperatorsTest 
{ 
class Program 
{ 
    public static void ListOperators(object inst) 
    { 
     dynamic d = inst; 

     try 
     { 
      var eq = d == d; // Yes, IntelliSense gives a warning here. 
      // Despite this code looks weird, it will do 
      // what it's supposed to do :-) 
      Console.WriteLine("Type {0} supports ==", inst.GetType().Name); 

     } 
     catch (RuntimeBinderException) 
     { 
     } 

     try 
     { 
      var eq = d <= d; 
      Console.WriteLine("Type {0} supports <=", inst.GetType().Name); 

     } 
     catch (RuntimeBinderException) 
     { 
     } 

     try 
     { 
      var eq = d < d; 
      Console.WriteLine("Type {0} supports <", inst.GetType().Name); 

     } 
     catch (RuntimeBinderException) 
     { 
     } 

     try 
     { 
      var add = d + d; 
      Console.WriteLine("Type {0} supports +", inst.GetType().Name); 
     } 
     catch (RuntimeBinderException) 
     { 
     } 

     try 
     { 
      var sub = d - d; 
      Console.WriteLine("Type {0} supports -", inst.GetType().Name); 
     } 
     catch (RuntimeBinderException) 
     { 
     } 

     try 
     { 
      var mul = d * d; 
      Console.WriteLine("Type {0} supports *", inst.GetType().Name); 
     } 
     catch (RuntimeBinderException) 
     { 
     } 

     try 
     { 
      try 
      { 
       var div = d/d; 
      } 
      catch (DivideByZeroException) 
      { 
      } 
      Console.WriteLine("Type {0} supports /", inst.GetType().Name); 
     } 
     catch (RuntimeBinderException) 
     { 
     } 
    } 

    private struct DummyStruct 
    { 
    } 

    static void Main(string[] args) 
    { 
     ListOperators(0); 
     ListOperators(0.0); 
     DummyStruct ds; 
     ListOperators(ds); 
     ListOperators(new Guid()); 
    } 
} 
}