C# 泛型及机制

来源：互联网发布：mc68hc908jl3 编程器编辑：程序博客网时间：2024/05/18 00:43

C# 泛型及机制

C#泛型演示

[csharp] view plaincopy
using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace ConsoleApplication1  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Stack<int> test = new Stack<int>();  
            test.Push(10);  
            Console.WriteLine(test.GetResult());  
            Console.Read();  
        }  
    }  
  
    class Stack<T>   
    {  
        private T[] store;  
        private int size;  
  
        public Stack()  
        {  
            store = new T[10];  
            size = 0;  
        }  
  
        public void Push(T x)  
        {  
            store[size++] = x;  
        }  
  
        public T Pop()  
        {  
            return store[--size];  
        }  
  
        public string GetResult()  
        {  
            return store[--size].ToString();  
        }  
    }  
}  

C#泛型简介

所谓泛型，即通过参数化类型来实现在同一份代码上的操作多种数据类型。泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用。

C#泛型赋予了代码更强的类型安全，更好的复用，更高的效率，更清晰的约束

C#泛型机制简介

C#泛型能力由CLR在运行时支持，区别于C++ 的编译时模板机制，和Java的编译时“ 搽拭法” 。这使得泛型能力可以在各个支持CLR的语言之间进行无缝的互操作。

C#泛型代码在被编译为IL 代码和元数据时，采用特殊的占位符来表示泛型类型，并用专有的IL 指令支持泛型操作。而真正的泛型实例化工作以“on-demand” 的方式，发生在JIT编译时。

C#泛型编译机制

第一轮编译时，编译器只为Stack<T>类型产生“ 泛型版” 的IL 代码与元数据——并不进行泛型类型的实例化，T在中间只充当占位符

JIT编译时，当JIT编译器第一次遇到Stack<int>时，将用int替换“ 泛型版”IL代码与元数据中的T——进行泛型类型的实例化。

CLR 为所有类型参数为“ 引用类型” 的泛型类型产生同一份代码；但如果类型参数为“ 值类型” ，对每一个不同的“ 值类型” ，CLR将为其产生一份独立的代码

C#泛型的几个特点

如果实例化泛型类型的参数相同，那么JIT编译器会重复使用该类型，因此C#的动态泛型能力避免了C++ 静态模板可能导致的代码膨胀的问题。
•C#泛型类型携带有丰富的元数据，因此C#的泛型类型可以应用于强大的反射技术。
•C#的泛型采用“ 基类, 接口, 构造器, 值类型/引用类型” 的约束方式来实现对类型参数的 “ 显式约束” ，提高了类型安全的同时，也丧失了C++ 模板基于“ 签名” 的隐式约束所具有的高灵活性。

泛型类型

C#泛型类与结构

[csharp] view plaincopy
class C<U, V> { }   //合法  
    class D : C<string, int> { }    //合法  
    class E<U, V> : C<U, V> { }     //合法  
    class F<U, V> : C<string, int> { }  //合法  
    //非法  
    //class G : C<U, V> { };  

C#除可单独声明泛型类型（包括类与结构）外，也可在基类中包含泛型类型的声明。但基类如果是泛型类，它的类型参数要么已实例化，要么来源于子类（同样是泛型类型）声明的类型参数。

泛型类型的成员

[csharp] view plaincopy
class D<V>  
   {  
         
   }  
  
   class C<V>  
   {  
       public V fi1;   //声明字段  
       public D<V> f2;  //作为其它泛型类型的参数  
       public C(V x)     
       {  
           this.fi1 = x;  
       }  
   }  

泛型类型的成员可以使用泛型类型声明中的类型参数。但类型参数如果没有任何约束，则只能在该类型上使用从System.Object继承的公有成员。

泛型接口

[csharp] view plaincopy
interface IList<T>  
   {  
       T[] GetElements();  
   }  
   interface IDictionary<K, V>  
   {  
       void Add(K key, V value);  
   }  
  
   class List<T> : IList<T>,IDictionary<int,T>  
   {  
  
       public void Add(int key, T value)  
       {  
           throw new NotImplementedException();  
       }  
  
       public T[] GetElements()  
       {  
           throw new NotImplementedException();  
       }  
   }  

泛型接口的类型参数要么已实例化，要么来源于实现类声明的类型参数。

泛型委托

[csharp] view plaincopy
delegate bool Predicate<T>(T value);  
    class X  
    {  
        static bool F(int i){ return true;}  
        static bool G(string s) { return false; }  
  
        static void Main()  
        {  
            Predicate<string> P2 = G;  
            Predicate<int> p1 = new Predicate<int>(F);  
        }  
    }  

泛型委托支持在委托返回值和参数上应用参数类型，这些参数类型同样可以附带合法的约束。

泛型方法

泛型方法简介

•C#泛型机制只支持 “在方法声明上包含类型参数”——即泛型方法
•C#泛型机制不支持在除方法外的其他成员（包括属性、事件、索引器、构造器、析构器）的声明上包含类型参数，但这些成员本身可以包含在泛型类型中，并使用泛型类型的类型参数
• 泛型方法既可以包含在泛型类型中，也可以包含在非泛型类型中

泛型方法的声明与调用

[csharp] view plaincopy
public class Finder  
   {  
       //泛型方法的声明  
       public static int Find<T>(T[] items, T item)  
       {  
           for (int i = 0; i < items.Length; i++)  
           {  
               if (items[i].Equals(item))  
               {  
                   return i;  
               }  
           }  
           return -1;  
       }  
  
       //泛型方法的调用  
       int i = Finder.Find<int>(new int[] { 1,3,4,5,6}, 6);  
   }  

泛型方法的重载

[csharp] view plaincopy
public class MyClass  
   {  
       void F1<T>(T[] a,int i);  
       void F1<U>(U[] a, int i);   //不可以构成重载方法  
  
       void F2<T>(int x);  
       void F2(int x);     //可以构成重载方法  
  
       void F3<T>(T t) where T : A;  
       void F3<T>(T t) where T : B;  
   }  
  
   class A{}  
   class B { }  

泛型方法的重写

[csharp] view plaincopy
abstract class Base  
   {  
       public abstract T F<T, U>(T t, U u) where U : T;  
       public abstract T G<T>(T t) where T : IComparable;  
   }  
  
   class Derived : Base  
   {  
       // 合法的重写，约束被默认继承  
       public override T F<T, U>(T t, U u)  
       {  
           throw new NotImplementedException();  
       }  
  
       // 非法的重写，指定任何约束都是多余的  
       public override T G<T>(T t) where T:IComparable  
       {  
           throw new NotImplementedException();  
       }  
   }  

泛型约束

泛型约束简介

•C#泛型要求对“ 所有泛型类型或泛型方法的类型参数” 的任何假定，都要基于“ 显式的约束” ，以维护C#所要求的类型安全。
•“显式约束” 由where 子句表达，可以指定“ 基类约束” ，“ 接口约束” ，“ 构造器约束” ，“ 值类型/引用类型约束” 共四种约束。
•“显式约束” 并非必须，如果没有指定“ 显式约束” ，泛型类型参数将只能访问System.Object类型中的公有方法。

基类约束

[csharp] view plaincopy
class A{ public void F1(){} }  
    class B { public void F2(){} }  
    class C<S,T>  
        where S:A   //S继承自A  
        where T:B   //T继承自B  
    {  
        //可以在类型为S的变量上调用F1  
        //可以在类型为T的变量上调用F2  
          
    }  

接口约束

[csharp] view plaincopy
//接口约束   
    interface IPrintable{void Print();}  
    interface IComparable<T>{int CompareTo(T v);}  
    interface IKeyProvider<T>{T GetKey();}  
  
    class Dictionary<K,V>  
        where K:IComparable<K>  
        where V:IPrintable,IKeyProvider<K>  
    {  
        //  可以在类型为K的变量上调用CompareTo，  
        //  可以在类型为V的变量上调用Print和GetKey  
    }  

构造器约束

[csharp] view plaincopy
class A{public A(){}}  
   class B{public B(int i){}}  
  
   class W<T> where T:new()  
   {  
         
   }  
  public class test  
  {  
      W<A> c=new W<A>();   //可以A有无参构造函数  
      W<B> c=new W<B>();   //错误，B没有无参构造器  
  }  

值类型/引用类型约束

0 0