This is a pretty commonly requested new feature for C#: the ability to specify more generic parameter constraints than the ones we already have. Operators are among the most frequently asked. However, C# does not currently support this.
Possible workarounds:
-
Pass a delegate to any method that needs to do addition. This is the most type-safe option, but of course it’s annoying if you need to call such a method often. For example:
public class Generic<T> { public void DoSomething(T anItem, T anotherItem, Func<T, T, T> add) { // instead of Blah(anItem + anotherItem); // have to write: Blah(add(anItem, anotherItem)); } } Generic<int> genInt = ...; // and then instead of ... genInt.DoSomething(1, 2); // have to write: genInt.DoSomething(1, 2, (a, b) => a + b);
-
Declare your own interface
IAddable
. Then you can use it as a generic type parameter constraint, but obviously you can’t useint
as the parameter then. You would have to use astruct
of your own that contains just anint
and which implementsIAddable
:public interface IAddable<T> { T Add(T other); } public struct Integer : IAddable<Integer> { public int Value; public Integer(int value) { Value = value; } public Integer Add(Integer other) { return new Integer(Value + other.Value); } } // then instead of Generic<int> blah = ...; // have to write: Generic<Integer> blah = ...;
-
dynamic
. Another possible workaround is to usedynamic
, but this is rather hacky and completely unsafe: it will let you pass in any type and call any method or operator, and only crash at runtime, not at compile-time.