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

This article mainly introduces how to use the derived constraints of C# generic constraints, which is very detailed and has a certain reference value. Friends who are interested must read it all!

Derived constraints in C # generic constraints use C # generics, and the compiler compiles generic code to IL, regardless of the type arguments that the client will use. Therefore, generic code can try to use methods, properties, or members of generic type parameters that are not compatible with specific types of arguments used by the client. This is unacceptable because it amounts to a lack of type safety. In C #, you need to tell the compiler client which constraints the specified types must follow so that they can be used instead of generic type parameters. There are three types of constraints. Derived constraints instruct the compiler that general type parameters are derived from base types such as interfaces or specific base classes. The default constructor constraint instructs the compiler general type parameters to expose the default public constructor (public constructor with no arguments). Reference / value type constraints constrain general type parameters to reference types or value types. Generic types can take advantage of multiple constraints, and you can even have IntelliSense reflect these constraints when using generic type parameters, for example, suggesting methods or members in a base type.

Demonstration and usage of derived constraint examples in C# generic constraints:

In C # 2.0, you can use the where reserved keyword to define constraints. Use the where keyword in a generic type parameter followed by a derived colon to indicate to the compiler that the generic type parameter implements a specific interface. For example, the following are the derived constraints necessary to implement the Find () method of LinkedList:

Public class LinkedList where K: IComparable {T Find (K key) {Node current = masked head; while (current.NextNode! = null) {if (current.Key.CompareTo (key) = = 0) break; else current = current.NextNode;} return current.Item } / / Rest of the implementation}

You will also get IntelliSense support on the methods of the interfaces you constrain.

When the client declares a variable of type LinkedList to provide type arguments to the keys of the list, the client compiler insists that the key type is derived from IComparable, otherwise it refuses to generate client code.

Note that even if this constraint allows you to use IComparable, it does not eliminate the performance loss caused by boxing when the key used is a value type (for example, an integer). To overcome this problem, the System.Collections.Generic namespace defines the general interface IComparable:

Public interface IComparable {int CompareTo (T other); bool Equals (T other);}

You can constrain the key type parameter to support IComparable, and use the type of the key as the type parameter; this not only gains type safety, but also eliminates boxing when the value type is used as a key:

Public class LinkedList where K: IComparable {...}

Virtually all types that support IComparable in .NET 1.1 support IComparable in .NET 2.0. This makes it possible to use keys of common types (for example, int, string, GUID, DateTime, and so on).

In C # 2.0, all constraints must appear after the actual derived list of general classes. For example, if LinkedList is derived from the IEnumerable interface (for iterator support), you need to place the where keyword immediately after it:

Public class LinkedList: IEnumerable where K: IComparable {...}

Typically, you only need to define constraints at the level you need. In the chain example, it makes no sense to define IComparable-derived constraints at the node level, because the node itself does not compare keys. If you do, you must also place the constraint at the LinkedList level, even if the list does not compare keys. This is because the list contains a node as a member variable, causing the compiler to insist that the key type defined at the list level comply with the constraints that the node places on the generic key type.

In other words, if you define the node as follows:

Class Node where K: IComparable {...}

You must repeat the constraint at the list level, even if you do not provide the Find () method or any other method related to it:

Public class LinkedList where KeyType: IComparable {Node < KeyType,DataType masking H > ead;}

You can constrain multiple interfaces on the same generic type parameter (separated by commas). For example:

Public class LinkedList where K: IComparable,IConvertible {...}

You can provide constraints for each general type parameter used by your class, for example:

Public class LinkedList where K: IComparable where T: ICloneable {...}

You can have a base class constraint, which means that general type parameters are derived from a specific base class:

Public class MyBaseClass {...} public class LinkedList where K: MyBaseClass {...}

However, you can use at most one base class in a constraint because C # does not support multiple inheritance of implementations. Obviously, the base class you constrain cannot be a sealed class or a static class, and this restriction is enforced by the compiler. In addition, you cannot constrain System.Delegate or System.Array as a base class.

You can constrain a base class and one or more interfaces at the same time, but the base class must first appear in the list of derived constraints:

Public class LinkedList where K: MyBaseClass, IComparable {...}

C# does allow you to specify another general type parameter as a constraint:

Public class MyClass where T: U {...}

When dealing with a derived constraint, you can satisfy the constraint by using the base type itself, rather than having to use its strict subclass. For example:

Public interface IMyInterface {...} public class MyClass where T: IMyInterface {...} MyClass obj = new MyClass ()

Or, you can even:

Public class MyOtherClass {...} public class MyClass where T: MyOtherClass {...} MyClass obj = new MyClass ()

Note that derived constraints in C # generic constraints:

When providing derived constraints, the base type (interface or base class) of your constraint must have the same visibility as the general type parameters you define. For example, the following constraints are valid because internal types can use common types:

Public class MyBaseClass {} internal class MySubClass where T: MyBaseClass {}

However, if the visibility of the two classes is reversed, for example:

Internal class MyBaseClass {} public class MySubClass where T: MyBaseClass {}

The compiler issues an error because no client outside the assembly can use the generic type MySubClass, making MySubClass actually an internal type rather than a public type. The reason external clients cannot use MySubClass is that to declare variables of type MySubClass, they need to use types derived from the internal type MyBaseClass.

The above is all the content of the article "how to use derived constraints of C# generic constraints". 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.