关于泛型对象使用算数运算符的问题

Question

我想用T类型的变量进行一个计算
但它不支持算术运算符
各位大佬有什么办法解决这个问题吗？using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            a<Program>.Add();//T类型不适合此方法
            a<int>.Add();//jijubhuibuib
            a<string>.Add();
           
            Console.ReadKey();
        }
    }
        class a<T>
    {
        private static T t;
        public static T Add()
        {
            //①子类对象可以直接赋值给父类变量；
            //③如果父类对象中装的是子类对象，可以将这个父类对象强转为子类对象；
            //is：如果转换成功，返回 true，失败返回 false；
            if (t is int || (t as string == null))//如果返回为true则证明T类型是int和string
            {
                Console.WriteLine("复制并连接或相加");
                t = t + t;
                return t;
            }
            else
            {
                Console.WriteLine("T类型不适合此方法");
            }        } 
    }
}这是我搜到的以前的一个帖子，这个帖子里好像也没有解决的方法
https://bbs.csdn.net/topics/210029007

Answer 1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            a<Program>.Add();//T类型不适合此方法
            a<int>.Add();//jijubhuibuib
            a<string>.Add();            Console.ReadKey();
        }
    }
    class a<T>
    {
        private static T t;
        private static string tt;
        public static T Add()
        {
            //①子类对象可以直接赋值给父类变量；
            //③如果父类对象中装的是子类对象，可以将这个父类对象强转为子类对象；
            //is：如果转换成功，返回 true，失败返回 false；
            if (t is int || (t as string == null))//如果返回为true则证明T类型是int和string
            {
                Console.WriteLine("复制并连接或相加");
                tt = t.ToString() + t.ToString();
                return t;
            }
            else
            {
                Console.WriteLine("T类型不适合此方法");
            }            return default(T);        }
    }
}

Answer 2

如果你要大量做算数运算，就不要做泛型。比如可以直接写死为：class 双精度傅里叶变换
{
   ...
}class 离散傅里叶变换
{
   ...
}

Answer 3

重载运算符？那具体该怎么做呢？大佬能教我吗？这个是泛型编程，不能对泛型重载运算符吧，这个方式解决不了。
两种方法可以解决：
1.用expression拼装加法表达式
2.用dynamic类型的替代泛型

Answer 4

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");            var a = new A();
            A.t = 1;
            var ret = a.Add();            A.t = "123";
            var ret1 = a.Add();
        }
    }    class A
    {
        public static dynamic t;        public dynamic Add()
        {
            return t + t;
        }
    }

Answer 5

dynamic类型的变量执行效率低。dynamic有传染性，一个函数用了dynamic，会将dynamic类型的变量适用范围扩大到你程序的其他地方，导致性能下降。

Answer 6

不过我没找到+法的源码，number和valuetype里也没找到。
但是重载操作符，运算符等等是一种很正常的行为。
因为大家也都知道，泛型并不能确切知道你传递的类型。
而在自定义类中实现，本来就是必须的

Answer 7

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace _787878
{
    class Program
    {
        static void Main(string[] args)
        {
            
        }
    }
    class a<T>
    {
        public static int operator +(int a,int b)
        {
            return a + b;
        }
        public static float operator +(float a, float b)
        {
            return a + b;
        }
        public static double operator +(double a, double b) 
        {
            return a + b;
        }
        public static int operator-(int a,int b)
        {
            return a - b;
        }
        
        T ff<T>(T a,T b) 
        {
            return a + b; 
        }
       
    }
}大佬是这样写吗？但他给我报了一个错说二元运算符的参数之一必须是包含类型，这是怎么回事，怎么解决呢？

Answer 8

我加过约束，但没用啊，该不能用运算符还是不能用，我之前就加过ValueType