《C#高级教程》学习笔记7

第七，八，九，十天
（最近几天因为课程设计原因耽误了C#学习进程，刚花了大量精力干掉课程设计，然后又花了挺多时间玩游戏看漫画来恢复精力，正当准备努力学习的时候，同学却来找我一起挑战做手机游戏来参加比赛，然后关于游戏类型与主题讨论了很长时间，于是学习便呵呵掉了，之后还要花时间去研究安卓，真是作死的节奏了）

CreateInstance()方法还有很多重载版本，可创建多维数组及不基于0的数组
int[] length={2,3};
int[] lowerBounds={1,10};
Array racers=Array.CreateInstance(typeof(Person),length,lowerBounds);
racers.SetValue(new Person{
    FirstName="A";
    SecondName="B";
},1,10);

6.5.2复制数组
数组是引用类型，直接赋值只是两个引用而且。
复制数组，会使数组实现ICloneable接口。这个接口定义的Clone()方法会创建数组的浅表副本。
int[] intArray1={1,2};
int[] intArray2=(int[])intArray1.Clone();
数组里有引用无素，则只复制引用，不复制元素
还可以使用Array.Copy()方法创建浅表副本。与Clone()方法的区别：Clone()会创建一个新数组，Copy()方法必须传递阶数相同用有足够元素的已有数组。

6.5.3排序
Array类使用QuickSort算法对数组中的元素进行排序。
Sort()方法需要数组中的元素实现IComparable接口。
对数组使用自定义类，则该类必须实现IComparable接口，此接口里只定义了一个方法CompareTo()，方法返回0。该实例对象应排在参数对象的前面则返回小于0的值，
相反则大于0
不能修改在数组中用作元素的类，就可以实现IComparer接口或IComparer<T>接口。这两个接口定义了方法Compare()。
IComparer接口独立于要比较的类。
Array.sort()时，第一个参为数组，第二个为new的比较器

6.6数组作为参数
public void A(Person[] person){}
public Person[] B(){}

6.6.1数组协变
数组支持协变，这表示数组可以声明为基类，其派生类型的元素可以赋予数组元素。
static void DisplayArray(object[] data){}

6.6.2 ArraySegment<T>
结构ArraySegment<T>表示数组的一段。把数组部分复制到方法去。
传参时：
(ArraySegment<int>[] segments)
之类
用例：
int[] ar1={1,4,5,11,13,18};
int[] ar2={3,4,5,18,21,27,33};
var segments = new ArraySegment<int>(2){
    new ArraySegment<int>(ar1,0,3),
    new ArraySegment<int>(ar2,3,3)
}

6.7枚举
foreach,可以迭代集合中的元素，且无需知道集合中的元素个数。
数组或集合实现带GetEnumerator()方法的IEnumerable接口。
GetEnumerator()方法返回一个实现IEnumerable接口的枚举。
接着，foreach语句就可以使用IEnumerable接口迭代集合。

6.7.1 IEnumerator接口
foreach语句作用IEnumerator接口的方法和属性，迭代集合中的所有元素。
为此IEnumerator定义了Current属性来返回光标所在的元素，
该接口的MoveNext()方法，移动到集合的下一个元素上，如果有这个元素就返加true,否则false。
IEnumerator<T>派生自接口IDisposable，因此定义了Dispose()方法来清理枚学会举器占用的资源。

6.7.2 foreach语句
C#的foreach语句不会解析为IL代码中的foreach语句。
foreach(var p in persons){
    Console.WriteLine(p);
}
解析：
IEnumerator<Person> enumerator=persons.GetEnumerator();
while(enumerator.MoveNext()){
    Person p=enumerator.Current();
    Console.WriteLine(p);
}

6.7.3 yield语句
yield语句返回集合的一个元素，并移动到下一个元素，yield break可停止迭代。
例：
using System;
using System.Collections;
namespace Wrox.ProCShape.Arrays{
    public class HelloCollection{
        public IEnumerator<String> GetEnumerator(){
            yield return "Hello";
            yield return "World";
        }
    }
}
然后用foreach迭代语句
使用迭代块，编译器会生成一个yield类型，其中包含一个状态机，如下面的代码段所示。
public class HelloCollection{
    public IEnumerator GetEnumerator(){
        return new Enumerator(0);
    }
}
public class Enumerator:IEnumerator<string>,IEnumerator,IDisposable{
    private int state;
    private string current;
    public Enumerator(int state){
        this.state=state;
    }
    bool System.Collections.IEnumerator.MoveNext(){
        switch(state){
        case 0:
            current="Hello";
            state=1;
            return true;
        case 1:
            current="World";
            state=2;
            return true;
        }
        return false;
    }
    void System.Collections.IEnumerator.Reset(){
        throw new NotSupportedException();
    }
    string System.Collections.Generic.IEnumerator<string>.Current{
        get{
            return current;
        }
    }
    object System.Collections.IEnumerator.Current{
        get{
            return current;
        }
    }
    void IDisposable.Dispose(){}
}
1.迭代集合的不同方式
例：
public class MusicTitles{
    string[] names={"A","B","C","D"};
    public IEnumerator<string> GetEnumerator(){
        for(int i=0;i<4;i++){
            yeild return name[i];
        }
    }
    public IEnumerable<string> Reverse(){
        for(int i=3;i>=0;i--){
            yeild return name[i];
        }
    }
    public IEnumerable<string> Subset(int index,int length){
        for(int i=index;i<index+length;i++){
            yield return name[i];
        }
    }
}
用：
var titles=new MusicTitles();
foreach(var title in titles){
    Console.WriteLine(title);
}
Console.WriteLine("reverse");
foreach(var title in titles.Reverse()){
    Console.WriteLine(title);
}
Console.WriteLine("subset");
foreach(var title in titles.Subset(2,2)){
    Console.WriteLine(title);
}

2.用yield return返回枚举器
public class GameMove{
    private IEnumerator cross;
    private IEnumerator circle;
    private GameMove{
        cross=Cross();
        circle=Circle();
    }
    private int move=0;
    private int MaxMoves=0;
    public IEnumerator Cross(){
        while(true){
            Console.WriteLine("Cross,move{0}",move);
            if(++move>=MaxMoves)
                yield break;
            yield return circle;
        }
    }
    public IEnumerator Circle(){
        while(true){
            Console.WriteLine("Circle,move{0}",move);
            if(++move>=MaxMoves)
                 yield break;
             yield return cross;
        }
    }
}

var game=new GameMove();
IEnumerator enumerator=game.Cross();
while(enumerator.MoveNext()){
    enumerator=enumerator.Current as IEnumerator;
}
输出:
Cross,move 0
Cicle,move 1
Cross,move 2
Cicle,move 3
Cross,move 4
Cicle,move 5
Cross,move 6
Cicle,move 7
Cross,move 8

6.8元组
数组合并了相同类型的对象，而元组合并了不同类型的对象。
在.NET Framework中，元组可用于所有的.NET语言。
.NET Framework定义了8个泛型Tuple类(自.NET4.0以来)和一个静态Tuple类。
不同泛型Tuple类支持不同数量的元素。如Tuple<T1>包含一个元素，Tuple<T1,T2>包含两个元素，以此类推。
例:
public static Tuple<int,int> Divide(int dividend,int divisor){
    int result=dividend/divisor;
    int reminder=dividend%divisor;
    return Tuple.Create<int,int>(result,reminder);
}
调用：
var result=Divide(5,2);
Console.WriteLine("{0},{1}",result.Item1,result.Item2);
如果元组包含的项超过8个，就可以使用带8个参数的Tuple类定义。最后一个传元组。
public class Tuple<T1,T2,T3,T4,T5,T6,T7,TRest>

(2014.12.12 158页，还有1517-158=1359)