Is it possible to call value type operators via reflection?

Question

As C# operators e.g. +, +=, == 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.

Operators can't be *overridden*. They can be *overloaded*. There's a big difference. — Jon Skeet, Aug 09 '09 at 15:11
To be clearer, override lets you redefine the implementation, overloading lets you add another method with the same name but with different parameters. Thanks for the remark. — Sébastien Ros - MSFT, Aug 12 '09 at 08:24

score 12 · Answer 1 · edited Oct 18 '15 at 14:46

12

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

edited Oct 18 '15 at 14:46

Yuval Itzchakov

146,575
32
257
321

answered Apr 19 '12 at 08:14

FdW

141
1
2

This worked beautifully in my application. First time I've really used "dynamic" too. I like it! – Boinst Jun 21 '13 at 05:19
1

Why not declare the parameters directly as `dynamic`s? – Benoît Dubreuil Jun 26 '20 at 15:04
That should be by far the accepted answer. – Yet Another Code Maker Jul 01 '22 at 09:12

score 7 · Accepted Answer · answered Aug 09 '09 at 14:43

7

Yes, the custom operators are invokable using reflection (they have special names, such as op_Addition), but System.Int32 doesn't define them, as fundamental, built-in, types are handled directly by IL opcodes like add, rather than method calls.

answered Aug 09 '09 at 14:43

Barry Kelly

41,404
5
117
189

1

what are custom cast operators named? – Tim Lovell-Smith Aug 03 '10 at 21:51
1

Answer own subquestion - turns out they are "op_Implicit" and "op_Explicit" and can have multiple versions with same name, differing only in return type. – Tim Lovell-Smith Aug 03 '10 at 23:42

Marc Gravell · Answer 3 · 2009-08-12T08:27:05.833

4

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

edited Aug 12 '09 at 08:27

answered Aug 09 '09 at 19:41

Marc Gravell

1,026,079
266
2,566
2,900

Actually I wanted to implement an Add(object left, object right) where the returned value is using the type of the left argument. This is for an expression evaluation, and as it is dynamic there is no way to write the code directly. – Sébastien Ros - MSFT Aug 12 '09 at 08:21
have to disagree on opting for 4.0 as Seb's work is focused and quite a performance ahievement when compared to Expression Trees bloat and invention. Judging the performance of DLR and its containing bits it only makes the imminent PDC realease the slowest framework in the history of mankind.. – rama-jka toti Oct 14 '09 at 08:26
The DLR solved my problem. I tried the lambdas on two Enum types and didn't work, since Linq Expressions use reflection, and the Enum operators are not declared in code, rather by assembly compiled code or something who knows. – Shimmy Weitzhandler Jan 12 '12 at 01:47

score 0 · Answer 4 · answered Aug 09 '09 at 15:01

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.

Kenan E. K. · Answer 5 · 2009-08-09T16:48:31.907

0

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's a small sample. Of course, performance isn't too nice, but we know what we're getting into with Reflection, anyway.

edited Aug 09 '09 at 16:48

answered Aug 09 '09 at 15:13

Kenan E. K.

13,955
3
43
48

Is it possible to call value type operators via reflection?

5 Answers5

Linked