19.C# 泛型

1.泛型的概念

所谓泛型，即通过参数化类型来实现在同一份代码上操作多种数据类型。泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的复用。

2. .net提供的泛型

2.1可空类型System.Nullable<T>

简单类型和引用类型的一个区别是简单类型必须包含一个值，引用类型可以是null，有时候需要把简单类型设置为可空类型，比如在处理数据库数据的时候。可以使用System.Nullable<T>声明一个可空类型，如System.Nullable<int> nullableInt = null;可以通过判断可空类型是否为null或者判断HasValue是否为true确定可空类型是否为空，如

            System.Nullable<int> nullableInt = null;
            if (nullableInt == null)
            {
                //
            }
            //等价于
            if (nullableInt.HasValue)
            {
                //
            }

可空类型缩写，因为可空类型比较常用，所以可以使用了一个比较简便的声明方式，可以在简单类型后面加个问号表示可以空类型，如int? op1=5

可空类型可以像简单类型一样使用+-*/等运算符来处理值，

int ? op1=
int ? op2=op1*;

简单类型可以隐式转换成可空类型，可空类型转换成简单类型必须使用显示转换..如下例子2会隐式转换成可空类型参与运算，运算结果强制转换成int类型。

int? op1=
int op2 =(int)op1*;

我们也可以通过可空类型的Value属性进行计算，但要判断是否有值，否则会引发异常

int? op1 = ;
if (op1.HasValue)
{
      int op2 = op1.Value + ;
}

对于bool？之外的简单可空类型，如果运算式子中有一个为null，则计算结果为null

int? op1 = null;
 int? op2 = op1 + ;//null

对于bool? 可以使用的运算符有&、|.他们的计算结果如下

op1	op2	op1&op2	op1|op2
true	true	true	true
true	false	false	true
true	null	null	true
false	true	false	true
false	false	false	false
false	null	false	null
null	true	null	true
null	false	false	null
null	null	null	null

可以这样简单的记忆，对于&运算符有一个false则为false，不管有没有null,其他情况有null皆为null；

对于|相反，有一个true则为true，不管有没有null，其他情况有null皆为null。

2.2空接运算符??

int ?op1=;
int ? op2=op1*??

等价于
int ? op1=;
int ? op2=op1*==null?:op1*；

如果??前面的表达式的值为null，则赋予??后面表达式的值赋给变量，否则把？？前面表达式的值赋值给变量

3..net提供的泛型

3.1 List<T>

使用List<T>可以很轻易的创建自己想要的强类型集合，它的很多方法都已经自动实现了，不必像之前那样从CollectionBase继承，并实现对应的方法。

创建T类型的对象需要以下语法,T是我们使用的具体类型，比如string。

List<T> myCollection=new List<T>(); 

List<T>有3个构造函数,我们可以使用默认的构造函数，也可以传一个支持IEnumerable接口的集合，或者传入一个list的初始容量。

public List()
public List(IEnumerable<T> collection)
public List(int capacity)

List<T>支持的方法和属性：

成员	说明
int Count	返回集合中项的个数
void Add(T item )	把一个项添加到集合中
void AddRange(IEnumerable <T>)	把多个项添加到集合中
IList<T> AsReadOnly	给集合返回一个只读接口
int Capacity	获取或者设置集合可以包含的项数。Capicity大于等于Count
void Clear()	清空所有项
bool Contains(T item)	确定项item是否包含在集合中
void CopyTo(T [] array,int index)	把集合复制到数组array中，从数组的索引index开始
IEnumerator<T>GetEnumerator()	获取一个IEnumerator<T>实例用于foreach循环。注意：返回的接口是强类型化为T的，所以不需要类型转换。
int Indexof(T item)	获取item的索引
int Insert(int index,T item)	在index位置插入item项
bool Remove(T item)	在集合中删除第一个item，并返回true，如果item不存在返回false
void RemoveAt(int index)	删除index位置的项

List<T>还有一个Item属性，允许List<T>像数组那样用下标进行访问

T item=myCollectionOfT[2];

List<T>例子

    class Animal
    {
        public string name;
        public Animal(string name)
        {
            this.name = name;
        }

        public void Feed()
        {
            Console.WriteLine("{0} has been Feeded.", this.name);
        }
    }
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {

            List<Animal> list = new List<Animal>();
            Animal a = new Animal("Rock");
            Animal b = new Animal("Peter");
            Animal c = new Animal("Tom");
            list.Add(a);
            list.Add(b);
            list.Add(c);
            list.Add(a);

            foreach (Animal o in list)
            {
                o.Feed();
            }

            Console.WriteLine(list.IndexOf(a));//返回第一个a的索引，如果集合未包含a返回-1

            list.Remove(a);//删除第一个a
            Console.WriteLine(list.IndexOf(a));
            Console.WriteLine("删除后");
            foreach (Animal o in list)
            {
                o.Feed();
            }

            Console.WriteLine("Count:{0},Capacity:{1}", list.Count, list.Capacity);
                Console.ReadLine();
        }
    }

 3.2对泛型列表进行排序和搜索

对泛型列表进行排序和其他列表是一样的，其他列表，比如ArrayList可以通过IComparable、IComparer接口进行排序，泛型列表可以通过实现IComparable<T>，IComparer<T>进行排序，唯一的区别在于IComparable<T>，IComparer<T>是强类型化的，它只针对特定类型进行排序。下表列出了他们的区别：

泛型方法	非泛型方法	区别
int IComparable<T>.CompareTo(T otherObj)	int IComparable.CompareTo(object obj)	泛型版本是强类型化的
int IComparer<T>.CompareTo(T otherObj)	int IComparer.CompareTo(object obj)	泛型版本是强类型化的

 //实现IComparable<Vector>的好处是比较时传入参数是强类型化的，不用类型转换
    class Vector:IComparable,IComparable<Vector>
    {
        public double? R = null;//大小
        public double? Theta = null;//方向,单位度

        //弧度
        public double? ThetaRadians
        {
            //度和弧度转换180度=pi弧度，
            get
            {
                return (Theta * Math.PI / );
            }
        }

        public Vector(double? r, double? theta)
        {
            if (r < )
            {
                r = -r;
                theta += ;
            }

            Theta = theta % ;
            R = r;
        }

        public override string ToString()
        {
            string rString = R.HasValue ? R.ToString() : "null";
            string thetaString = Theta.HasValue ? Theta.ToString() : "null";
            return string.Format("{0},{1}",rString,thetaString);
        }

        public int CompareTo(object obj)
        {
            if (this.R > ((Vector)obj).R)
                return -;
            else if (this.R < ((Vector)obj).R)
                return ;
            return ;
        }

        public int CompareTo(Vector other)
        {
            if (this.R > other.R)
                return ;
            else if (this.R < other.R)
                return -;
            return ;
        }

    }

    class Vectors:List<Vector>
    {
        public Vectors()
        { }

        public Vectors(IEnumerable<Vector> initialItem)
        {
            AddRange(initialItem);
        }
    }

    class VectorDelegates
    {
        public static int Compare(Vector x, Vector y)
        {
            if (x.R > y.R)
                return ;
            else if (x.R < y.R)
                return -;
            return ;

        }

        public static bool TopRightQuadrant(Vector target)
        {
            if (target.Theta >= 0.0 && target.Theta <= 90.0)
                return true;
            else
                return false;
        }
    }

    class VectorComparer :IComparer,IComparer<Vector>
    {
        public static VectorComparer Default= new VectorComparer();

        public int Compare(object x, object y)
        {
            return (int)(((Vector)x).Theta-((Vector)y).Theta);
        }

        public int Compare(Vector x, Vector y)
        {
            return (int)(x.Theta-y.Theta);
        }
    }

    class Program
    {

        static void Main(string[] args)
        {
            Vectors route = new Vectors();
            route.Add(new Vector(2.0, 90.0));
            route.Add(new Vector(1.0, 180.0));
            route.Add(new Vector(0.5, 45.0));
            route.Add(new Vector(2.0, 90.0));
            route.Add(new Vector(2.5, 315.0));

            //使用Vector默认的比较方法排序，如果同时实现了IComparable,IComparable<Vector>两个接口，比较时优先使用强类型化的方法
            //所以以下排序会使用public int CompareTo(Vector other)方法而不是public int CompareTo(object obj)排序
            route.Sort();

            Console.WriteLine("默认排序，按大小降序");
            foreach (Vector v in route)
            {
                Console.WriteLine(v.ToString());
            }

            Console.WriteLine("使用泛型委托排序，按大小升序");
            Comparison<Vector> sorter = new Comparison<Vector>(VectorDelegates.Compare);
            route.Sort(sorter);
            foreach (Vector v in route)
            {
                Console.WriteLine(v.ToString());
            }

            Console.WriteLine("使用IComparer<T>接口排序，按角度大小升序");
            route.Sort(VectorComparer.Default);
            foreach (Vector v in route)
            {
                Console.WriteLine(v.ToString());
            }

            Console.WriteLine("恢复默认排序后使用IComparer<T>接口，对前面三项排序，按角度大小升序");
            route.Sort();
            route.Sort(, , VectorComparer.Default);
            foreach (Vector v in route)
            {
                Console.WriteLine(v.ToString());
            }

            Console.WriteLine("使用泛型委托Predicate<T>查找所有角度在0到90之间的向量");
            Predicate<Vector> searcher = new Predicate<Vector>(VectorDelegates.TopRightQuadrant);
            Vectors topRightQuadrant =new Vectors( route.FindAll(searcher));
            foreach (Vector v in topRightQuadrant)
            {
                Console.WriteLine(v.ToString());
            }

            route[].CompareTo(route[]);

            Console.ReadLine();
        }
    }

除了使用泛型接口IComparable<T>和IComparer<T>对泛型列表进行排序，上面的例子中还使用了泛型委托Comparison<T>对集合排序，它的定义如下

public delegate int Comparison<in T>(T x, T y);

它表示一个返回类型为int ，有两个T类型参数的委托，使用时要传入一个方法签名一样的方法

还可以使用泛型委托Predicate<in T>查找符合条件的项，它的定义如下

public delegate bool Predicate<in T>(T obj);

 3.3Dictionary<K,V>

使用Dictionary<k,v>可以创建类型为k，和V的键值对集合，实例化之后可以像继承自DictionaryBase的类那样执行相同的操作。添加到接口Dictionary<k,v>的键必须唯一，否则会抛出ArgumentException异常。一般情况下，如果K是简单类型，比如int，string会判断值是否相等，如果是引用类型（除string）会判断两个对象的引用是否相等。如果要改变判断的规则可以给构造函数传入一个IEqualityComparer<TKey> comparer接口对象，如下使用不区分大小写的方法比较字符串

Dictionary<string, int> things = new Dictionary<string, int>(StringComparer.CurrentCultureIgnoreCase);

对于自己的类，我们可以继承IEqualityComparer<T>接口改变判断规则，IEqualityComparer<T>有两个比较方法，一般情况下先使用int GetHashCode(T obj)方法判断，如果两个比较对象返回值是相等的，则进一步用bool Equals(T x, T y)方法判断两个对象是否相等。

    // 摘要:
    //     定义方法以支持对象的相等比较。
    //
    // 类型参数:
    //   T:
    //     要比较的对象的类型。
    public interface IEqualityComparer<in T>
    {
        // 摘要:
        //     确定指定的对象是否相等。
        //
        // 参数:
        //   x:
        //     要比较的第一个类型为 T 的对象。
        //
        //   y:
        //     要比较的第二个类型为 T 的对象。
        //
        // 返回结果:
        //     如果指定的对象相等，则为 true；否则为 false。
        bool Equals(T x, T y);
        //
        // 摘要:
        //     返回指定对象的哈希代码。
        //
        // 参数:
        //   obj:
        //     System.Object，将为其返回哈希代码。
        //
        // 返回结果:
        //     指定对象的哈希代码。
        //
        // 异常:
        //   System.ArgumentNullException:
        //     obj 的类型为引用类型，obj 为 null。
        int GetHashCode(T obj);
    }

只用int GetHashCode(T obj)判断的情况，如下例子中，我们创建两个同名的Animal对象，但是这两个对象属于不同的引用，obj.GetHashCode()返回的是不同的值，所以不管Equals方法怎么实现，程序都会认为cow和cow2是两个不同的对象。

    class Animal
    {
        protected string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public Animal()
        {
            name = "The animal has no name.";
        }

        public Animal(string newName)
        {
            name = newName;
        }

        public void Feed()
        {
            Console.WriteLine("{0}has been fed.", name);
        }

    }

    class AnimalComparer : IEqualityComparer<Animal>
    {
        public static AnimalComparer Default = new AnimalComparer();

        public bool Equals(Animal x, Animal y)
        {
            if (Comparer.Default.Compare(x.Name, y.Name) == )
                return true;
            else
                return false;

            //return x == y;
        }

        public int GetHashCode(Animal obj)
        {
            return obj.GetHashCode();
        }
    }

    class Program
    {

        static void Main(string[] args)
        {

            Dictionary<Animal, int> a = new Dictionary<Animal, int>(AnimalComparer.Default);
            Animal cow = new Cow("cow");
            Animal cow2 = new Cow("cow");

            a.Add(cow, );
            a.Add(cow2, );

            Console.ReadLine();
        }
    }

两个方法都使用的情况，我们把GetHashCode方法稍微改一下，同名的对象返回相同的值，此时调试发现，程序比较GetHashCode完方法之后又用Equals方法进行了比较，因为两次比较是相同的，所以添加cow2时程序报错

    class Animal
    {
        protected string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }

        public Animal()
        {
            name = "The animal has no name.";
        }

        public Animal(string newName)
        {
            name = newName;
        }

        public void Feed()
        {
            Console.WriteLine("{0}has been fed.", name);
        }

    }

    class AnimalComparer : IEqualityComparer<Animal>
    {
        public static AnimalComparer Default = new AnimalComparer();

        public bool Equals(Animal x, Animal y)
        {
            if (Comparer.Default.Compare(x.Name, y.Name) == )
                return true;
            else
                return false;

            //return x == y;
        }

        public int GetHashCode(Animal obj)
        {
            return obj.Name.GetHashCode();
        }
    }
        static void Main(string[] args)
        {

            Dictionary<Animal, int> a = new Dictionary<Animal, int>(AnimalComparer.Default);
            Animal cow = new Animal("cow");
            Animal cow2 = new Animal("cow");

            a.Add(cow, );
            a.Add(cow2, );

            Console.ReadLine();
        }

我们还可以给构造函数传递一个支持IDictionary<K,V>的集合，或者指定集合的大小Capacity，Dictionary<k,v>有以下构造函数，可以根据情况使用

可以使用集合的Keys和Values属性迭代集合中的键和值，也可以使用KeyValuePair<K,V>迭代集合中的每个项，使用Dictionary[K]访问对象某项的值

    class Program
    {

        static void Main(string[] args)
        {

            Dictionary<Animal, int> a = new Dictionary<Animal, int>();
            Animal cow = new Animal("cow");
            Animal cow2 = new Animal("cow");

            a.Add(cow, );
            a.Add(cow2, );

            foreach (Animal k in a.Keys)
            {
                Console.WriteLine(k.Name);
            }

            foreach (int v in a.Values)
            {
                Console.WriteLine(v);
            }

            foreach (KeyValuePair<Animal,int> d in a)
            {
                Console.WriteLine(d.Value);
            }

            int value = a[cow];
            Console.ReadLine();
        }
    }