c# in depth的泛型实现实例代码

1.默认值表达式
如果已经明确了要处理的类型，也就知道了它的“默认”值。不知道要引用的类型，就不能直接指定默认值。不能使用null,因为它可能不是一个引用类型，不能使用0，因为它可能不是数值类型。虽然很少需要用到默认值，但它偶尔还是有用的。dictionary<tkey,tvalue>就是一个好的例子，它有个tryvalue方法，它的作用有点儿像对数值类型进行处理的tryparse方法：他用一个输出参数来接收你打算获取的值，用一个boolean返回值显示它是否成功。这意味着方法必须用tvalue类型的值来填充输出参数。请记住，输出参数必须在方法正常返回之前赋值。
为了满足这方面的要求，c#2提供了默认值表达式。虽然c#语言规范没有说他是一个操作符，但可以把它看做是与typeof相似的操作符，只是返回值不一样罢了。

using system;
using system.collections.generic;
using system.linq;
using system.text;
using system.threading.tasks;

namespace 默认值表达式
{
    class program
    {
        static int comparetodefault<t>(t value)
        where t : icomparable<t>
        {
            return value.compareto(default(t));
        }

        static void main(string[] args)
        {
            console.writeline(comparetodefault("x"));
            console.writeline(comparetodefault(10));
            console.writeline(comparetodefault(0));
            console.writeline(comparetodefault(-10));
            console.writeline(comparetodefault(datetime.minvalue));
        }
    }
}

运行结果：

在上述代码中，我们为泛型方法使用了3种不同的类型：string,int和datetime. comparetodefault方法规定只能使用实现了icomparable<t>接口的类型作为参数，这样才能为传入的值调用comparto<t>.传入的值要和类型的默认值进行比较。string是引用类型，默认值是null—根据有关compareto的文档，所有引用类型的值都要大于null，所以第一个输出的结果是1，随后三行和int的默认值进行比较，显示int的默认值是0.最后一行输出0，显示了datetime.minvalue就是datetime的默认值。
如果传递的参数是null，上述代码会抛出nullreferenceexception异常。

2.直接比较

虽然上述代码演示了如何进行比较，但我们并不是总是愿意限制我们自己的类型来实现icomparable<t>或者它的姊妹接口iequatable<t>,后者提供了一个强类型的equals(t)方法,以弥补所有类型都具备的equals(object)的不足。如果没有接口允许我们访问一些额外的信息，那么我们能做的事情就很少了。只能调用equals（object）。如果要比较的值时值类型，它会造成装箱。
如果一个类型是未约束的，就可以使用==和！=操作符，但只能将该类型的值与null进行比较。不能直接比较两个t类型的值（会报错，无法通过编译），如果类型实参是一个引用类型，会进行正常的引用比较。如果为t提供的类型实参是一个非可空值类型，与null进行比较总是不相等（这样一来，jit编译器就可以移除这个比较）。如果类型实参是可空值类型，那么就会自然而然的与类型的空值进行比较。
如果一个类型参数被约束成值类型，就完全不能使用==和！=。如果被约束成引用类型，那么具体执行的比较将完全取决于类型参数被约束成什么类型。如果它只是一个引用类型，那么执行的是简单的引用比较。如果被进一步约束成继承自某个重载了==和！=操作符的特定类型，就会使用重载运算符。但要注意，假如调用者指定的类型实参恰巧也进行了重载，那么这个重载操作符是不会使用的。

using system.text;
using system.threading.tasks;

namespace 直接比较实现
{
    class program
    {
        static bool arereferencesequal<t>(t first, t second)
            where t:class
        {
            return first == second;
        }
        static void main(string[] args)
        {
            string name = "joy";
            string intro1 = "my name is "+name;
            string intro2 = "my name is "+name;
            console.writeline(intro1==intro2);
            console.writeline(arereferencesequal(intro1,intro2));
        }
    }
}

运行结果为：

虽然string 重载了==，但在执行的比较中是不会用这个重载的。基本上，在说编译arereferencesequal<t>时，编译器根本不知道有哪些重载可用，就好比传入的只是object类型的参数。
并非只有操作符才有这个问题，遇到泛型类型时，编译器会在编译未绑定时就解析好所有方法重载，而不是等到执行时，才去为每个可能的方法调用重新考虑是否存在更具体的重载。例如，console.writeline(default(t));这个语句总是被解析成console.writeline(object object),即使为t传递的类型恰好就是string，也不会调用console.writeline(string value),这好比普通方法重载是发生在编译时，而不是执行时。
需要对值进行比较时，有两个相当有用的类，他们是equalitycomparer<t>和comparer<t>,两者都位于system.collection.generic命名空间中。他们分别实现了iequalitycomparer<t>（适合对字典进行比较和哈希处理）和icomparer<t>（适合排序）。这两个类的default属性能返回一个实现，能为特点的类型采取正确的比较操作。
说明：泛型比较接口  共有四个主要的泛型接口可用于比较。icomparer<t>和icomparable<t>用于排序（判断某个值是小于、等于还是大于另一个值），而iequalitycomparer<t>和iequatable<t>通过某种标准来比较两个项的相等性，或查找某个项的散列（通过相等性方式匹配）
如果换一种方式来划分这四个接口，icomparer<t>和iequaliycomparer<t>的实例能比较两个不同的值，而icomparer<t>和iequatable<t>的实例则可以比较它们本身和其他值。

3.一个完整的比较实例，表示一对值

这是一个完整的实例，它实现了一个有用的泛型类型，也就是一个pair<t1,t2>，用于容纳两个值，类似键值对，但这两个值之间没有任何关系。
除了提供属性来访问值本身之外，我们还覆盖了equals和gethashcode方法，从而使这个类型的实例能很好的作为字典中的键来使用。
 pair<t1,t2>类

using system;
using system.collections.generic;
using system.linq;
using system.text;
using system.threading.tasks;

namespace 表示一对值的泛型类
{
    public sealed class pair<t1, t2> : iequatable<pair<t1, t2>>
    {
        private static readonly iequalitycomparer<t1> firstcomparer = equalitycomparer<t1>.default;
        private static readonly iequalitycomparer<t2> secondcomparer = equalitycomparer<t2>.default;
        private readonly t1 first;
        private readonly t2 second;
        public pair(t1 first, t2 second)
        {
            this.first = first;
            this.second = second;
        }
        public t1 first { get { return first; } }
        public t2 second { get { return second; } }
        public bool equals(pair<t1, t2> other)
        {
            return other != null && firstcomparer.equals(this.first, other.first) && secondcomparer.equals(this.second, other.second);
        }
        public override bool equals(object obj)
        {
            return equals(obj as pair<t1,t2>);
        }
        public override int gethashcode()
        {
            return firstcomparer.gethashcode(first) * 37 + secondcomparer.gethashcode(second);
        }
    }
}

pair<t1,t2>辅助类

using system;
using system.collections.generic;
using system.linq;
using system.text;
using system.threading.tasks;

namespace 表示一对值的泛型类
{
    public static class pair
    {
        public static pair<t1, t2> of<t1, t2>(t1 first, t2 second)
        {
            return new pair<t1, t2>(first,second);
        }
    }
}

主体方法

using system;
using system.collections.generic;
using system.linq;
using system.text;
using system.threading.tasks;
namespace 表示一对值的泛型类
{
    class program
    {
        static void main(string[] args)
        {
            pair<string, string> pair1 = new pair<string, string>("hello","world");
            pair<string, string> pair2 = new pair<string, string>("hello", "world");
            pair<int, string> pair3 = new pair<int, string>(1,"hello world");
            bool c = pair1.equals(pair2);
            bool d = pair2.equals(pair3);
            system.console.writeline(c);
            system.console.writeline(d);
            system.console.writeline(pair2.gethashcode());

        }
    }
}

运行结果