泛型

实践/后端/C#基础/21.泛型.md

@@ -24,4 +24,303 @@
      public delegate void EventHandle<TEventArgs>(object sender,TEventArgs e);
      public delegate TOutput Converter<TInput,TOutput>(TInput from);
      public class SortedList<TKey,TValue>{}
-     ```
+     ```
+
+> 创建泛型类
+-  在链表中，一个元素引用下一个元素。所以必须创建一个类，它将对象封装在链表中，并引用下一个对象。
+-  类LinkedListNode包含一个属性value，该属性用构造函数初始化。另外，LinkedListNode类包含对链表中下一个元素和上一个元素的引用，这些元素都可以从属性中访问。
+```
+public class LinkedListNode
+{
+    public LinkedListNode(object value)
+    {
+        Value=value;
+    }
+    public object Value{get;private set;}
+    public LinkedListNode Next{get;internal set;}
+    public LinkedListNode Prev{get;internal set;}
+}
+```
+- LinkedList类包含LinkedListNode类型的First和Last属性，它们分别标记了链表的头尾。AddLast()方法在链表尾添加一个新元素。首页创建一个LinkedListNode类型的对象。如果链表是空的，First和Last属性就设置为该新元素；否则，就把新元素添加为链表中的最后一个元素。通过实现GetEnumerator()方法，可以用foreach语句遍历链表。GetEnumerator()方法使用yield语句创建一个枚举器类型。
+```
+public class LinkedList:IEnumerable
+{
+    public LinkedListNode First{get;private set;}
+    public LinkedListNode Last{get;private set;}
+
+    public LinkedListNode AddLast(object node)
+    {
+        var newNode=new LinkedListNode(node);
+        if(First==null)
+        {
+            First=newNode;
+            Last=First;
+        }
+        else
+        {
+            LinkedListNode previous=Last;
+            Last.Next=newNode;
+            Last=newNode;
+            Last.Prev=previous;
+        }
+        return newNode;
+    }
+    public IEnumerator GrtEnumerator()
+    {
+        LinkedListNode current =First;
+        while(current!=null)
+        {
+            yield return current.Value;
+            current=current.Next;
+        }
+    }
+
+}
+```
+> 创建链表的泛型版本
+- LinkedListNode 类用一个泛型类型T声明。属性Value的类型是T，而不是object。构造函数也变为可以接受T类型的对象。也可以返回和设置泛型类型，所以属性Next和Prev的类型是LinkedLisTNode<T>
+```
+public class LinkedListNode<T>
+{
+    public LinkedListNode(T value)
+    {
+        Value=value;
+    }
+    public T Value{get;private set;}
+    public LinkedListNode<T> Next{get;internal set;}
+    public LinkedListNode<T> Prev{get;internal set;}
+}
+
+
+public class LinkedList<T>:IEnumerable<T>
+{
+    public LinkedListNode<T>Frist{get;private set;}
+    public LinkedListNode<T>Last{get;private set;}
+
+    public LinkedListNOde<T>AddLast(T node)
+    {
+        var newNode=new LinkedListNode<T>(node);
+        if(First==null)
+        {
+            First=newNode;
+            Last=First;
+        }
+        else
+        {
+            LinkedListNode<T>previous=Last;
+            LAst.Next=newNode;
+            Lsat=newNode;
+            Last.Prev=previous;
+        }
+        return newNode;
+    }
+
+    public IEnumerator<T> GetEnumerator()
+    {
+        LinkedListNode<T>current=First;
+        while(current!=null)
+        {
+            yield return current.Value;
+            current=current.Next;
+        }
+    }
+    IEnumerator IEnumerable.GetEnumerator()=>GetEnumerator();
+}
+```
+- 使用泛型LinkedList<T>,可以用int类型实例化它，且无需装箱操作。如果不使用AddLast()去传递int，就会出现一个编译器错误。使用泛型IEnumerable<T>,foreach语句也是类型安全的，如果foreach语句中的变量不是int，就会出现一个编译器错误
+```
+var list2=new LinkedList<int>();
+list2.AddLast(1);
+list2.AddLAst(3);
+list2.AddLAst(5);
+
+foreach(int i in list2)
+{
+    WriteLine(i);
+}
+对于字符串类型使用泛型LinkList<T>,将字符串传递给AddLast（）方法。
+var list3=new LinkedList<string>();
+list3.AddLast("2")；
+list3.AddLast("four");
+list3.AddLast("foo");
+
+foreach(string s in list3)
+{
+    WriteLine(s);
+}
+```
+- 每个处理对象类型的类都可以有泛型实现方式，另外，如果类使用了层次结构，泛型就非常有助于消除类型强制转换操作
+
+
+> 泛型类的功能
+- 默认值
+- 约束
+- 继承
+- 静态成员
+
+**默认值**
+- 给DocumentManager<T>类添加一个GetDocument()方法。在这个方法中，应把类型T指定为null。但是，不能把null赋予泛型类型。原因是泛型类型也可以实例化值类型，而null只能用于引用类型。为了解决这个问题，可以使用default关键字。通过default关键字，将null赋予引用类型，将0赋予值类型。
+```
+public T GetDocument()
+{
+    T doc =default(T);
+    lock(this)
+    {
+        doc=documentQueue.Dequeue();
+    }
+    return doc;
+}
+```
+
+**约束**
+- 如果泛型类需要调用泛型类型中的方法，就必须添加约束
+- 对于DocumentManager<T>,文档的所有标题应在DisplayAllDocuments()方法中显示。Document类实现带有Title和Content属性的IDocument接口
+```
+public interface IDocument
+{
+    string Title{get;set;}
+    string Content{get;set;}
+}
+public class Document:IDocument
+{
+    public Document()
+    {
+
+    }
+    public Document(string title,string content)
+    {
+        Title=title;
+        Content=content;
+    }
+    public string Title{get;ste;}
+    public string Content{get;set;}
+}
+- 要使用DocumentManager<T>类显示文档，可以将类型T强制转换为IDocument接口，以显示标题
+
+public void DisplayAllDocuments()
+{
+    foreach(T doc in documentQueue)
+    {
+        WriteLine(((IDocument)doc).Title);
+    }
+}
+```
+- 如果类型T没有实现IDocument接口，这个类型强制转换就会导致一个运行时异常。最好给DocumentManager<TDocument>类定义一个约束：TDocument类型必须实现IDocument接口。
+- 为了在泛型类型的名称中制定该要求，将T改为TDocument。where子句指定了实现IDocument接口的需求
+```
+public class DocumentManager<TDocument> where TDocument:IDocument
+{
+    public void DisplayAllDocuments()
+    {
+        foreach (TDocument doc in documentQueue)
+        {
+            WriteLine(doc.Title);
+        }
+    }
+}
+```
+- 在main()方法中，用Document类型实例化DocumentManager<TDocument>类，而Document类型实现了需要的IDocument接口。接着添加和显示新文档，检索其中一个文档
+```
+public static void Main()
+{
+    var dm=new DocumentManager<Document>();
+    dm.AddDocument(new Document("Title A","Sample A"));
+    dm.AddDocument(new Document("Title B","Sample B"));
+
+    dm.DisplayAllDocuments();
+
+    if(dm.IsDocumentAvailable)
+    {
+        Document d=dm.GetDocument();
+        WriteLine(d.Content);
+    }
+}
+DocumentMAnager现在可以处理任何实现了IDocument接口的类。
+```
+- where T：struct  ：对于结构约束，类型T必须是值类型
+- where T：class   ：类约束指定类型T必须是引用类型
+- where T：IFoo    ：指定类型T必须实现接口IFoo
+- where T：Foo     ：指定类型T必须派生自基类Foo
+- where T：new()   :这是一个构造函数约束，指定类型T必须有一个默认构造函数
+- where T1：T2     ：这个约束也可以指定，类型T1派生自泛型类型T2
+
+
+
+**继承**
+前面创建的LinkedList<T>类实现了IEnumerable<T>接口
+```
+public class LinkedList<T>:IEnumerable<T>
+{
+    //泛型类型可以实现泛型接口，也可以派生自一个类。泛型类可以派生自泛型基类
+}
+public class Base<T>
+{
+
+}
+
+public class Derived<T>:Base<T>
+{
+
+}
+其要求是必须重复接口的泛型类型，或者必须指定基类的类型
+
+public class Base<T>
+{
+
+}
+public class Derived<T>:Base<string>
+{}
+```
+- 派生类可以是泛型类或非泛型类。例如，可以定义一个抽象的泛型基类，它在派生类中用一个具体的类实现。这允许对特定类型执行特殊的操作
+```
+public abstract class Calc<T>
+{
+    public abstract T Add(T x,T y);
+    public abstract T Sub(T x,T y);
+}
+public class IntCalc:Calc<int>
+{
+    public override int Add(int x,int y)=>x+y;
+    public override int Sub(int x,int y)=>x-y;
+}
+```
+还可以创建一个部分的特殊操作，如从Query中派生StringQuery类，只定义一个泛型参数，如字符串TResult。要实例化StringQuery，只需要提供TRequest
+```
+public class Query<TRequest,TResult>
+{}
+public StringQuery<TRequest>:Query<TRequest,string>
+{}
+```
+
+**静态成员**
+- 泛型类的静态成员需要特别关注。泛型类的静态成员只能在类的一个实例中共享。
+```
+public class StaticDemo<T>
+{
+    public static int x;
+}
+由于同时对一个string类型和一个int类型使用StaticDemo<T>le类，因此存在两组静态字段：
+StaticDemo<string>.x=4;
+StaticDemo<int>.x=5;
+WriteLine(StaticDemo<string>.x)；
+```
+
+
+> 泛型接口
+- 如果泛型类型用out关键字标注，泛型接口就是协变得。这也意味着返回类型只能是T。接口IIndex与类型T是协变得，并从一个只读索引器中返回这个类型
+```
+public interface IIndex<out T>
+{
+    T this[int index]{get;}
+    int Count{get;}
+}
+
+```
+
+
+
+
+
+
+
+