东莞 网站建设网站定制制作公司

1、泛型

• class 类名<T>
• interface 接口名<T>
• 函数名<T>(...)
• 泛型可以有多个，用 , 分开

// 泛型类
class MyTest<T>
{public T Value;// 这个不是泛型方法哦（只有函数名后面有<>的才是）public void Test(T t){// ...}
}// 普通类
class MyTest
{// 泛型方法public void Test<T>(T t){Console.WriteLine(t);}// 泛型方法public void Test<T>(){T t = default(T);// ...}
}// 泛型接口
interface ICommon<T>
{T Value{set;get;}
}// 普通类继承泛型接口要指定泛型具体类型
class MyCommonImpl : ICommon<int>
{// ...
}// 泛型类与泛型接口所用泛型相同则可不指定接口泛型具体类型
class MyCommonImpl02<T> : ICommon<T>
{// ...
}

2、泛型约束

• 关键字：where
• 一共 6 种约束
  • 值类型：where 泛型字母:struct
  • 引用类型：where 泛型字母:class
  • 存在无参公共构造函数的非抽象类型：where 泛型字母:new()
  • 某个类本身或其派生类：where 泛型字母:类名
  • 某个接口的派生类：where 泛型字母:接口名
  • 另一个泛型类型本身或其派生类型：where 泛型字母:另一个泛型类型字母

2.1、值类型

class Test<T> where T:struct
{public T Value;public void TestFun<K>(K k) where K:struct{Console.WriteLine(k);}
}// 某方法内↓↓↓
Test<int> test = new Test<int>();
test.Value = 10;
test.TestFun(test.Value); // 10

2.2、引用类型

class Test<T> where T:class
{public T Value;public void TestFun<K>(K k) where K:class{Console.WriteLine(k);}
}// 某方法内↓↓↓
Test<string> test = new Test<string>();
test.Value = "嘎嘎";
test.TestFun(test.Value); // "嘎嘎"

2.3、存在无参公共构造函数的非抽象类型

class Test<T> where T:new()
{public T Value;public void TestFun<K>(K k) where K:new(){Console.WriteLine(k);}
}class MyCons
{public override string ToString(){return "这是一个有无参构造的类的ToString()";}
}// 某方法内↓↓↓
Test<MyCons> test = new Test<MyCons>();
test.Value = new MyCons();
test.TestFun(test.Value); // "这是一个有无参构造的类的ToString()"

2.4、某个类本身或其派生类

class Test<T> where T:MyCons
{public T Value;public void TestFun<K>(K k) where K:MyCons{Console.WriteLine(k);}
}class MyCons
{public override string ToString(){return "这是MyCons的ToString()";}
}// 某方法内↓↓↓
Test<MyCons> test = new Test<MyCons>();
test.Value = new MyCons();
test.TestFun(test.Value); // "这是MyCons的ToString()"

2.5、某个接口的派生类

class Test<T> where T : ITest
{public T Value;public void TestFun<K>(K k) where K : ITest{Console.WriteLine(k);}
}interface ITest
{ }class MyTest : ITest
{public override string ToString(){return "这是 ITest 实现类 MyTest 的ToString()";}
}// 某方法内↓↓↓
Test<ITest> test = new Test<ITest>();
test.Value = new MyTest();
test.TestFun(test.Value); // "这是 ITest 实现类 MyTest 的ToString()"

2.6、另一个泛型类型本身或其派生类型

class Test<T, U> where T : U
{public T ValueT;public U ValueU;public void TestFun<K, V>(K k, V v) where K : V{Console.WriteLine("{0}{1}", k, v);}
}interface ITest
{ }class MyTest : ITest
{public override string ToString(){return "这是 ITest 实现类 MyTest 的ToString()";}
}class YourTest : ITest
{public override string ToString(){return "这是 ITest 实现类 YourTest 的ToString()";}
}// 某方法内↓↓↓
Test<ITest, ITest> test = new Test<ITest, ITest>();
test.ValueT = new MyTest();
test.ValueU = new YourTest();
test.TestFun(test.ValueT, test.ValueU);
// 这是 ITest 实现类 MyTest 的ToString()这是 ITest 实现类 YourTest 的ToString()

3、约束组合使用

• 不冲突的情况下随意组合

class Test<T> where T:class, new()
{}

4、多个泛型约束

• 罗列 where 就完了（别随手加逗号啥的，空开即可）

class Test<T, V> where T:class, new() where V:struct
{}