Mircrosoft.NET 2.0 Beta1 SDK

导读:
  泛型(generic)是C#语言2.0和通用语言运行时(CLR)的一个新特性。泛型为.NET框架引入了类型参数(type parameters)的概念。类型参数使得设计类和方法时,不必确定一个或多个具体参数,其的具体参数可延迟到客户代码中声明、实现。这意味着使用泛型的类型参数T,写一个类MyList ,客户代码可以这样调用:MyList ,MyList 或MyList 。这避免了运行时类型转换或装箱操作的代价和风险。
  
  
  
  
   目录
   C# 中的泛型
   一、泛型概述
   二、泛型的优点
   三、泛型类型参数
   四、类型参数的约束
   五、泛型类
   六、泛型接口
   七、泛型方法
   八、泛型委托
   九、泛 型代码中的default 关键字
   十、C++ 模板和C# 泛型的区别
   十一 、运行时中的泛型
   十二 、基础类库中的泛型
  
  
   一、泛型概述
  泛型类和泛型方法兼复用性、类型安全和高效率于一身,是与之对应的非泛型的类和方法所不及。泛型广泛用于容器(collections)和对容器操作的方法中。.NET框架2.0的类库提供一个新的命名空间System.Collections.Generic,其中包含了一些新的基于泛型的容器类。要查找新的泛型容器类(collection classes)的示例代码,请参见基础类库中的泛型。当然,你也可以创建自己的泛型类和方法,以提供你自己的泛化的方案和设计模式,这是类型安全且高效的。下面的示例代码以一个简单的泛型链表类作为示范。(多数情况下,推荐使用由.NET框架类库提供的List 类,而不是创建自己的表。)类型参数T在多处使用,具体类型通常在这些地方来指明表中元素的类型。类型参数T有以下几种用法:
  l 在AddHead方法中,作为方法参数的类型。
  l 在公共方法GetNext中,以及嵌套类Node的Data属性中作为返回值的类型。
  l 在嵌套类中,作为私有成员data的类型。
  
  注意一点,T对嵌套的类Node也是有效的。当用一个具体类来实现MyList 时——如MyList ——每个出现过的T都要用int代替。
  
  using System;
  using System.Collections.Generic;
  
  public class MyList //type parameter T in angle brackets
  {
  private Node head;
  // The nested type is also generic on T.
  private class Node
  {
  private Node next;
  //T as private member data type:
  private T data;
  //T used in non-generic constructor:
  public Node(T t)
  {
  next = null;
  data = t;
  }
  public Node Next
  {
  get { return next; }
  set { next = value; }
  }
  //T as return type of property:
  public T Data
  {
  get { return data; }
  set { data = value; }
  }
  }
  public MyList()
  {
  head = null;
  }
  //T as method parameter type:
  public void AddHead(T t)
  {
  Node n = new Node(t);
  n.Next = head;
  head = n;
  }
  
  public IEnumerator GetEnumerator()
  {
  Node current = head;
  
  while (current != null)
  {
  yield return current.Data;
  current = current.Next;
  }
  }
  }
  
  下面的示例代码演示了客户代码如何使用泛型类MyList ,来创建一个整数表。通过简单地改变参数的类型,很容易改写下面的代码,以创建字符串或其他自定义类型的表。
  
  class Program
  {
  static void Main(string[] args)
  {
  //int is the type argument.
  MyList list = new MyList ();
  for (int x = 0; x <10; x++)
  list.AddHead(x);
  
  foreach (int i in list)
  {
  Console.WriteLine(i);
  }
  Console.WriteLine("Done");
  }
  }
   二、泛型的优点
  针对早期版本的通用语言运行时和C#语言的局限,泛型提供了一个解决方案。以前类型的泛化(generalization)是靠类型与全局基类System.Object的相互转换来实现。.NET框架基础类库的ArrayList容器类,就是这种局限的一个例子。ArrayList是一个很方便的容器类,使用中无需更改就可以存储任何引用类型或值类型。
  
  //The .NET Framework 1.1 way of creating a list
  ArrayList list1 = new ArrayList();
  list1.Add(3);
  list1.Add(105);
  //...
  ArrayList list2 = new ArrayList();
  list2.Add(“It is raining in Redmond.”);
  list2.Add("It is snowing in the mountains.");
  //...
  
  但是这种便利是有代价的,这需要把任何一个加入ArrayList的引用类型或值类型都隐式地向上转换成System.Object。如果这些元素是值类型,那么当加入到列表中时,它们必须被装箱;当重新取回它们时,要拆箱。类型转换和装箱、拆箱的操作都降低了性能;在必须迭代(iterate)大容器的情况下,装箱和拆箱的影响可能十分显著。
  
  另一个局限是缺乏编译时的类型检查,当一个ArrayList把任何类型都转换为Object,就无法在编译时预防客户代码类似这样的操作:
  
  ArrayList list = new ArrayList();
  //Okay.
  list.Add(3);
  //Okay, but did you really want to do this?
  list.Add(.“It is raining in Redmond.”);
  
  int t = 0;
  //This causes an InvalidCastException to be returned.
  foreach(int x in list)
  {
  t += x;
  }
  
  虽然这样完全合法,并且有时是有意这样创建一个包含不同类型元素的容器,但是把string和int变量放在一个ArrayList中,几乎是在制造错误,而这个错误直到运行的时候才会被发现。
  
  在1.0版和1.1版的C#语言中,你只有通过编写自己的特定类型容器,才能避免.NET框架类库的容器类中泛化代码(generalized code)的危险。当然,因为这样的类无法被其他的数据类型复用,也就失去泛型的优点,你必须为每个需要存储的类型重写该类。
  
  ArrayList和其他相似的类真正需要的是一种途径,能让客户代码在实例化之前指定所需的特定数据类型。这样就不需要向上类型转换为Object,而且编译器可以同时进行类型检查。换句话说,ArrayList需要一个类型参数。这正是泛型所提供的。在System.Collections.Generic命名空间中的泛型List
  The .NET Framework 2.0 way of creating a list
  List list1 = new List ();
  //No boxing, no casting:
  list1.Add(3);
  //Compile-time error:
  list1.Add("It is raining in Redmond.");
  
  与ArrayList相比,在客户代码中唯一增加的List 语法是声明和实例化中的类型参数。代码略微复杂的回报是,你创建的表不仅比ArrayList更安全,而且明显地更加快速,尤其当表中的元素是值类型的时候。
   三、泛型类型参数
  
  在泛型类型或泛型方法的定义中,类型参数是一个占位符(placeholder),通常为一个大写字母,如T。在客户代码声明、实例化该类型的变量时,把T替换为客户代码所指定的数据类型。泛型类,如泛型概述中给出的MyList 类,不能用作as-is,原因在于它不是一个真正的类型,而更像是一个类型的蓝图。要使用MyList ,客户代码必须在尖括号内指定一个类型参数,来声明并实例化一个已构造类型(constructed type)。这个特定类的类型参数可以是编译器识别的任何类型。可以创建任意数量的已构造类型实例,每个使用不同的类型参数,如下:
  
  MyList list1 = new MyList ();
  MyList list2 = new MyList ();
  MyList list3 = new MyList ();
  
  在这些MyList 的实例中,类中出现的每个T都将在运行的时候被类型参数所取代。依靠这样的替换,我们仅用定义类的代码,就创建了三个独立的类型安全且高效的对象。有关CLR执行替换的详细信息,请参见运行时中的泛型。
   四、类型参数的约束
  
  若要检查表中的一个元素,以确定它是否合法或是否可以与其他元素相比较,那么编译器必须保证:客户代码中可能出现的所有类型参数,都要支持所需调用的操作或方法。这种保证是通过在泛型类的定义中,应用一个或多个约束而得到的。一个约束类型是一种基类约束,它通知编译器,只有这个类型的对象或从这个类型派生的对象,可被用作类型参数。一旦编译器得到这样的保证,它就允许在泛型类中调用这个类型的方法。上下文关键字where用以实现约束。下面的示例代码说明了应用基类约束,为MyList 类增加功能。
  
  public class Employee
  {
  public class Employee
  {
  private string name;
  private int id;
  public Employee(string s, int i)
  {
  name = s;
  id = i;
  }
  
  public string Name
  {
  get { return name; }
  set { name = value; }
  }
  public int ID
  {
  get { return id; }
  set { id = value; }
  }
  
  }
  }
  class MyList where T: Employee
  {
  //Rest of class as before.
  public T FindFirstOccurrence(string s)
  {
  T t = null;
  Reset();
  while (HasItems())
  {
  if (current != null)
  {
  //The constraint enables this:
  if (current.Data.Name == s)
  {
  t = current.Data;
  break;
  }
  else
  {
  current = current.Next;
  }
  } //end if
  } // end while
  return t;
  }
  }
  
  约束使得泛型类能够使用Employee.Name属性,因为所有为类型T的元素,都是一个Employee对象或是一个继承自Employee的对象。

本文转自
http://blog.csdn.net/metababy/archive/2005/12/30/565947.aspx
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值