Network Security Internet Technology Development Database Servers Mobile Phone Android Software Apple Software Computer Software News IT Information

In addition to Weibo, there is also WeChat

Please pay attention

WeChat public account

Shulou

What are the five generic types in C #

2025-01-28 Update From: SLTechnology News&Howtos shulou NAV: SLTechnology News&Howtos > Development >

Share

Shulou(Shulou.com)06/02 Report--

This article mainly introduces what are the five generic types in C#. It is very detailed and has a certain reference value. Friends who are interested must finish it!

What are generics ("generics" in a broad sense)-- > generics in a specific language (C #)-- > 5 generic types in C #

1. What is generics?

2. Five generics are available in C# (generics in C#)

3. Generic classes in C # (Generic Classes)

4. Generic method Generic Methods

5. Generic structure Generic Structs

6. Generic delegate Generic Delegates

7. Generic interface Generic Interfaces

=

1. What is generics

Generics achieve the reuse of methods in an abstract way. "reuse of methods" is the purpose of generics, which means abstraction, that is, "type" parameterization.

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. Five generics are available in C#

Generics allow developers to write "type parameterized code (type-parameterized code)", which provides a placeholders for types for storing 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 # provides five types of generics: classes, structs, interfaces, delegates and 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 Classes)

The process of creating and instantiating a generic class:

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 (declare a generic class)

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

1. Use "" after the class name

2. Place the type parameter (type parameters) in the, separated by ","

3. Use type parameters (type parameters) inside generic classes

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.

The difference between generic classes and ordinary classes is "."

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.

Creating a Constructed Type (create 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.

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

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: (multiple where clause, note plural)

They're listed after the closing angle bracket of the type parameter list. (location of where clause)

They're not separated by commas or any other token. (is there a delimiter)

They can be listed in any order. (order is not important)

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.

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

There can be any number of InterfaceName constraints.

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

The above is all the content of the article "what are the five generic types in C#". Thank you for reading! Hope to share the content to help you, more related knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.

Views: 0

*The comments in the above article only represent the author's personal views and do not represent the views and positions of this website. If you have more insights, please feel free to contribute and share.

Share To

Development

Wechat

© 2024 shulou.com SLNews company. All rights reserved.

12
Report