c#2解决c#1中的问题之用泛型实现参数化类型

时间:2022-01-28 09:04:38

为什么需要泛型

你手中还有c#1的代码吗?数一数其中的强制转换有多少,特别是那些大量使用集合的代码。几乎每次使用foreach都需要隐式的强制转换。使用那些为不同数据类型而设计的类型,就意味着强制转换。他们平静的告诉编译器:什么都别担心,一切都很正常,把那个表达式看做似乎它具有这种特性就可以了。任何api只要将object作为参数类型或返回类型使用,就可能在某个时候涉及强制类型转换。设计只有一个类,并将object作为根的层次结构,将使一切都变的更加简单。但是object类型本身是及其愚钝的一个存在。要用一个object做真正有意义的事情,几乎都要对它进行强制类型转换。

强制类型转换很糟糕吧。它并不是“永远不用”的那种糟糕,而是不得不用的那种糟糕。但是,如果要想达到某个目的就不得不用,那它就是坏的。发生强制类型转换后,就意味着你本来应该为编译器提供更多信息,但你选择的是让编译器在编译时相信你,并生成一个检查,以便执行时运行,以验证你所言非虚。

如果需要在某处将某些信息传达给编译器,那么正在读你代码的人也极有可能需要相同的信息。当然,他们能在你进行强制转换的时候读到这些信息,但那几乎没有任何用处。保存这些信息的理想位置是声明变量或方法的位置。如果提供一个其他人不需要访问源代码就能调用的类型或方法,这一点就更加重要。有了泛型,用户在程序中用错误的参数调用库时,就无法通过编译。

以上这些足以证明泛型存在的价值。但泛型还改善了性能。首先,由于编译器能执行更多的检查,所以执行时的检查就可以少做,其次,JIT非常聪明地处理值类型,能消除许多情况下的装箱和拆箱处理。某些情况下,无论在速度还是内存的消耗上,有泛型和没有泛型的结果会大相径庭。

泛型所带来的好处非常像静态语言较之动态语言的优点:更好的编译时检查,更多的在代码中能表现的信息,更多的IDE支持,更好的性能。

日常使用的简单泛型

泛型字典

用Dictionary<TKey,TValue>统计文本中的单词数

static Dictionary<string,int> CountWords(string text)

{

Dictionary<string,int> frequencies;

frequencies=new Dictionary<string,int>();

string[] words=Regex.Split(text,@"\W+");

foreach(string word in words)

{

if(frequencies.ContaninsKey(word))

{

frequencies[word]++;

}

else

{

frequencies[word]=;

}

return frequencies;

}

...

string text=@"Do you like green eggs and ham?

I do not like them, Sam-I-am.

I do not like green eggs and ham.";

Dictionary<string,int> frequencies=CountWords(text);

foreach(KeyValuePair<string,int>)

{

string word=entry.Key;

int frequency=entry.Value;

Console.WriteLine(word+value);

}

泛型字典

 泛型类型和类型参数

有两种形式的泛型:泛型类型(包括类、接口、委托和结构)和泛型方法。

类型参数是真实类型的占位符。在泛型声明中,类型参数要放在一对尖括号中,并以逗号分开。使用泛型类型或者方法时,要用真实的类型代替。这些真实的类型称为类型实参。

如果没有为任何类型参数提供类型实参,声明的就是一个未绑定泛型类型。如果制定了类型实参,该类型就称为一个已构造类型。类型可以看做是对象的蓝图。未绑定泛型类型是是已构造类型的蓝图。它是一种额外的抽象层。如下图所示c#2解决c#1中的问题之用泛型实现参数化类型

已构造类型可以是开放或封闭的。开放类型还包含一个类型参数,而封闭类型则不是开放的,类型的每个部分都是明确的。所有代码实际都是在一个封闭的已构造类型的上下文中执行。

类型参数“接收”信息,类型实参“提供”信息,这个思路与方法参数/方法实参是一样的。只不过类型实参必须为类型,而不能为任意的值。只有在编译时才能知道类型实参的类型,它可以是(或包含)相关上下文中的类型参数。

可以认为“封闭类型”拥有“开放类型”的API,只不过类型参数被替换成了对应的类型实参。

以下是Dictionary<TKey,TValue>可能的代码,虽然没有包括任何实际的方法实现,而且实际的成员数量比这更多。

namespace System.Collections.Generic

{

public class Dictionary<TKey,TValue>:IEnumerable<KeyValuePair<TKey,TValue>>

{

public Dictionary(){.....}

pubic void Add(TKey key,TValue){....}

public TValue this[TKey key]

{

get{...}

set{...}

}

public bool ContainsValue(TValue value){...}

public bool ContainsKey(TKey key){...}

{...other members...}

}

}

注意Dictionary<TKey,TValue>是如何实现泛型接口IEnumerable<KeyValuePaie<TKey,TValue>>的(事实上还实现了其他许多接口)。为类指定任何类型的实参都可以应用到具有相同类型的接口中。所以,在我们的例子中,Dictionary<sring,int>会实现IEnumerable<KeyValuePair<string,int>>.后者实际是某种“双重泛型”结构。正是由于实现了IEnumerable<KeyValuePair<string,int>>接口,上例子中才能像那样枚举keys和values.

还值得指出的是,构造函数不在尖括号中列出类型参数。类型参数从属于类型,而非从属于某个特定的构造函数,所以才会在声明类型的时候声明。成员(仅限方法)仅在引入新类型参数时才需要声明。

泛型可以重载,只需改变一下类型参数的数量就可以了。

 泛型方法和判读泛型声明

我们已经习惯于方法的参数和返回值有固定的类型,而且已看到了泛型类型如何在它的方法声明中使用类型参数。泛型方法则更进一步—即使你已经确切地知道要操作哪一个已构造类型,泛型方法也可以有类型参数。

虽然Dictionary<TKey,TValue>没有任何泛型方法,但它的近亲List<T>是有的。你能想的到,List<T>表示的是由任意指定类型的数据项构成的一个列表。先记住这一点:T是在整个类的范围内使用的类型参数。

泛型方法实例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace test泛型
{
class Program
{
static Guid getGuid(string x)
{
System.Guid guid = System.Guid.NewGuid();
return guid;
}
static void Main(string[] args)
{
List<string> stringers = new List<string>();//创建一个字符串列表
stringers.Add("hello");
stringers.Add("word");
Converter<string, Guid> converter = getGuid;//创建委托实例
List<Guid> guids;
guids=stringers.ConvertAll<Guid>(converter);//调用委托
foreach(Guid g in guids)
{
Console.WriteLine(g.ToString());
}
}
}
}

运行结果:c#2解决c#1中的问题之用泛型实现参数化类型

 在非泛型类型中实现泛型方法

非泛型类型也可以拥有泛型方法

实例:

 static List<T> MakeList<T> (T first ,T second)
{
List<T> list=new List<T>;
list.Add(first);
list.Add(second);
return list;
}
....
List<string> list=MakeList<string>("Line 1","Line 2");
foreach(string x in list)
{
Console.WriteLine(x);
}