C#中的5个泛型类型是什么

这篇文章主要介绍C#中的5个泛型类型是什么，文中介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们一定要看完！

成都创新互联是一家专注于做网站、网站制作与策划设计,德令哈网站建设哪家好?成都创新互联做网站,专注于网站建设十载,网设计领域的专业建站公司;建站业务涵盖:德令哈等地区。德令哈做网站价格咨询:13518219792

什么是泛型（广泛意义上的“泛型”）-->在特定语言（C#）里的泛型-->C#中的5个泛型类型

1、什么是泛型？

2、C#中提供了五种泛型（C#中的泛型）

3、C#中的泛型类（Generic Classes ）

4、泛型方法Generic Methods 

5、泛型结构Generic Structs

6、泛型委托Generic Delegates 

7、泛型接口Generic Interfaces 

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

1、什么是泛型

泛型是通过一种抽象的方式达到方法的重用。“方法的重用”是泛型的目的，其手段是进行抽象，即将“类型”参数化。

There are times, when a class would be more useful if you could “distill” or “refactor” out its actions and apply them not just to the data types for which they are coded, but for other types as well.

Generics allow you to do just that. You can refactor your code and add an additional layer of abstraction so that, for certain kinds of code, the data types are not hard-coded. This is particularly designed for cases in which there are multiple sections of code performing the same instructions, but on different data types. 

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

2、C#中提供了五种泛型

泛型可以让开发人员编写“类型参数化的代码(type-parameterized code)”，它提供了一个容器(placeholders for types)用于存放类型。

The generics feature offers a more elegant way of using a set of code with more than one type. Generics allow you to declare type-parameterized code, which you can instantiate with different types. This means you can write the code with “placeholders for types” and then supply the actual types when you create an instance of the class. 

C#提供了5种类型的泛型：classes, structs, interfaces, delegates和 methods.

C# provides five kinds of generics: classes, structs, interfaces, delegates, and methods. Notice that the first four are types, and methods are members.

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

3、泛型类（Generic Classes ）

创建并实例化泛型类的过程：

Generic Class-->Constructed Type-->instances of the constructed type

As you know, there are two steps for creating and using your own regular, nongeneric classes: declaring the class and creating instances of the class. However, generic classes are not actual classes, but templates for classes—so you must first construct actual class types from them. You can then create references and instances from these constructed class types. 

1.  Declare a class, using placeholders for some of the types. 

2.  Provide actual types to substitute in for the placeholders. This gives you an actual class definition, with all the “blanks” filled in. This is called a constructed type. 

3.  Create instances of the constructed type.

3.1、Declaring a Generic Class （声明一个泛型类）

Declaring a simple generic class is much like declaring a regular class, with the following differences: 

1、在类名之后使用“<>”

2、在<>中放置类型参数（type parameters），中间以“,”分隔

3、在泛型类内部使用类型参数（type parameters）

1. You place a matching set of angle brackets after the class name. 

2. Between the angle brackets, you place a comma-separated list of the placeholder strings that represent the types, to be supplied on demand. These are called type parameters. 

3. You use the type parameters throughout the body of the declaration of the generic class to represent the types that should be substituted in. 

泛型类与普通类的区别就是“<>”

There is no special keyword that flags a generic class declaration. Instead, the presence of the type parameter list, demarcated(定…的界线，区分) with angle brackets, distinguishes a generic class declaration from a regular class declaration.

3.2、Creating a Constructed Type (创建Constructed Type)

Once you have declared the generic type, you need to tell the compiler what actual types should be substituted for the placeholders (the type parameters). The compiler takes those actual types and creates a constructed type, which is a template from which it creates actual class objects. 

type arguments-->type parameters

The real types being substituted for the type parameters are called type arguments.

The compiler takes the type arguments and substitutes them for their corresponding type parameters throughout the body of the generic class, producing the constructed type—from which actual class instances are created.

3.3、Creating Variables and Instances 

A constructed class type is used just like a regular type in creating references and instances.

Many different class types can be constructed from the same generic class. Each one is a separate class type, just as if it had its own separate nongeneric class declaration.

3.4、Comparing the Generic and Nongeneric Stack

3.5、Constraints on Type Parameters

Since the generic stack doesn’t know the type of the items it will be storing, it can’t know what members these types implement.

All C# objects, however, are ultimately derived from class object, so the one thing the stack can be sure of about the items it’s storing is that they implement the members of class object. These include methods ToString, Equals, and GetType. Other than that, it can’t know what members are available. 

To make generics more useful, you need to be able to supply additional information to the compiler about what kinds of types are acceptable as arguments. These additional bits of information are called constraints. Only types that meet the constraints can be substituted for the given type parameter to produce constructed types.

3.5.1、Where Clauses 

Constraints are listed as where clauses. 

1.  Each type parameter that has constraints has its own where clause. 

2.  If a parameter has multiple constraints, they are listed in the where clause, separated by commas. 

The syntax of a where clause is the following:

The important points about where clauses are the following: （多个where clause，注意是复数形式）

1.  They’re listed after the closing angle bracket of the type parameter list. (where clause的位置)

2.  They’re not separated by commas or any other token. （是否有分隔符）

3.  They can be listed in any order. （顺序不重要）

 The token where is a contextual keyword, so you can use it in other contexts. 

3.5.2、Constraint Types and Order

There are five types of constraints.

The where clauses can be listed in any order. The constraints in a where clause, however, must be placed in a particular order. 

1.  There can be at most one primary constraint, and if there is one, it must be listed first. 

2.  There can be any number of InterfaceName constraints. 

3.  If the constructor constraint is present, it must be listed last.

以上是“C#中的5个泛型类型是什么”这篇文章的所有内容，感谢各位的阅读！希望分享的内容对大家有帮助，更多相关知识，欢迎关注创新互联行业资讯频道！