如何在泛型参数上进行四则运算和初识dynamic类型

        在C#中,泛型<T>仅仅作为占位符,没有实际意义,而通过泛型声明的参数不能进行四则运算,关系运算,逻辑运算,仅仅只能满足赋值操作,即使通过where T : struct来限定参数是值类型,也无法完成运算. 

        而从目前所学的知识中,可以继承一些特殊的API来完成诸如关系运算.

class Program    {        public T Comp<T>(T a, T b) where T : struct, IComparable   //继承特殊的比较接口IComparable,使用CompareTo方法        {            if (a.CompareTo(b) < 0)            {                return b;            }            return a;        }        static void Main(string[] args)        {            int a = 10;            int b = 20;            //比较字符串返回较大的那个串            int str = new Program().Comp<int>(a, b);            Console.WriteLine(str);            Console.ReadKey();        }    }

          而如果需要实现四则运算,发现并没有相应的API可以继承.

         那么如何能才能在泛型参数上完成四则运算呢?这里提供两种办法.

         第一种可以使用方法重载来完成

    class A    {        public int x;        public static A operator +(A a, A b)        {            A Temp = new A();            Temp.x = a.x + b.x;            return Temp;        }        public override string ToString()        {            return this.x.ToString();        }    }    class B<T>        where T : A, new()    {        public void Add(T t1, T t2)        {            T t3 = (T)(t1 + t2);            Console.WriteLine(t3);        }    }    class Program    {        static void Main(string[] args)        {            A b1 = new A();            b1.x = 10;            A b2 = new A();            b2.x = 20;            B<A> bb1 = new B<A>();            bb1.Add(b1, b2);            Console.Read();        }    }

          而另一种方法,是参考了FrameWork4.0的新特性dynamic类型,它让C#有了弱语言的特性,在编译器编译时不对类型进行检查.从而让两个泛型类型完成计算并返回运算值.

    interface IAlgorthim<T> where T : struct // 约束于值类型    {        T Add(T t1, T t2);    }    class Algorthim<T> : IAlgorthim<T> where T : struct    {        public T Add(T t1, T t2)        {            dynamic first = t1, second = t2;  //这里用dynamic类型对两个泛型参数进行赋值,能使两个泛型参数进行运算            return first + second;        }    }    class Program    {        static void Main(string[] args)        {            IAlgorthim<int> algInteger = new Algorthim<int>();            Console.WriteLine(algInteger.Add(2, 3));            IAlgorthim<double> algDouble = new Algorthim<double>();            Console.WriteLine(algDouble.Add(2.5D, 3.1D));            Console.ReadKey();        }    }

      虽然在泛型上进行四则运算并无实际意义,而其他方法能更高效得完成运算,但从思考中接触到新的dynamic语句也算是有所收获.