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

为什么需要泛型

你手中还有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]=1;

}

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);

}

 泛型类型和类型参数

有两种形式的泛型：泛型类型（包括类、接口、委托和结构）和泛型方法。

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

如果没有为任何类型参数提供类型实参，声明的就是一个未绑定泛型类型。如果制定了类型实参，该类型就称为一个已构造类型。类型可以看做是对象的蓝图。未绑定泛型类型是是已构造类型的蓝图。它是一种额外的抽象层。如下图所示

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

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

可以认为“封闭类型”拥有“开放类型”的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());
            }
        }
    }
}

运行结果：

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

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

实例：

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);
}