首页 > .NET泛型解析(下)

.NET泛型解析(下)

上一篇对.NET中的泛型进行了详细的介绍以及使用泛型的好处是什么,这篇将更加深入的去了解泛型的其他的知识点,重头戏.

【1】泛型方法

上一篇我们也说过了,泛型可以是类,结构,接口,在这些泛型类型中定义的方法都可以叫做泛型方法,都可以引用由泛型类型本身指定的一个类型参数例如:
1 public class GenericType
2 {
3 
4      private T G_Value;
5 
6      public T Convert { T res = (T)Convert.ChangeType(G_value,typeof(T)); return res; }
7 
8 }
泛型方法的存在为我们提供了极大的灵活性。
泛型方法顾名思义,首先它是一个方法,只不过这个方法的返回值,参数可能是泛型的,
类型推断
类型推断就是根据泛型方法中定义的形参类型T,在我们调用的使用,那么所要传的也应该是一致的。例如:
1 static void Test(ref T t1,ref T t2)
2 {
3        T temp = t1;
4        t1 = t2;
5        t2 = temp;
6 }

这是我们定义的一个泛型方法,第一个参数类型为 T,第二个也为 T,说明这两个类型是一致的。那么我们在调用的时候应该这样 :

1   int i = 8, j = 0 ;
2 
3   Test( ref i, ref j);

而如果我们两个实参的类型不统一的话,那么就会引发编译异常例如 :

开放类型和封闭类型

具有泛型类型参数的类型对象让就还是一个类型, CLR内部依旧和其他的对象类型一样创建一个内部类型对象, 那么这种具有泛型类型参数的类型称之为开放类型,开发类型不能进行构造任何的实例.
当泛型类型参数是一个实参时,那么所有的类型实参传递的都是实际的数据类型了,这种类型称之为 封闭类型,封闭类型是允许构造实例对象的
 1  class DictionaryStringKey  : IEnumerable
 2  {
 3        public IEnumerator GetEnumerator()
 4        {
 5            throw new NotImplementedException();
 6        }
 7 
 8        System .Collections. IEnumerator System. Collections.IEnumerable .GetEnumerator()
 9        {
10            throw new NotImplementedException();
11        }
12  }
View Code

在上述代码中,有一个DictionaryStringKey的类,继承了一个IEnumable的泛型,那么根据我们的开放类型它在调用的时候是不只是具体的实参,并且不能被构造实例的.

 1          static void Main( string[] args)
 2         {
 3             object o = null;
 4             Type t = typeof( DictionaryStringKey <>);
 5            o =   CreateInstance(t);
 6            Console .ReadLine();
 7 
 8         }
 9 
10         private static object CreateInstance( Type t)
11         {
12             object o = null;
13             try
14             {
15                 o = Activator . CreateInstance(t);
16                 Console .WriteLine( @" 创建了 " + t + "的实例 " , t .ToString());
17             }
18             catch (Exception ex)
19             {
20                 o = Activator . CreateInstance(t);
21                 Console .WriteLine( @" 创建 " + t + "的实例失败 " , t .ToString());
22             }
23           
24             return o;
25         }
View Code

上述代码中我尝试着对开放类型进行实例化,结果报出异常 :

当我们传入实参之后,那么它就是一个封闭类型,这样我们就可以进行构造实例了.

1   static void Main( string[] args)
2         {
3             object o = null;
4             Type t = typeof( DictionaryStringKey <string > );
5            o =   CreateInstance(t);
6            Console .ReadLine();
7 
8         }
View Code

 【2】泛型接口

泛型的主要作用就是定义泛型的引用类型和值类型,在CLR中,对于泛型接口的支持也是很重要的,因为这样更有益与程序的扩展性, 另外一点如果没有泛型接口我们每次使用非泛型接口时都会进行装箱操作(例如:  IComparable),并且会失去编译时的安全性(因为它是非泛型的,较之泛型的好处之一).

那么CLR提供了对于泛型接口的支持,对于引用类型和值类型可以通过制定实参的方式来实现泛型接口,同时也可以保持未指定状态来实现一个泛型接口( 接受者也可以是泛型 , 可以在后期进行指定类型)

实例 1 : 声明一个泛型接口

1      interface IPair 
2     {
3         T First { get; set ; }
4         T Second { get; set ; }
5     }
IPair这个接口实现了一对相关的对象,两个数据项具有相同的类型.
实现接口时,语法与非泛型类的语法是相同的,如果在实现泛型接口时,同时不指定实参,则默认为是一个泛型类.
实例 2 : 泛型接口的实现
 1      class Pair  : IPiar< T>
 2     {
 3         public T First
 4         {
 5             get
 6             {
 7                 throw new NotImplementedException();
 8             }
 9             set
10             {
11                 throw new NotImplementedException();
12             }
13         }
14 
15         public T Second
16         {
17             get
18             {
19                 throw new NotImplementedException();
20             }
21             set
22             {
23                 throw new NotImplementedException();
24             }
25         }
26     }
View Code

CLR泛型接口的支持对于集合类型来讲尤其重要,同时泛型在集合类型中较为常用,如果没有泛型那么我们所使用List的时候都要依赖与System.Collections,我们在每次访问的时候都需要执行一次转换,如果使用泛型接口,就可以避免执行转型,因为参数化的接口能实现更强的编译时绑定.

实例 3 : 在一个类中多次实现相同的接口

Items属性使用一个显式接口实现多次出现,每一次,类型参数都有所不同,如果没有泛型,这是做不到的,在非泛型的情况下,CLR只允许一个显式的IContainer.Items属性.

【4】泛型约束(主要约束,次要约束,构造器约束)

约束也可以理解为是一种规则,意思就是我们所编写的所有泛型,你在调用的时候,应该给我传输那些类型的实参。

在上一篇中,我们也在一个DataTableToList中使用到了约束,但是并没有进行讲解,在这里我们详细的说明一下:
在.NET 中有4中约束方式,它们的常规语法是相同的,约束要放在泛型方法或者泛型类型声明的末尾,并由上下文关键字 ”where :“  来引入 。
主要约束(引用类型约束):
主要约束表示的是 : 我们在指定一个引用类型约束时,那么一个指定的类型实参要么是与约束类型相同的类型,要么是从约束类型派生的一个类型
实例 4 : 引用类型约束
1 struct Generic(T t1) where : class
这里我定义了一个泛型方法,Generic,后来写了一个where : class,这就告诉编译器,在使用者调用这个方法时,必须为这个方法的传入一个引用类型的实参,同时,我们也可以注意到这个方法的返回类型为struct值类型。
主要约束(值类型约束)
很明显,值类型约束的话,就是将 约束条件指定为 Struct
实例 5 : 值类型约束
1  class ConstraintOfStruct  where T : struct
2  {
3      public T result()
4      {
5          return new T();
6      }
7  }

在代码中,我们最后返回的是new T(),这个是没有问题的,因为我们已经可以肯定T就是值类型,所有的值类型都有一个隐式的构造函数,那么如果我们将 约束条件改为 class的话,那么就会出异常,因为不是所有的引用类型都可以实例化.

实例 6 : 反面教材 - 约束为引用类型时进行实例化.

构造函数类型约束
构造函数类型约束表示为 T : new(),这个约束必须为所有的类型参数的最后一个约束,它用于检查类型实参是否有一个可用于创建类型实例的无参构造函数,这一点比较适用于所有的值类型,所有的没有显式声明构造函数的非静态、非抽象类,所有显式声明了一个公共无参构造函数的非抽象类。
实例 7 : 构造函数类型约束
1   public T CreateInatance() where T : new()
2   {
3       return new T();
4   }

在方法createInstance中,要求我们必须传入一个无参的构造函数,例如:我们可以传入 object,struct,stream等,但是不能传入 string,Directory等.

接口约束:

接口约束的一个好处就是我们可以指定多个接口,但是只能指定一个类
1     class ConstraintOfStruct  where T : class,IEquatable  ,IComparable
2     {
3     }
组合约束 :
组合约束就是指定多个约束条件在上一个约束中我们已经看到了 ,更详细的如下 :
1     class Sample where T : class ,IDisposable,new(){}
2     class Sample where T : struct,IDisposable{}
3     class Sample where T : Stream where U : IDisposable{}
4  
5     class Sample where T : class ,struct
View Code

【5】泛型类型转型  

1  public static T Desercialies  (Stream stream, IFormatter formatter)
2 {
3       return (T)formatter. Deserialize(stream);
4 }

formatter 负责将流转换为 Object,返回一个Object类型,我们在使用泛型调用的时候应该这样来 :

1   string result = Desercialies <string > (stream, formatter);

上述的代码看着是一种强制转换,但是仍然执行了隐式的转换,就和使用非泛型 string result = (string)Desercialies(stream, formatter); 一样

【6】泛型和属性

 属性也可以应用到泛型类型中,使用的方式和非泛型类型相同.自定义的属性只允许引用开发泛型类型

1     class MyClass where T :class 
2           where S : struct
3     {
4         public T MyName { get; set; }
5         public S MyCode { get; set; }
6         public List MyCourse { get; set; }
7         public List MyStudyHistory { get; set; }
8     }

上述我们定义了一个MyClass 类,这个类有两个参数一个是引用类型一个是值类型.在属性MyName,MyCourse的类型都是引用类型,MyCode的类型都为值类型

泛型类型构造器:

 1      class Pair < T> : IPiar< T >
 2     {
 3         private T _first;
 4 
 5         public T First
 6         {
 7             get { return _first; }
 8             set { _first = value; }
 9         }
10         private T _second;
11 
12         public T Second
13         {
14             get { return _second; }
15             set { _second = value; }
16         }
17         public Pair(T first,T second)
18         {
19 
20         }
21     }
22     interface IPiar < T> { }
View Code

泛型的构造器不需要添加类型参数来与类的声明一致.

 

先到这里, 下一篇着重分享协变和逆变,否则这一篇符太长,不利于以后的查看.

泛型委托和泛型反射留在深入总结委托和反射的时候进行总结。

同时,希望给在阅读的你带来一些帮助。

转载于:https://www.cnblogs.com/DeepLearing/p/4564791.html

更多相关:

  • Python 与 ABC 的一个重要区别在于其类型系统。ABC 采用静态类型,编译器会检查程序中的变量类型是否保持一致,如果不一致,程序就无法运行。并且,ABC与当时大多数静态语言不同,采用的是类型推导(和 Haskell 一样),而不是类型声明(比如 C 语言)。而 Python 采用动态类型,所有类型检查都是在程序运行过程中,而不...

  • python是计算机二级考试的科目之一,并没有级别的划分。其考试目标是测试考生掌握Python语言知识的程度和对Python语言的编程能力、调试能力和综合应用能力,在当下的应用中是十分重要的。 什么是python Python语言是一种解释运行、面向对象、扩展性强的程序设计语言,是大学生学习计算机编程能力、理解计算机解决问题的方法的...

  • 正在学C,书上老说空指针,或者说void指针,对于我这样的生手来说,理解非常容易造成混淆,因为void这个单词的意思也是空,到底空指针的意思是指指向地址为空的类型呢,还是指void类型的指针呢 (1)空指针所对应的是指指向的对象为空的指针。            不经发问,什么叫指向为空呢?要理解这点,必须理解如下几点(有点啰嗦,但...

  • 一、reponseType 1、什么是reponseType XMLHttpRequest.reponseType属性是一个枚举类型的属性,返回响应数据的类型,他允许我们手动的设置 返回数据的类型。如果我们将它设置为一个空字符串,它将默认的使用"text"类型。 当将reponseType设置为一个特定的类型的时候需要确保服务...

  • SNMP中,数据类型并不多。这里我们就讨论这些数据类型,而不关心这些数据类型在实际中是如何编码的。INTEGER一个变量虽然定义为整型,但也有多种形式。有些整型变量没有范围限制,有些整型变量定义为特定的数值(例如,IP的转发标志就只有允许转发时的或者不允许转发时的这两种),有些整型变量定义一个特定的范围(例如,UDP和TCP的端口号...

  • Java中创建泛型数组 使用泛型时,我想很多人肯定尝试过如下的代码,去创建一个泛型数组 T[] array = new T[]; 当我们写出这样的代码时编译器会报Cannot create a generic array of T,初学泛型时,看到这个错就以为Java中不能创建泛型数组,随着不断的深入,当看到Tinking in J...

  • 1.带有【超类型限定 super】的通配符可以向泛型对象写入,带有【子类型限定 extends】的通配符可以从泛型对象读取,反之则不然。 转载于:https://www.cnblogs.com/baokang/p/7441122.html...

  • 约束简介约束用于确保数据库数据满足特定的商业逻辑或者企业规则,如果定义了约束,并且数据不符 合约束,那么DML操作(INSERT、UPDATE、DELETE)将不能成功执行。约束包括NOT NULL、UNIQUE、PRIMARY KEY、FOREING KEY 以及CHECK等五种类型 定义约束列级约束:column [CONSTRA...