.NET Core(C#)泛型(方法，类，委托，接口)使用示例代码

1､使用示例代码

1)泛型（类、接口、委托）

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace MyGeneric

{

///

/// 一个类来满足不同的具体类型，做相同的事儿

///

///

///

///

///

///

public class GenericClass

//, S, X, Eleven, 老K>

//where T : People

//where S : Chinese

//where Eleven : Hubei

{

public T _T;

}

///

/// 一个接口来满足不同的具体类型的接口，做相同的事儿

///

///

public interface IGenericInterface //where T : People

{

T GetT(T t);//泛型类型的返回值

}

public class CommonClass

//: GenericClass//必须指定

: IGenericInterface//必须指定

{

public int GetT(int t)

{

throw new NotImplementedException();

}

}

public class GenericClassChild

//: GenericClass

: GenericClass, IGenericInterface

{

public Eleven GetT(Eleven t)

{

throw new NotImplementedException();

}

}

public delegate void SayHi(T t);//泛型委托

}

2) 泛型方法

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace MyGeneric

{

///

/// 泛型方法

///

public class GenericMethod

{

///

/// 2.0推出的新语法

/// 泛型方法解决用一个方法，满足不同参数类型；做相同的事儿

/// 没有写死参数类型，调用的时候才指定的类型

///

/// T/S 不要用关键字 也不要跟别的类型冲突

///

public static void Show(T tParameter)

{

Console.WriteLine("This is {0},parameter={1},type={2}",

typeof(GenericMethod), tParameter.GetType().Name, tParameter.ToString());

}

public static void ShowObject(object oParameter)

{

Console.WriteLine("This is {0},parameter={1},type={2}",

typeof(GenericMethod), oParameter.GetType().Name, oParameter);

}

}

}

2、泛型类介绍

泛型类封装了不针对任何特定数据类型的操作。泛型类常用于容器类，如链表、哈希表、栈、队列、树等等。这些类中的操作，如对容器添加、删除元素，不论所存储的数据是何种类型，都执行几乎同样的操作。

对大多数情况，推荐使用.NET框架2.0类库中所提供的容器类。有关使用这些类的详细信息，请参见基础类库中的泛型。

通常，从一个已有的具体类来创建泛型类，并每次把一个类型改为类型参数，直至达到一般性和可用性的最佳平衡。当创建你自己的泛型类时，需要重点考虑的事项有：

哪些类型应泛化为类型参数。一般的规律是，用参数表示的类型越多，代码的灵活性和复用性也就越大。过多的泛化会导致代码难以被其它的开发人员理解。

如果有约束，那么类型参数需要什么样约束。一个良好的习惯是，尽可能使用最大的约束，同时保证可以处理所有需要处理的类型。例如，如果你知道你的泛型类只打算使用引用类型，那么就应用这个类的约束。这样可以防止无意中使用值类型，同时可以对T使用as运算符，并且检查空引用。

把泛型行为放在基类中还是子类中。泛型类可以做基类。同样非泛型类的设计中也应考虑这一点。泛型基类的继承规则 。

是否实现一个或多个泛型接口。例如，要设计一个在基于泛型的容器中创建元素的类，可能需要实现类似IComparable的接口，其中T是该类的参数。

//泛型类：

public class MySQLHelp

{

private T t;

public MySQLHelp(T t)

{

this.t = t;

}

}

//测试类

public class Test{

public static void Main(){

MySQLHelp mm = new MySQLHelp(new Message());

}

}

//其他类

public class Message{

}

3､泛型接口介绍

不论是为泛型容器类，还是表示容器中元素的泛型类，定义接口是很有用的。把泛型接口与泛型类结合使用是更好的用法，比如用IComparable而非IComparable，以避免值类型上的装箱和拆箱操作。.NET框架2.0类库定义了几个新的泛型接口，以配合System.Collections.Generic中新容器类的使用。

当一个接口被指定为类型参数的约束时，只有实现该接口的类型可被用作类型参数。下面的示例代码显示了一个从MyList派生的SortedList类。更多信息，请参见泛型概述。SortedList增加了约束where T : IComparable。

这使得SortedList中的BubbleSort方法可以使用表中的元素的IComparable.CompareTo方法。在这个例子中，表中的元素是简单类——实现IComparable的Person类。

using System;

using System.Collections.Generic;

//Type parameter T in angle brackets.

public class MyList

{

protected Node head;

protected Node current = null;

// Nested type is also generic on T

protected class Node

{

public Node next;

//T as private member datatype.

private T data;

//T used in non-generic constructor.

public Node(T t)

{

next = null;

data = t;

}

public Node Next

{

get { return next; }

set { next = value; }

}

//T as return type of property.

public T Data

{

get { return data; }

set { data = value; }

}

}

public MyList()

{

head = null;

}

//T as method parameter type.

public void AddHead(T t)

{

Node n = new Node(t);

n.Next = head;

head = n;

}

// Implement IEnumerator to enable foreach

// iteration of our list. Note that in C# 2.0

// you are not required to implment Current and

// GetNext. The compiler does that for you.

public IEnumerator GetEnumerator()

{

Node current = head;

while (current != null)

{

yield return current.Data;

current = current.Next;

}

}

}

public class SortedList : MyList where T : IComparable

{

// A simple, unoptimized sort algorithm that

// orders list elements from lowest to highest:

public void BubbleSort()

{

if (null == head || null == head.Next)

return;

bool swapped;

do

{

Node previous = null;

Node current = head;

swapped = false;

while (current.next != null)

{

// Because we need to call this method, the SortedList

// class is constrained on IEnumerable

if (current.Data.CompareTo(current.next.Data) > 0)

{

Node tmp = current.next;

current.next = current.next.next;

tmp.next = current;

if (previous == null)

{

head = tmp;

}

else

{

previous.next = tmp;

}

previous = tmp;

swapped = true;

}

else

{

previous = current;

current = current.next;

}

}// end while

} while (swapped);

}

}

// A simple class that implements IComparable

// using itself as the type argument. This is a

// common design pattern in objects that are

// stored in generic lists.

public class Person : IComparable

{

string name;

int age;

public Person(string s, int i)

{

name = s;

age = i;

}

// This will cause list elements

// to be sorted on age values.

public int CompareTo(Person p)

{

return age - p.age;

}

public override string ToString()

{

return name + ":" + age;

}

// Must implement Equals.

public bool Equals(Person p)

{

return (this.age == p.age);

}

}

class Program

{

static void Main(string[] args)

{

//Declare and instantiate a new generic SortedList class.

//Person is the type argument.

SortedList list = new SortedList();

//Create name and age values to initialize Person objects.

string[] names = new string[]{"Franscoise", "Bill", "Li", "Sandra", "Gunnar", "Alok", "Hiroyuki", "Maria", "Alessandro", "Raul"};

int[] ages = new int[]{45, 19, 28, 23, 18, 9, 108, 72, 30, 35};

//Populate the list.

for (int x = 0; x < 10; x++)

{

list.AddHead(new Person(names[x], ages[x]));

}

//Print out unsorted list.

foreach (Person p in list)

{

Console.WriteLine(p.ToString());

}

//Sort the list.

list.BubbleSort();

//Print out sorted list.

foreach (Person p in list)

{

Console.WriteLine(p.ToString());

}

Console.WriteLine("Done");

}

}

可以在一个类型指定多个接口作为约束，如下:

class Stack where T : IComparable, IMyStack1{}

一个接口可以定义多个类型参数，如下:

IDictionary

接口和类的继承规则相同：

IMyInterface : IBaseInterface

IMyInterface : IBaseInterface

IMyInterface: IBaseInterface

具体类可以实现封闭构造接口，如下:

class MyClass : IBaseInterface

泛型类可以实现泛型接口或封闭构造接口，只要类的参数列表提供了接口需要的所有参数，如下:

class MyClass : IBaseInterface

class MyClass : IBaseInterface

4､泛型方法介绍

泛型方法是声名了类型参数的方法，如下：

void Swap( ref T lhs, ref T rhs)

{

T temp;

temp = lhs;

lhs = rhs;

rhs = temp;

}

下面的示例代码显示了一个以int作为类型参数，来调用方法的例子：

int a = 1;

int b = 2;

//…

Swap(a, b);

也可以忽略类型参数，编译器会去推断它。下面调用Swap的代码与上面的例子等价：

Swap(a, b);

静态方法和实例方法有着同样的类型推断规则。编译器能够根据传入的方法参数来推断类型参数；而无法单独根据约束或返回值来判断。因此类型推断对没有参数的方法是无效的。类型推断发生在编译的时候，且在编译器解析重载方法标志之前。编译器对所有同名的泛型方法应用类型推断逻辑。在决定（resolution）重载的阶段，编译器只包含那些类型推断成功的泛型类。更多信息，请参见C# 2.0规范，20.6.4类型参数推断

在泛型方法中，非泛型方法能访问所在类中的类型参数，如下：

class MyClass

{

//…

void Swap (ref T lhs, ref T rhs){…}

}

[JX1] 定义一个泛型方法，和其所在的类具有相同的类型参数；试图这样做，编译器会产生警告CS0693。

class MyList

{

// CS0693

void MyMethod{...}

}

class MyList

{

//This is okay, but not common.

void SomeMethod(){...}

}

使用约束可以在方法中使用更多的类型参数的特定方法。这个版本的Swap称为SwapIfGreater，它只能使用实现了IComparable的类型参数。

void SwapIfGreater( ref T lhs, ref T rhs) where T: IComparable

{

T temp;

if(lhs.CompareTo(rhs) > 0)

{

temp = lhs;

lhs = rhs;

rhs = temp;

}

}

泛型方法通过多个类型参数来重载。例如，下面的这些方法可以放在同一个类中：

void DoSomething(){}

void DoSomething(){}

void DoSomething(){}

5､泛型委托介绍

无论是在类定义内还是类定义外，委托可以定义自己的类型参数。引用泛型委托的代码可以指定类型参数来创建一个封闭构造类型，这和实例化泛型类或调用泛型方法一样，如下例所示：

public delegate void MyDelegate(T item);

public void Notify(int i){}

//...

MyDelegate m = new MyDelegate(Notify);

C#2.0版有个新特性称为方法组转换（method group conversion），具体代理和泛型代理类型都可以使用。用方法组转换可以把上面一行写做简化语法：

MyDelegate m = Notify;

在泛型类中定义的委托，可以与类的方法一样地使用泛型类的类型参数。

class Stack

{

T[] items;

int index

//...

public delegate void StackDelegate(T[] items);

}

引用委托的代码必须要指定所在类的类型参数，如下：

Stack s = new Stack();

Stack.StackDelegate myDelegate = StackNotify;

泛型委托在定义基于典型设计模式的事件时特别有用。因为sender[JX2] ，而再也不用与Object相互转换。

public void StackEventHandler(T sender, U eventArgs);

class Stack

{

//…

public class StackEventArgs : EventArgs{...}

public event StackEventHandler, StackEventArgs> stackEvent;

protected virtual void OnStackChanged(StackEventArgs a)

{

stackEvent(this, a);

}

}

class MyClass

{

public static void HandleStackChange(Stack stack, StackEventArgs args){...};

}

Stack s = new Stack();

MyClass mc = new MyClass();

s.StackEventHandler += mc.HandleStackChange;