精通C#--高级C#编程结构

集合与泛型

集合类：
–非泛型集合【System.Collections，System.Collections.Specialized】
–泛型集合【System.Collections.Generic】

非泛型集合

ArrayList
BitArray
Hashtable
Queue
SortedList
Stack

HybridDictionary
ListDictionary
StringCollection
BitVector32

相关接口：
ICollection 为所有非泛型集合类型定义基本特性
ICloneable 为实现它的对象，向调用者返回对象的副本
IDictionary 允许非泛型集合对象使用名称/值对来表示其内容
IEnumerable
IEnumerator
IList

2.非泛型集合一般针对的对象类型是System.Object

3.
装箱：把值类型数据保存在引用类型变量中。

static void SimpleBoxUnboxOperation()
{
    int myInt = 25;
    // 显式地将值类型分配给System.Object变量的过程
    // 对值类型进行装箱时，CLR会在堆上分配新的对象并且将值类型的值复制到那个实例上。因此，返回给我们的就是新分配在堆上的对象的引用。
    object boxedInt = myInt;
}

拆箱：把保存在对象引用中的值转换回栈上的相应值类型。

static void SimpleBoxUnboxOperation()
{
    int myInt = 25;
    object boxedInt = myInt;
    // CLR会验证收到的值类型是不是等价于装箱的类型。
    // 如果是，就将值复制回本地栈变量上。
    // 如果不是，将抛出InvalidCastException异常。
    int unboxedInt = (int)boxedInt;
}

在传递给需要object的方法时，值类型会自动装箱。

static void WorkWithArrayList()
{
    ArrayList myInts = new ArrayList();
    // 在传递给需要object的方法时，值类型会自动装箱
    myInts.Add(10);
    myInts.Add(20);
    myInts.Add(35);

    // 当将object转换回栈数据时，会发送拆箱
    int i = (int)myInts[0];
    Console.WriteLine("Value of your int:{0}", i);
}

装箱和拆箱时细节：
在托管堆上分配一个新对象
基于栈数据的值必须被转移到新分配的内存位置
在拆箱时，保存在堆对象中的值必须转移回栈
堆上无用的对象【最后】会被回收

泛型集合

1.
与非泛型容器相比，泛型容器的一些优势
提供了更好的性能，因为没有装箱和拆箱过程
更类型安全，因为只包含我们指定的类型
大幅减少了构建自定义集合类型的需要

2.只有类，结构，接口，委托可以使用泛型，枚举类型不可以。
泛型的类型参数的名称可以随意取。但通常，T表示类型，TKey或K表示键，TValue或V表示值。

3.非泛型接口指定类型参数

// 非泛型版本
public interface IComparable
{
    int CompareTo(object obj);
}

// 泛型版本
public interface IComparable
{
    int CompareTo(T obj);
}

public class Car : IComparable
{
    ...
    // IComparable的实现
    int IComparable.CompareTo(Car obj)
    {
        if(this.CarID > obj.CarID)
            return 1;
        if(this.CarID < obj.CarID)
            return -1;
        else
            return 0;
    }
}

4.System.Collections.Generic

// 泛型接口
ICollection<T>
ICompare<T>
IDictionary<TKey, TValue>
IEnumerable<T>
IEnumerator<T>
IList<T>
ISet<T>

// 泛型类
Dictionary<TKey, TValue>
LinkedList<T>
List<T>
Queue<T>
SortedDictionary<TKey, TValue>
SortedSet<T>
Stack<T>
HashSet<T>

5.
对象初始化语法。
集合初始化语法：
只能对支持Add()方法的类使用集合初始化语法。

// 初始化标准数组
int[] myArrayOfInts = {0, 1, 2, 3};
// 初始化int的泛型List<>
List myGenericList = new List{0, 1, 2, 3};
// 用数字数据初始化ArrayList
ArrayList myList = new ArrayList{0, 1, 2, 3};

// 综合使用对象初始化和集合初始化
List<Point> myListOfPoints = new List<Point>
{
    new Point{X=2, Y=2},
    new Point{X=3, Y=3},
    new Point(PointColor.BloodRed){X=4, Y=4}
};

6.System.Collections.ObjectModel

ObservableCollection     添加，移除项或刷新整个列表时提供通知的动态数据集合
ReadOnlyObservableCollection


// ObservableCollection实现了与List相同的核心接口。不同的是，ObservableCollection实现了一个名为CollectionChanged的事件。该事件将在插入新项，移除当前项或修改整个集合时触发。
// CollectionChanged定义为委托【这里为NotifyCollectionChangedEventHandler】
// 该委托可以调用任何以object为第一个参数，以NotifyCollectionChangedEventArgs为第二个参数的方法
class Program
{
    static void Main()
    {
        ObservableCollection people = new ObservableCollection()
        {
            new Person{FirstName="Peter", LastName="Murphy", Age=52},
            new Person{FirstName="Kevin", LastName="Key", Age=48},
        };

        people.CollectionChanged += people_CollectionChanged;
    }

    static void people_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
    {
        Console.WriteLine("Action for this event:{0}", e.Action);
        if(e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Remove)
        {
            Console.WriteLine("Here are the OLD items:");
            foreach (Person p in e.OldItems)
            {
                Console.WriteLine(p.ToString());
            }

            Console.WriteLine();
        }

        if(e.Action == System.Collections.Specialized.NotifyCollectionChangedAction.Add)
        {
            Console.WriteLine("Here are the NEW items:");
            foreach(Person p in e.NewItems)
            {
                Console.WriteLine(p.ToString());
            }
        }
    }
} 

7.自定义泛型方法

static void Swap(ref T a, ref T b)
{
    Console.WriteLine("You sent the Swap() method a {0}", typeof(T));
    T temp;
    temp = a;
    a = b;
    b = temp;
}

static void Main()
{
    Console.WriteLine("******Fun with custom Generic Methods ******\n");
    int a = 10, b = 90;
    Console.WriteLine("Before swap:{0}, {1}", a, b);
    Swap<int>(ref a, ref b);
    Console.WriteLine("After swap:{0}, {1}", a, b);
    Console.WriteLine();

    string s1 = "Hello", s2 = "There";
    Console.WriteLine("Before swap:{0} {1}", s1, s2);
    Swap<string>(ref s1, ref s2);
    Console.WriteLine("After swap:{0} {1}", s1, s2);
    Console.ReadLine();
}

当使用泛型时，不指定类型参数时，编译器会基于成员参数推断类型参数。
类型参数推断只在泛型方法至少有一个参数时起作用。

8.自定义泛型结构和类

public struct Point
{
    private T xPos;
    private T yPos;
    public Point(T xVal, T yVal)
    {
        xPos = xVal;
        yPos = yVal;
    }

    public T X
    {
        get{return xPos;}
        set{xPos = value;}
    }

    public T Y
    {
        get{return xPos;}
        set{xPos = value;}
    }

    public override string ToString()
    {
        return string.Format("[{0},{1}]", xPos, yPos);
    }

    public void ResetPoint()
    {
        // default(类型参数) 返回一个类型参数的默认值
        xPos = default(T);
        yPos = default(T);
    }
}

9.类型参数的约束
任何泛型项须至少有一个类型参数，并在与泛型类型或参数交互时指定该类型参数。
使用where可以对给定的类型参数添加一组约束。
where T : ???
???：
struct 类型参数T须在其继承链中包含System.ValueType值类型。
class 类型参数T不能在其继承链中包含System.ValueType值类型。
new() 类型参数T须包含一个默认的构造函数。【在有多个约束的类型上，此约束须列在末尾】
NameOfBaseClass 类型参数T须派生于NameOfBaseClass指定的类
NameOfInterface 类型参数T须实现NameOfInterface指定的接口

// 类型参数T为引用类型，且实现了IDrawable，且具备默认构造
// 要为多个类型参数指定多个约束集时，用多个where语句
// where也可以用在限制泛型方法中的类型参数
public class MyGenericClass where T : class, IDrawable, new()
{
    ...
}

目前版本不支持对泛型的类型参数应用C#操作符