从C# 2.0 爬向 C# 4.0—— 先说说 泛型——C# 是个优雅的语言

前言

开始时学的是C#2.0而且没有学完全。工作后，不是在忙着赶项目，就是对各种技术尝尝鲜，而语言的学习却没有什么进步。直到半年前开始入门Python（纯粹爱好，断断续续的学着）才发现——原来编程还可以这样！原来代码还可以这样写！

沉溺于各种设计模式、框架、新鲜技术

回眸一望

忽然发现

她

依然如此优雅

甚至

更胜从前！

目标

补完C# 2.0 3.0的新特性，然后在研究研究4.0。本章先从泛型开始温习一下。

参考链接

详细读完这些文章，你就不用看我写的了！如有不明请往下，还是不明请留言，大家相互讨论。

C#泛型简介

Predicate泛型委托

Func（T，TResut）委托

泛型委托（C#编程指南）

走进Linq-Linq大观园

C++ 模板和 C# 泛型间的区别

泛型

有句经典的等式： 算法+ 数据结构 = 程序！写程序总会遇到一些算法相同（处理方法相似），但数据结构不同的情况。难道就为了把int 改成 double 、Struct或Class A ，而把代码再打一遍吗？

　　你很勤快，不在乎多敲一次代码？不，程序员应该很懒！让机器帮我们去做吧，于是我们有了泛型——Class Stack<T>。

C#2.0 引入了泛型它类似于C++的模板（都是C 一家亲嘛，另外推荐一篇利用C++模板来打印质数的博文，它的厉害之处在于利用c++模板的特性，在编译时计算出质数而不是运行时 ——质数打印），但是在实现和功能方面还是存在差异的。我们可以这样定义泛型

/// <summary>
/// 在类上定义
/// </summary>
/// <typeparam name="T"></typeparam>
public class Stack<T>
{
public void Push(T value)
{ }
}

/// <summary>
/// 在方法里
/// </summary>
public class Stack
{
public void Push<T>(T value)
{ }
public T Pop<T>(T value1, T value2) { return value1; }
}
/// <summary>
/// 错误案例，因为 占位符 还没声明，就使用了。
/// </summary>
//public class StackT
//{
//    public void Push(T value)
//    { }
//}

//委托
public delegate TResult Add<T,TResult>(T value);

其实T 就是一个占位符（为啥是T？当然你也可以是V、R、Y，这得从它哥哥说起），个人认为把泛型里的T理解为占位符是最直接的。先声明<T> ，然后就可以在该泛型里，直接使用这个占位符T了。编译器会根据 调用泛型时指定的占位符T的类型，来替换 或推断出对应的类型。

//声明
public class Stack<T>
{
//在 Stack 的范围里 可以调用。
public void Push(T value)
{ }

public void Pop<V>(statck<V> s, params V[] p){}
}

在使用 class Stack 时 必须指定T 占位符是什么,编译器就能推断出 Push(T)的类型了。而Pop 里的V是另一个占位符，在使用时需要指定。

Stack<int> stack = new Stack<int>();
stack.Pop<string>("nihao ", "sdfsdf", "sdfsdf", "sdfsdfvwevwwve");

其实这个例子除了表明一些语法外，没什么意义。

泛型委托

委托也可以定义泛型，将参数一般化。在.net 3.5 里为我们定义了几个常见的泛型委托Predicate<> Func<> Action<> 等几个泛型。 有了这几个常用的委托我们写起代码来就更加方便了。

View Code

class Program
{
static void Main(string[] args)
{

Func<string, string> test1 = IsTooLong;
Func<string, string> test2 = delegate(string str)
{
if (str.Length > 10)
{
return "Too long";
}
else
{
return "ok";
}
};
Func<string, string> test3 = (str) => str.Length > 10 ? "Too long" : "ok";

Console.WriteLine(test3("sodiinbgweoeinbowevw"));

Console.Read();
}

static string IsTooLong(String value)
{
if (value.Length > 10)
{
return "Too long";
}
else
{
return "ok";
}
}

}

代码使用 Func<> 定义了3个有返回值的委托， 然后再将委托的运行结果输出，如果字符串的长度大于10 则输出“Too Long”。

test1里 也可以写成“test1 = new Func<string, string>(IsTooLong);” ，但是直接赋予 =IsTooLong更简洁不是吗？ 这得归功于编译器的委托推理，它能够推断出我们分配到委托的类型，并验证该方法是否与签名相匹配。

test2 用到了 匿名方法

test3 则是使用了lambda 表达式，这个是不是更简洁。

后记

这里只简单的介绍一下泛型，详细的信息可以查看参考链接。把T 理解为占位符 就好，编译器会帮我们替换它的。