Is it possible to call value type operators via reflection?

Question

As C# operators eg +, +=, == are overridable. It lets me think they are sort of methods, thus wonder if there is a way to call them using reflection, on Int32 for instance.

Answer 1

What about this, it's simple, small and works :)

public T Add<T>(object x, object y)
{
    return (T)Convert.ChangeType((dynamic)x + (dynamic)y, typeof(T));
}

Answer 2

是的，自定义运算符可以使用反射调用（它们具有特殊名称，例如op_Addition），但System.Int32不定义它们，因为基本的内置类型直接由IL操作码（如add ，而不是方法调用。

Answer 3

What exactly is it you want to do? Dealing with the various meanings of operators (primitive (mapped to specific IL instructions), custom (mapped to static methods), and lifted (provided as a pattern by the compiler)) makes this painful. If you just want to use the operators, then it is possible to write code that provides operator support via generics . I have some code for this that is freely available in MiscUtil ( description and examples ).

---

As an untyped example (an note that this isn't hugely efficient, but works):

object x = 123, y = 345; // now forget that we know that these are ints...
object result = Expression.Lambda<Func<object>>(
    Expression.Convert(Expression.Add(
        Expression.Constant(x), Expression.Constant(y)),
    typeof(object))).Compile()();

Answer 4

It would be very inefficient if adding or comparing two integers required a method call so these simple operations on the fundamental types are code-generated as explained in another answer and cannot be invoked using reflection. One interesting built-in value type is decimal (or System.Decimal ). This struct has support for literal values in C#, but behaves a lot like a real value type and exposes a lot of operators that can be invoked via reflection.

If you are curious you can use Reflector to browse all members exposed by System.Int32 .

Answer 5

There are good answers here, so just to add something not mentioned yet:

A struct might have an operator overloaded . This means more options to check if you try to create some programmatic approach.

One nice thing to try out is, to try the expression tree approach. Here 'sa small sample. Of course, performance isn't too nice, but we know what we're getting into with Reflection, anyway.