C# 泛型编程基础实例详解-java泛型方法具体实例

C# 泛型编程基础学习：最显著的一点就是它参数化了类型，把类型作为参数抽象出来，从而使我们在实际的运用当中能够更好的实现代码的重复利用，同时它提供了更强的类型安全，更高的效率，不过在约束方面，它只支持显示的约束，这样在灵活性方面就显得不是那么好了。我觉得它之所以能够提供更高的效率是因为泛型在实例化的时候采用了 "on-demand"的模式,即按需实例化,发生在JIT(Just In Time)编译时。

下面来看如何定义一个C# 泛型类，很简单，你只需要意识到一点,在这里,类型已经被参数化了:

C# 泛型编程实例：

using System;   
using System.Collections.Generic;   
using System.Text;   
namespace GenericTest   
{   
　class Program   
　{   
　　static void Main(string[] args)   
　　{   
　　　//使用string,int来实例化Test类   
　　　Test t = new Test("SHY520",22);   
　　　//调用泛型类中的方法   
　　　t.SetValue();   
　　}   
　}   
　/**////   
　/// 定义一个泛型类，该类有两个类型参数，分别是T,S   
　///   
　/// 类型参数   
/// 类型参数   
　public class Test   
　{   
　　//泛型类的类型参数可用于类成员   
　　private T name;   
　　private S age;   
　　public Test(T Name,S Age)   
　　{   
　　　this.name = Name;   
　　　this.age = Age;   
　　}   
　　public void SetValue()   
　　{   
　　　Console.WriteLine(name.ToString());   
　　　Console.WriteLine(age.ToString());   
　　}   
　}   
}  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.

上面的C# 泛型编程例子不是很恰当，目的是让初学C# 泛型的你了解一下泛型的定义及实例化方法，如上，我们定义了一个泛型类，那么如何实现泛型类的继承呢？这里需要满足下面两点中的任何一点即可：

1、C# 泛型类继承中，父类的类型参数已被实例化，这种情况下子类不一定必须是C# 泛型类；

2、父类的类型参数没有被实例化，但来源于子类，也就是说父类和子类都是泛型类，并且二者有相同的类型参数；

//如果这样写的话，显然会报找不到类型T,S的错误   
public class TestChild : Test { }   
//正确的写法应该是   
public class TestChild : Test{ }   
public class TestChild : Test { }   
public class TestChild : Test { }  
1.
2.
3.
4.
5.
6.

接着我们来看看泛型接口，其创建以及继承规则和上面说的泛型类是一样的，看下面的代码：

public interface IList   
{   
　T[] GetElements();   
}   
public interface IDictionary   
{   
　void Add(K key, V value);   
}   
// 泛型接口的类型参数要么已实例化   
// 要么来源于实现类声明的类型参数   
class List : IList, IDictionary   
{   
　public T[] GetElements() { return null; }   
　public void Add(int index, T value)   
　{}   
}  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

在来看一下C# 泛型委托，首先我们定义一个类型参数为T的委托，然后在类中利用委托调用方法：

using System;   
using System.Collections.Generic;   
using System.Text;   
namespace GenericTest   
{   
　//定义一个委托，类型参数为T，返回值类型T   
　//泛型委托支持在返回值和参数上应用类型参数   
delegate string GenericDelete(T value);   
　class test   
　{   
　　static string F(int i) { return "SHY520"; }   
　　static string G(string s) { return "SHY520"; }   
　　static void Main(string[] args)   
　　{   
　　　GenericDelete G1 = G;   
　　　GenericDelete G2 = new GenericDelete(F);   
　　}   
　}   
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

我们再来看C# 泛型方法，C#的泛型机制只支持在方法申明上包含类型参数，也即是泛型方法。特别注意的是，泛型不支持在除了方法以外的其他类/接口成员上使用类型参数，但这些成员可以被包含在泛型类型中，并且可以使用泛型类型的类型参数。还有一点需要说的就是，泛型方法可以在泛型类型中，也可以存在于非泛型类型中。下面我们分别看一下泛型类型的申明，调用，重载和覆盖。

using System;   
using System.Collections.Generic;   
using System.Text;   
namespace GenericTest   
{   
　class GenericClass   
　{   
　　//申明一个泛型方法   
　　public T getvalue(T t)   
　　{   
　　　return t;   
　　}   
　　//调用泛型方法   
　　//注意：在调用泛型方法时，对泛型方法的类型参数实例化   
　　public int useMethod()   
　　{   
　　　return this.getvalue(10);   
　　}   
　　//重载getvalue方法   
　　public int getvalue(int i)   
　　{   
　　　return i;   
　　}   
　}   
　//下面演示覆盖   
　//要注意的是，泛型方法被覆盖时，约束被默认继承，不需要重新指定约束关系   
　abstract class Parent   
　{   
　　public abstract K TEST(K k, V v) where K : V;   
　}   
　class Child : Parent   
　{   
　　public override T TEST(T t, S s)   
　　{   
　　　return t;   
　　}   
　}   
}   
 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.

C# 泛型编程基础实例的基本内容就向你介绍到这里，希望对你了解和学习C# 泛型编程基础有所帮助。

【编辑推荐】