The delegate declaration can contain type parameters.
delegate-declaration: attributes opt delegate-modifiers op t delegate return-type identifier type-parameter-list opt （formal-parameter-list opt） type-parameter-constraints-clauses opt ; (Delegation declaration: Attributes optional delegate modifier optional delegate return type identifier type parameter list optional (formal parameter list optional) type parameter constraint statement optional A delegate declared using type parameters is a Generic delegate declarations. A delegate declaration can support type parameter constraint statements (§20.7) only if it supports a type parameter list. Except as noted, generic delegate declarations follow the same rules as regular delegate declarations. Each type parameter in the declaration defines a name in the specific declaration space associated with the delegate. The scope of the type parameter in the delegate declaration includes the return type, the formal parameter list, and the type parameter constraint statement ##. #Like other generic type declarations, type arguments must be given to form the constructed delegate type. The parameters and return values of the constructed delegate type are replaced by the actual parameters corresponding to each type parameter of the constructed delegate type in the delegate declaration. The result return type and parameter type are used to determine what method is compatible with the constructed delegate type. For example,
Note that the two assignments in the previous Main method are equivalent to the following. The longer form of .
static void Main(){
Predicate<int> p1 = new Predicate<int>(F);
Predicate<string> p2 = new Predicate<string>(G);
}
Copy after login
The shorter form is also possible due to method group conversion, which is explained in §21.9
20.5 construct. Type
A generic type declaration does not itself represent a type. Instead, a generic type declaration is used to form a "blueprint" for many different types by applying type arguments. Type parameters are written in angle brackets. between, and immediately after the generic type declaration name. A type that is named with at least one actual parameter is called a constructed type. Constructed types can be used in most places where type names can appear in the language.
Constructed types can also be used in expressions as a simple name (§20.9.3) or to access a member (§20.9.4). When namespace or type names are evaluated, only generic types with the correct number of type parameters are considered, whereby types are identified with the same identifier whenever they have a different number of type parameters and are declared in different namespaces. Different types are possible. This is useful for mixing generic and non-generic classes in the same program.
namespace System.Collections
{
class Queue{…}
}
namespace Sysetm.Collections.Generic
{
class Queue<ElementType>{…}
}
namespace MyApplication
{
using System.Collections;
using System.Collections.Generic;
class X
{
Queue q1; //System.Collections.Queue
Queue<int> q2;//System.Collections.Generic.Queue
}
}
Copy after login
The detailed rules for name lookups in these codes are described in §20.9. Resolution of ambiguities in these codes is described in §20.6.5.
A type name may identify a constructed type even though it does not directly specify type parameters. This situation occurs when a type is nested within a generic class declaration, and the instance type of the containing declaration will be used implicitly due to name lookup (§20.1.2).
class Outer<T>
{
public class Inner{…}
public Inner i; //i的类型是Outer<T>.Inner
}
Copy after login
In unsafe code, constructed types cannot be used as unmanaged types (§18.2).
20.5.1 Type Arguments
Each actual parameter in a type parameter list is just a type.
Type arguments, in turn, can also be constructed types or type parameters. In unsafe code (§18), type arguments cannot be pointer types. Each type argument must comply with any constraints on the corresponding type parameter (§20.7.1).
class A {…}
class B<T>:A{…}
class C<T>:B<IComparable<T>>{…}
class D<T>:C<T[]>{…}
D<int>的基类是C<int[]>,B<IComparable<int[]>>,A和object。
Copy after login
20.5.4构造类型的成员
构造类型的非继承成员通过替代成员声明的类型实参，构造类型的对应类型实参而得到。
例如，给定泛型类声明
class Gen<T,U>
{
public T[,],a;
public void G(int i ,T t , Gen<U, T> gt){…}
public U Prop(get{…}) set{…}}
public int H{double d}{…}
}
Copy after login
构造类型Gen>有如下的成员。
public int[,][] a;
public void G(int I , int[] t , Gen<IComparable<string>,int[] gt>){…}
public IComparable<string> Prop{get{…} set{…}}
public int H(double d){…}
class A {…}
class B:A{…}
class Colletion{…}
class List<T>:Collection{…}
class Test
{
void F()
{
List<A> listA = new List<A>();
List<B> listB= new List<B>();
Collection c1 = listA; //OK,List<A>是一个集合
Collection c2 = listB; //OK,List<B>是一个集合
List<A> a1 = listB; //错误，没有隐式的转换
List<A> a2 = (List<A>)listB; //错误，没有显式的转换
}
}
Nullable<int> x = null;
Nullable<string> y = null;
Copy after login
和下面的写法相同。
Nullable<int> x = Nullable<int>.default;
Nullable<string> y = Nullable<string>.default;
Copy after login
20.5.8使用别名指令
使用别名可以命名一个封闭构造类型，但不能命名一个没有提供类型实参的泛型类型声明。例如
namespace N1
{
class A<T>
{
class B{}
}
class C{}
}
namespace N2
{
using W = N1.A; //错误，不能命名泛型类型
using X = N1.A.B; //错误，不能命名泛型类型
using Y = N1.A<int>; //ok,可以命名封闭构造类型
using Z = N1.C; //ok
}
class A:Attribute
{
public A(Type t){…}
}
class B<T>: Attribute{} //错误，不能将Attribute用作基类
class List<T>
{
[A(typeof(T))] T t; //错误，在特性中有开放类型
}
class X
{
[A(typeof(List<int>))] int x; //ok,封闭构造类型
[B<int>] int y; //错误，无效的特性名字
}
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
