C#2.0 泛型和继承

5.1 在从泛型基类派生时，可以提供类型实参，而不是基类泛型参数

    public class BaseClass<T>

     {…… }

     public class SubClass : BaseClass<int>

     {…… }

  5.2 如果子类是泛型，而非具体的类型参数，则可以使用子类泛型参数作为泛型基类的恶指定类型

    public class BaseClass<T>

     {…… }

     public class SubClass<T> : BaseClass< T >

     {…… }

  5.3在使用子类泛型参数时，必须在子类级别重复在基类级别规定的任何约束

A． 派生约束

public class BaseClass1<T> where T : ISomeInterface

{…… }

public class SubClass2<T> : BaseClass1<T> where T : ISomeInterface

{ ……}

B． 构造函数约束

public class BaseClass3<T> where T : new()

{

public T SomeMethod()

{

  return new T();

     }

}

public class SubClass3<T> : BaseClass3<T> where T : new()

{ ……}

   5.4 基类可以定义其签名使用泛型参数的虚拟方法。在重写它们时，子类必须在方法签名中提供相应的类型。

        public class BaseClass4<T>

         {

              public virtual T SomeMethod()

              {

                   return default(T);

              }

         }

         public class SubClass4 : BaseClass4<int>

         {

              public override int SomeMethod()

              {

                   return 0;

              }

         }

      如果该子类是泛型，则它还可以在重写时使用它自己的泛型参数

         public class SubClass5<T> : BaseClass4<T>

         {

              public override T SomeMethod()

              {

                   return default(T);

              }

         }

      可以定义泛型接口，泛型抽象类，甚至抽象方法。这些类型的行为像其他任何泛型基类型一样。

                   public interface ISomeInterface6<T>

         {

              T SomeMethod(T t);

         }

         public abstract class BaseClass6<T>

         {

              public abstract T SomeMethod(T t);

         }

         public class SubClass6<T> : BaseClass6<T>,ISomeInterface6<T>

         {

              public override T SomeMethod(T t)

              { return default(T); }

         }

5.4 泛型抽象方法和泛型接口有一种有趣的用法。在C#2.0中，不能对泛型参数使用诸如 + 或 += 之类的运算符。例如，一下代码无法编译，因为C#2.0不具有运算符约束。

                        public class Calculator<T>

              {

                   public T Add(T arg1, T arg2)

                   {

                       return arg1 + arg2;//Does not compile

                   }

                   //Rest of the methods

              }

         但是，我们通过定义泛型操作，使用抽象方法（最好使用接口）进行补偿。由于抽象方法的内部不能具有任何代码，因此可以在基类级别指定的泛型操作，并且在子类别提供具体的类型实现

A．  泛型抽象方法

public abstract class BaseCalculator<T>

{

public abstract T Add(T arg1, T arg2);

         //public abstract T Subtract(T arg1, T arg2);

//public abstract T Divide(T arg1, T arg2);

    //public abstract T Multiply(T arg1, T arg2);

}

public class MyCalculator : BaseCalculator<int>

{

public override int Add(int arg1, int arg2)

{

    return arg1 + arg2;

}

     //Rest of the methods

}

B． 泛型接口

public interface ICalculator<T>

{

T Add(T arg1, T arg2);

//Rest of the methods

}

public class MyCalculator1 : ICalculator<int>

{

public int Add(int arg1, int arg2)

{

           return arg1 + arg2;

    }

    //Rest of the methods
   }