C#学习笔记（三十）-- 定义泛型类型

    要创建泛型类，只需要在类定义中包含尖括号语法：

class MyGenericClass<T> {...}

    其中T可以是任意标识符，只要遵循通常的C#命名规则即可，但一般只使用T。泛型类可在其定义中包含任意多个类型参数，参数之间用逗号分隔，例如：

class MyGeneriaClass<T1, T2, T3> {...}

class MyGenericClass<T1, T2, T3>
{
  private T1 innerT1Object;
  public MyGenericClass(T1 item)
  {
    innerT1Object = item;//不能写成 innerT1Object = new T1();
  }
  public T1 InnerT1Object
  {
    get { return innerT1Object;}
  }
}

    其中，类型T1的对象可以传递给构造函数，只能通过InnerT1Object属性对这个对象进行只读访问。注意，不能假定为类提供了什么类型。

    因为我们并不知道T1是什么，也就不能使用它的构造函数,它甚至可能没有构造函数，或者没有可公共访问的默认构造函数。如果不涉及高级技术的复杂代码，则只能对T1进行如下假设：可以把它看成继承自System.Object的类型或可以封箱到System.Object中的类型。

    显然，这意味着不能对这个类型的实例进行非常有趣的操作，或者对为MyGenericClass泛型类提供的其他类型进行有趣的操作。不使用反射技术，就只能使用下面的代码：

public string GetAllTypesAsString()
{
  return " T1 = " + typeof(T1).ToString() + ", T2 = " + typeof(T2).ToString() + ", T3 = " + typeof(T3).ToString();
}

    可以做一些其他工作，尤其是对集合进行操作，因为处理对象组是非常简单的，不需要对对象类型进行任何假设，这是为什么存在本章前面介绍的泛型集合类的一个原因。

    另一个需要注意的限制是，在比较为泛型类型提供的类型值和null时，只能使用运算符==或!=：

public bool Compare(T1 op1, T2 op2)
{
  if(op1 != null && op2 != null)//if (op1 == op2)这段代码在编译时就会出现错误
  {
    return true;
  }
  else
  {
    return false;
  }
}

1  default关键字

    要确定用于创建泛型类实例的类型，需要了解它们是引用类型还是值类型。如果T1是值类型，则innerT1Object不能取null值，所以这段代码不会编译。

    使用default关键字可以有效解决这一问题：

public MyGenericClass()
{
  innerT1Object = default(T1);
}

    其结果是，如果innerT1Object是引用类型，就给它赋予null值；如果它是值类型，就给它赋予默认值。对于数字类型，这个默认值是0；而结构根据其各个成员的类型，以相同的方式初始化为0或null。default关键字允许对必须使用的类型执行更多操作，但为了更进一步，还需要限制所提供的类型。

2  约束类型

    前面用于泛型类的类型称为无绑定类型，因为没有对他们进行任何约束。而通过约束类型，可以限制用于实例化泛型类的类型。在类定义中，这可以使用where关键字实现：

class MyGeneriaClass<T> where T : constraint {...}

    其中constraint定义了约束。可以用这样的方式提供多种约束，各个约束之间用逗号分开：

class MyGeneriaClass<T> where T : constraint1，constraint2 {...}

    还可以使用多个where语句，定义泛型类需要的任意类型或所有类型上的约束：

class MyGeneriaClass<T1, T2> where T1 : constraint1 where T2 : constraint2 {...}

    约束必须出现在继承说明符的后面：

class MyGenericClass<T1, T2> : MyBaseClass, IMyInterface where T1 : constraint1 where T2 : constraint2 {...}

    下面给出了一些可用的约束：

约束	定义	用法示例
struct	类型必须是值类型	在类中，需要值类型才能起作用，例如，T类型的成员变量是0，表示某种含义
class	类型必须是引用类型	在类中，需要引用类型才能起作用，例如，T类型的成员变量是努力了，表示某种含义
base-class	类型必须是基类或继承自基类。可以根据这个约束提供任意类名	在类中，需要继承自基类的某种基本功能，才能起作用
interface	类型必须是接口或者实现了接口	在类中，需要接口公开的某种基本功能，才能起作用
new()	类型必须有一个公共的无参构造函数	在类中，需要能实例化T类型的变量，例如在构造函数中实例化，如果使用new()作为约束，它就必须是类型指定的最后一个约束

    可以通过base-class约束，把一个类型参数用作另一个类型参数的约束：

class MyGenericClass<T1, T2> where T2 : T1 {...}

    其中，T2必须与T1的类型相同，或继承自T1.这成为罗类型约束，表示一个泛型类型参数用作另一个类型参数的约束。

3  从泛型类中继承

    首先，如果某个类型所继承的基类型中受到了约束，该类型就不能“解除约束”。也就是说，类型T在所继承的基类型中使用时，该类型必须受到至少与基类型相同的约束。

    另外，如果继承自一个泛型类型，就必须提供所有必须的类型信息，这可以使用其他泛型类型参数的格式来提供。

    如果给泛型类型提供了参数，就可以称该类型是“关闭的”，如果没有提供参数的话，那这个类型就是“打开的”。

4  泛型运算符

    在C#中，可以像其他方法一样进行运算符的重写，也可以在泛型类中实现此类重写。例如，可在Farm<T>中定义如下隐式转换运算符：

public static implicit operator List<Animal>(Farm<T> farm)
{
   List<Animal> result = new List<Animal>();
   foreach (T animal in farm)
   {
      result.Add(Animal);
   }
   return result;
}

    如果，有必要的话，可以在Farm<T>中把Animal对象直接作为List<Animal>来访问：

public static Farm<T> operator +(Farm<T> farm1, List<T> farm2)
{
   Farm<T> result = new Farm<T>();
   foreach (T animal in farm1)
   {
      result.Animal.Add(animal);
   }
   foreach (T animal in farm2)
   {
      if (!result.Animal.Contains(animal))
      {
         result.Animals.Add(animal);
      }
   }
   return result;
}
public static Farm<T> operator + (List<T> farm1, Farm<T> farm2) => farm2 + farm1;

    接着可以添加Farm<Animal>和Farm<Cow>的实例：

Farm<Animal> newFarm = farm + dairyFarm;

    在这行代码中，dairyFarm(Farm<Cow>的实例)隐式转换为List<Animal>，List<Animal>可在Farm<T>中由重载运算符+使用。

    为了解决Farm<Cow>转换为Farm<Animal>导致汇总失败的问题，可以使用下面的转换运算符来解决这一问题：

public static implicit operator Farm<Animal>(Farm<T> farm)
{
   Farm<Animal> result = new Farm <Animal>();
   foreach (T animal in farm)
   {
     result.Animal.Add(animal);
   }
   return result;
}

    使用这个运算符，Farm<T>的实例（如Farm<Cow>）就可以转换为Farm<Animal>的实例，这解决了上面的问题。

5  泛型结构

    可以用与泛型类相同的方式来创建泛型结构：

public struct Mystruct<T1, T2>
{
   public T1 item1;
   public T2 item2;
}