泛型类的定义类似于一般的类，只是要使用泛型类型声明。之后就可以在类中把泛型类型用作成员字段，或方法的参数类型。在定义泛型类时，可以对客户端代码能够在实例化类时用于类型参数的类型种类施加限制。如果客户端代码尝试使用某个约束所不允许的类型来实例化类，则会产生编译时错误。这些限制称为约束。约束是使用 where 关键字指定的。

1. //源代码下载路径：http://media.wiley.com/product_ancillary/41/07645753/DOWNLOAD/Ch10.zip
2. namespace Wrox.ProCSharp.Generics
3. {
4.     using System;
5.     using System.Threading;
6.     using System.Collections.Generic;
7.     public interface IDocument
8.     {
9.         string Title { get;}
10.         string Content { get;}
11.     }
12.     public class Document : IDocument
13.     {
14.         private string title;
15.         public string Title
16.         {
17.             get { return title; }
18.         }
19.         private string content;
20.         public string Content
21.         {
22.             get { return content; }
23.         }
24.         public Document(string title, string content)
25.         {
26.             this.title = title;
27.             this.content = content;
28.         }
29.     }
30.     /// <summary>
31.     /// 定制泛型类【使用接口约束】
32.     /// </summary>
33.     public class ProcessDocuments<TDocument, TDocumentManager>
34.         where TDocument : IDocument
35.         where TDocumentManager : IDocumentManager<TDocument>
36.     {
37.         public static void Start(TDocumentManager dm)
38.         {
39.             new Thread(new ProcessDocuments<TDocument, TDocumentManager>(dm).Run).Start();
40.         }
41.         protected ProcessDocuments(TDocumentManager dm)
42.         {
43.             //注意不能把null赋予泛型类型，因为泛型类型也可以是值类型。
44.             //其中T doc = default(T);//则会将null赋予引用类型，把0赋予值类型。
45.             documentManager = dm;
46.         }
47.         //使用泛型类型定义成员字段
48.         private TDocumentManager documentManager;
49.         protected void Run()
50.         {
51.             while (true)
52.             {
53.                 if (documentManager.IsDocumentAvailable)
54.                 {
55.                     TDocument doc = documentManager.GetDocument();
56.                     Console.WriteLine("Processing document {0}", doc.Title);
57.                 }
58.                 Thread.Sleep(20);
59.             }
60.         }
61.     }
62.     /// <summary>
63.     /// 定制泛型接口
64.     /// </summary>
65.     public interface IDocumentManager<T>
66.     {
67.         void AddDocument(T doc);
68.         T GetDocument();
69.         bool IsDocumentAvailable
70.         {
71.             get;
72.         }
73.     }
74.     /// <summary>
75.     /// 定制泛型类
76.     /// </summary>
77.     public class DocumentManager<T> : IDocumentManager<T>
78.     {
79.         private Queue<T> documentQueue = new Queue<T>();
80.         //泛型类型作为参数类型
81.         public void AddDocument(T doc)
82.         {
83.             lock (this)
84.             {
85.                 documentQueue.Enqueue(doc);
86.             }
87.         }
88.         //泛型类型作为返回类型
89.         public T GetDocument()
90.         {
91.             T doc;
92.             lock (this)
93.             {
94.                 doc = documentQueue.Dequeue();
95.             }
96.             return doc;
97.         }
98.         public bool IsDocumentAvailable
99.         {
100.             get { return (documentQueue.Count > 0) ? true : false; }
101.         }
102.     }
103.     class Program
104.     {
105.         static void Main(string[] args)
106.         {
107.             DocumentManager<Document> dm = new DocumentManager<Document>();
108.             ProcessDocuments<Document, DocumentManager<Document>>.Start(dm);
109.             for (int i = 0; i < 1000; i++)
110.             {
111.                 Document doc = new Document("title" + i.ToString(), "content");
112.                 dm.AddDocument(doc);
113.                 Console.WriteLine("added document {0}", doc.Title);
114.                 Thread.Sleep(10);
115.             }
116.         }
117.     }
118. }