C# 具有可用计数的泛型类型

我正在用泛型类型测试C#中的多态性，并试图找到使泛型可计数的方法，但C#编译器不接受泛型类型的求和等操作。我找到了其中一个变通方法，并根据该变通方法创建了下面的代码，该代码继承自提供适当功能的接口：

using System.IO;
using System;

interface ICountable<T>
{
    T Add(T a, T b);
    T Multiply(T a, T b);
}

interface IExecute<T> : ICountable<T>
{
    T Operation(T a, T b);
}

class IntSum : IExecute<int>
{
    public int Add(int a, int b)
    {
        return a + b;
    }
    public int Multiply(int a, int b)
    {
        return a*b;
    }
    public int Operation(int a, int b)
    {
        return Add(a,b);
    }
}
class DoubleMultiply : IExecute<double>
{
    public double Add(double a, double b)
    {
        return a + b;
    }
    public double Multiply(double a, double b)
    {
        return a*b;
    }
    public double Operation(double a, double b)
    {
        return Multiply(a,b);
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine(DoOperation(new IntSum(), 1, 2));
        Console.WriteLine(DoOperation(new DoubleMultiply(), 3.5d, 3d));
    }

    static TResult DoOperation<TOperand, TResult>(TOperand obj, TResult a, TResult b)
    where TOperand : IExecute<TResult>
    {
        return obj.Operation(a,b);
    }
}

使用System.IO；
使用制度；
接口可数
{
T添加（T a，T b）；
T乘（ta，tb）；
}
接口执行：i可数
{
T操作（ta，tb）；
}
类IntSum:IExecute
{
公共整数相加（整数a、整数b）
{
返回a+b；
}
公共整数乘法（整数a，整数b）
{
返回a*b；
}
公共整数运算（整数a、整数b）
{
返回添加（a，b）；
}
}
类DoubleMultiply:IExecute
{
公共双加（双a，双b）
{
返回a+b；
}
公共双倍乘法（双a，双b）
{
返回a*b；
}
公共双重操作（双重a、双重b）
{
返回乘法（a，b）；
}
}
班级计划
{
静态void Main（）
{
WriteLine（DoOperation（新的IntSum（），1，2））；
Console.WriteLine（DoOperation（新的DoubleMultiply（），3.5d，3d））；
}
静态结果操作（TOperand obj、结果a、结果b）
托珀兰德：我在哪里
{
返回对象操作（a、b）；
}
}

上面的代码可以工作，但最终我使用了对具体原语类型的继承，并且有很多冗余代码块。我的最终目标是使此类类型尽可能通用，类似于：

using System.IO;
using System;

interface ICountable<T>
{
    T Add(T a, T b);
    T Multiply(T a, T b);
}

interface IExecute<T> : ICountable<T>
{
    T Operation(T a, T b);
}

// Generic code
class Sum<T> : IExecute<T>, ICountable<T>
{
    public T Add(T a, T b)
    {
        return a + b;
    }
    public T Multiply(T a, T b)
    {
        return a*b;
    }
    public T Operation(T a, T b)
    {
        return Add(a,b);
    }
}

class Program
{
    static void Main()
    {
        //Console.WriteLine(DoOperation(new IntSum(), 1, 2));
        //Console.WriteLine(DoOperation(new DoubleMultiply(), 3.5d, 3d));
    }

    //static TResult DoOperation<TOperand, TResult>(TOperand obj, TResult a, TResult b)
    //where TOperand : IExecute<TResult>
    //{
    //    return obj.Operation(a,b);
    //}
}

使用System.IO；
使用制度；
接口可数
{
T添加（T a，T b）；
T乘（ta，tb）；
}
接口执行：i可数
{
T操作（ta，tb）；
}
//通用代码
类总数：i执行，i可计算
{
公共T添加（T a，T b）
{
返回a+b；
}
公共T乘（T a，T b）
{
返回a*b；
}
公共T运营（T a、T b）
{
返回添加（a，b）；
}
}
班级计划
{
静态void Main（）
{
//WriteLine（DoOperation（新的IntSum（），1，2））；
//Console.WriteLine（DoOperation（新的DoubleMultiply（），3.5d，3d））；
}
//静态结果操作（TOperand obj、结果a、结果b）
//托珀兰德：我在哪里
//{
//返回对象操作（a、b）；
//}
}

---

显然，编译器会抱怨，因为它无法对两个泛型类型求和。你认为我总是要继承特定的原语吗？谢谢。

您可以使用Expression.Add（）和Expression.Multiply（）来实现这一点。请注意，如果没有为您使用的类型定义加法/乘法运算符，它们将引发异常。

如何？也许结合？你可以检查T的类型，所以至少你只有一个类Sum@BastiM不能重载泛型的运算符。我还尝试对基元类型应用约束

struct

。您不能直接重载它们，但如果您希望以类型安全的方式（无反射/动态）执行此操作，那么您唯一的选择就是为您明确关心的每种类型实现它。无法使用泛型跨重载方法进行抽象。