Doing arithmetic on generic parameters

Only for you. Only today ;-)

using System;
using System.Reflection;

namespace TestApp
{
class My
{
public static My operator +(My x, My y)
{
return x;
}
}

public static class PrimiteImpl
{
// Define operations here for all primitive classes
public static int Add(int x, int y)
{
return x + y;
}
}
public static class MathOps<T>
{

delegate T BinaryOp(T a, T b);
static readonly BinaryOp add;
static MathOps()
{
// For primitive types we need to emulate this functionality manualy
if (typeof(T).IsPrimitive)
{
add = (BinaryOp)Delegate.CreateDelegate(typeof(BinaryOp), typeof(PrimiteImpl), "Add", false, false);
}
else
{
// For user-defined custom types - use type from user
add = (BinaryOp)Delegate.CreateDelegate(typeof(BinaryOp), typeof(T), "op_Addition", false, false);
}
// If not found do not leave our delegate as empty to avoid useless null-checks
// but assign it to method that will throw some valuable information to user
// It's up to you to use this hack or throw some custom exception as early as possible
if (add == null)
{
add = new BinaryOp(NotSupported);
}
}
// Requered to avoid TypeInitializationException then no operation can be found
private static T NotSupported(T dummy1, T dummy2)
{
throw new NotSupportedException(string.Format("I'm realy sorry. {T} does not support some requered operations.",typeof(T).FullName));
}
public static T Add(T x, T y)
{
return add(x, y);
}
}

class Program
{
public static T Add<T>(T a, T b)
{
return MathOps<T>.Add(a, b);
}
static void Main(string[] args)
{
int x = 10;
int y = 20;
int z = Add(x, y);
My a = new My();
My b = Add(a, a);
long implementMePlz = Add<long>(1, 2);
}
}
}

TAG at 2007-9-8 >

Differences Between C++ Templates and C# Generics (C# Programmers Reference)

is the following:

C# generics do not provide the same amount of flexibility as C++ templates. For example, it is not possible to call arithmetic operators in a C# generic class, although it is possible to call user defined operators.

Bummer!

dba at 2007-9-8 >

Sorry for such a compicated example.

You do with a little bit simpler with help of "using" statements:

using T = System.Double;

class MyFunctions
{
T DoFoo(T x, T y)
{
return x+y;
}
}

All you need now is to keep sources with different using statements in sync.

TAG at 2007-9-8 >