Is there a generic constraint I could use for the + operator?

is there some 'where' type contraints in can add to make the follwing code compile ?

public class Plus<T> : BinaryOpe开发者_开发问答rator<T> where T : ...
{
    public override T Evaluate(IContext<T> context)
    {
        return left.Evaluate(context) + right.Evaluate(context);
    }
}

Thanks :)

There are no such devices in C#. A few options are available, though:

• in C# 4.0 and .NET 4.0 (or above), use dynamic, which supports + but offers no compile time checking
• in .NET 3.5 (or above), MiscUtil offers an Operator class which makes operators available as methods - again, without any compile-time checking

So either:

return (dynamic)left.Evaluate(context) + (dynamic)right.Evaluate(context);

or

return Operator.Add(left.Evaluate(context), right.Evaluate(context));

The Type parameter constraints in C# are very limited and is listed here. So the answer is no as far as compile time check goes. If T is a type that you create and manage, one way to go about it would be to

interface IAddable 
{
   IAddable Add(IAddable foo);
}

and implement IFoo for all your types and use where T: IAddable as constraint and use Add() instead of +

In C# 11 and .NET 7, there is a feature exactly for this (see Microsoft Docs). It would have to go as follow:

public interface IAddable<T> where T : IAddable<T>
{
    static abstract T operator +(T left, T right);
}

public class Foo : IAddable<Foo>
{
    public static Foo operator +(Foo left, Foo right)
    {
        /* Something */
    }
}

With C# 8 default interface methods you can achieve something similar, but it might not solve your exact use case:

You can define an interface with a default implementation of an operator:

public interface IFoo
{
    double Value { get; }

    public static IFoo operator +(IFoo a, IFoo b)
    {
        return new Foo(a.Value + b.Value);
    }
}

public class Foo : IFoo
{
    public double Value { get; }

    public Foo(double value)
    {
        Value = value;
    }
}

And consume it in a generic method/class like this:

public static class Program
{
    public static void Main()
    {
        var f1 = new Foo(1);
        var f2 = new Foo(2);
        var sum = Add(f1, f2);
        Console.WriteLine(sum.Value);
    }

    public static IFoo Add<T>(T a, T b) where T : IFoo
    {
        return a + b;
    }
}

Using a generic constraints you can force T

• to be a reference type or a value type
• to inherit from a certain class
• to implement certain interface
• to have parameterless constructor

But that's all. You can't force the existence of the static operator+ on it.