C#高级编程笔记 Day 7， 2016年9月 19日（泛型）

1、协变和抗变

泛型接口的协变

　　如果泛型类型用 out 关键字标注，泛型接口就是协变的。这也意味着返回类型只能是 T。接口IIndex 与类型T 是协变的，并从一个制度索引器中返回这个类型。

1 public interface IIndex<out T>
2 {
3     T this[int index]{ get; }
4     int Count{ get; }
5 }

　　如果对接口IIndex 使用了读写索引器，就把泛型类型T 传递给方法，并从方法中检索这个类型。这不能通过协变来实现—泛型类型必须定义为不变的。不使用out 和 in 标注，就可以把类型定义为不变的。

泛型接口的抗变

　　如果泛型类型用 in 关键字标注，泛型接口就是抗变的。这样，接口只能把泛型类型 T 用作其方法的输入。

1 public interface IDisplay<in T>
2 {
3     void Show(T item);
4 }

2、因为可空类型使用得非常频繁，所以 C# 有一种特殊的语法，它用于定义可空类型的变量。定义这类变量时，不适用泛型结构的语法，而是用 “？”运算符。在下面的李子中，变量 x1和x2 都是可空的int 类型的实例：

　　
```
Nullable <int> x1;
int ?x2; 
```

　　可空类型可以与null 和数字比较，如上所示。这里，x的值与null 比较，如果x 不是 null，它就与小于 0的值比较：

```
1 int ？ x =GetNullableType();
2 if(x==null)
3 {
4     Console.WriteLine("x id null");
5 }
6 else if(x < 0)
7 {
8     Console.WriteLine("x is smaller than 0");
9 }
```
知道了 Nullable<T> 是如何定义的之后，下面就使用可空类型。可空类型还可以与算术运算符一起使用。变量 x3 是 x1 和x2 的和。如果这两个可空变量中任何一个的值是 null ，他们的和就是 null
```
1 int ? x1=GetNullableType();
2 int ? x2=GetNullableType();
3 int ? x3=x1+x2;
```
！这里调用的 GetNullableThype() 只是一个占位符，它对于任何方法都返回一个可空的 int 。

3、非可空类型可以转换为可空类型。从非可空类型转换为可空类型时，在不需要强制类型转换的地方可以进行隐式转换。

```
1 int y1=4;
2 int ? x1=y1;
```
但从可空类型转换为非可空类型可能会失败。如果可空类型的值是null，并且把null 值赋予非可空类型，就会抛出InvalidOperationException 类型的异常。这就是需要类型强制转换运算符进行显示转换的原因：
```
int ? x1=GetNullableType();
int y1=(int) x1;
```
如果不进行显示类型转换，还可以使用合并运算符从可空类型转换为非可空类型，合并运算符的语法是“？？”，为转换定义了一个默认值，以防可空类型的值是null。这里，如果 x1 是 null,y1的值就是 0

int ? x1 = GetNullableType();
int y1 = x1 ?? 0;

4、泛型方法：

　　除了定义泛型类之外，还可以定义泛型方法。在泛型犯法中，泛型类型用方法声明来定义。泛型方法可以在非泛型类中定义。

void Swap<T>(ref T x,ref T y)
{
    T temp;
    temp =x;
    x=y;
    y= temp;
}

　　把泛型类型赋予方法调用，就可以调用泛型方法：

```
int i=4;
int j=5;
Swap<int>(ref i,ref j);
//或者 Swap(ref i,ref j);
```
泛型方法实例，下面的例子使用泛型方法累加集合中的所有元素。为了说明泛型方法的功能，下面使用包含Name 和Balance 属性的Account 类

 1 public class Account
 2 {
 3     public string Name{ get; private set;}
 4     public decimal Balance{get; private set;}
 5     
 6     public Account(string name,Decimal balance)
 7     {
 8         this.Name=name;
 9         this.Balance=balance;
10     }
11 }

其中应累加余额的所有账户操作都添加到 List<Account> 类型的账户列表中

```
1 var accounts=new List<Account>()
2 {
3     new Account("Christian",1500),
4     new Account("Stephanie",2200),
5     new Account("Angela",1800),
6     new Account("Matthias",2400)
7 };
```
累加所有Account对象的传统方式是用foreach 语句遍历所有的Account 对象，如下所示，foreach 语句使用 IEnumerable 接口迭代集合的元素，所以 AccumulateSimple() 方法的参数是 IEnumerable类型。foreach语句处理实现 IEunmerable 接口的每个对象。这样，AccumulateSimple() 方法就可以用于所有实现 IEnumerable<Account> 接口的集合类。在这个方法的实现代码中，直接访问Account 对象的 Balance 属性。

 1 public static class Algorithm
 2 {
 3     public static decimal AccumulateSimple(IEnumerable<Account> source)
 4     {
 5         decimal sum=0;
 6         foreach(Account a in source)
 7         {
 8             sum+=a.Balance;
 9         }
10         return sum;
11     }
12 }

调用如下：

decimal amount=Algorthm.AccumulateSimple(accounts);

带约束的泛型方法

　　　　第一个实现代码的问题是，它只能用于Account 对象。使用泛型方法就可以避免这个问题。

　　　　Accumulate() 方法的第二个版本接受实现了 IAccount 接口的任意类型。如前面的泛型类所述，泛型类型可以用where 子句来限制。

 1 public static decimal Accmulate<TAccount>(IEnumerable<TAccount> source) where TAccount : IAccount
 2 {
 3     decimal sum=0;
 4 
 5     foreach(TAccount a in source)
 6     {
 7         sum+= a.Balance;
 8     }
 9     return sum;
10 }

重构Account 类实现 IAccount 接口

```
public class Account : IAccount
{
    //...
```
IAccount 接口定义了只读属性 Balance 和 Name

1 public interface IAccount
2 {
3     decimal Balance {get; }
4     string Name{get ;}
5 }

新的调用方式：

decimal amount =Algorthim.Accmulate<Account>(accounts);
//或者 decimail amount =Alhorthim.Accmulate(accounts);

　　　　带委托的泛型方法

　　　　泛型类型实现了 IAccount 接口的要求过于严格。下面的示例提示了，如何通过传递一个泛型委托来修改 Accumulate()方法。这个Accumulate() 方法使用两个泛型参数 T1 和 T2。第一个参数T1 用于实现了IEnumerable<T1> 参数的集合，第二个参数使用泛型委托Fun<T1, T2, TResult>。其中，第二个和第三个泛型参数都是 T2 类型。需要传递的方法有两个输入参数（T1 和 T2）和一个 T2类型的返回值。

- ```
1 public static T2 Accmulate<T1,T2>(IEnumerable<T1> source, Func<T1,T2,T2> action)
2 {
3     T2 sum=default(T2);
4     foreach(T1 item in source)
5     {
6         sum=action(item,sum);
7     }
8     return sum;
9 }
```
  在调用这个方法时，需要指定泛型参数类型，因为编译器不能自动推断出该类型。对于方法的第一个参数，所赋予的accounts集合是IEnumerable<Account> 类型。对于第二个参数，使用一个 Lambda 表达式来定义Account 和 decimal 类型的两个参数，返回一个小数。对于每一项通过Accumulate() 方法调用这个 Lambda 表达式
- ```
decimal amount=Algorithm.Accumulate<Account,decimal>(accounts,(item,sum)=>sum+=item.Balance);
```

　　　　泛型方法规范

　　　　泛型方法可以重载，为特定的类型定义规范。这也适用于带泛型参数的方法。Foo()方法定义了两个版本，第一个版本接受一个泛型参数，第二个版本是用于int 参数的专有版本。在编译期间，会使用最佳匹配。如果传递了一个int，就选择带int 参数的方法。对于任何其他参数类型，编译器会选择方法的泛型版本

- ```
 1 public class MethodOverloads
 2 {
 3     public void Foo<T>(T obj)
 4     {
 5         Console.WriteLine("Foo<T>(T obj),obj type :{0}",obj.GetType().Name);
 6     }
 7     public void Foo(int x)
 8     {
 9         Console.WriteLine("Foo(int x)");
10     }
11     public void Bar<T>(T obj)
12     {
13         Foo(obj);
14     }
15 }
```
  Foo()方法现在可以通过任意参数类型来调用。下面的示例代码给该方法传递了一个 int 和一个 string
- ```
1 static void Main()
2 {
3     var test =new MethodOverloads();
4     test.Foo(33);
5     test.Foo("abc");
6 }
```
  运行该程序，可以从输出中看出选择了最佳匹配的方法：
- ```
Foo(int x)
Foo<T>(T obj), obj type: String
```
  需要注意的是，所调用的方法是在编译期间定义的，而不是运行期间。这很容易举例说明：添加一个调用Foo() 方法的Bar() 泛型方法，并传递泛型参数值：
- ```
public class MethodOverloads
{
    //...
    
    public void Bar<T> (T obj)
    {
        Foo(obj);
    }
}
```
  Main()方法现在改为调用传递以个 int 值的Bar()方法:
- ```
static void Main()
{
    vat test=new MethodOverloads();
    test.Bar(44);
```
  从控制台的输出可以看出，Bar()方法选择了泛型Foo()方法，而不是用 int参数重载的Foo()方法。原因是编译器是在编译期间选择Bar() 方法调用的Foo() 方法。由于Bar() 方法定义了一个泛型参数，而且泛型Foo()方法匹配这个类型，所以调用了Foo() 方法。在运行期间给Bar() 方法传递一个 int 值不会改变这一点。
- ```
Foo<T>(T obj), obj type: Int32
```

【小结】：泛型。通过泛型类可以创建独立于类型的类，泛型方法是独立于类型的方法。接口、结构、和委托也可以用泛型的方式创建。泛型引入了一种新的编程方式。我们介绍了如何实现相应的算法（尤其是操作和谓词）以用于不同的类，而且他们呢都是类型安全的。泛型委托可以去除集合中的算法。

C#高级编程笔记 Day 7， 2016年9月 19日 （泛型）

C#高级编程笔记 Day 7， 2016年9月 19日（泛型）