C#基礎之yield與Singleton

1.實例解析yiled的作用

最近參加java筆試題第一次見到yield這個關鍵字，既然遇見了那肯定要掌握，下面是C#中關於yield關鍵字的總結。 yield這個關鍵字作用於迭代器區塊中，其最本質的功能有2個：一是「依序」向枚舉物件提供值，二是發出迭代結束訊號。這兩個函數對應的語句分別是yield return和yield break。

下面有2個小例子，分別沒有使用yield和有使用yield。先來看第一個，當我調試時顯然執行到GetResult()方法時將會跳到方法內部並且執行完，接著再去執行輸出當前值語句。從結果可以看出第一個是0，說明傳回的枚舉數所在的位置在集合中是0，接著才是我想要的遍歷數據，也就是說只有呼叫MoveNext()後枚舉數才會繼續向前移動得到下一個值，但是此時資料已全部載入到記憶體。

再來看第二個例子，當我調試到GetResultByYield()方法時我想進入到這個方法內部結果發現直接執行下一句，根本就沒有進入到GetResultByYield()方法內部。此時發現result.Current是null，再加上前面根本都沒執行方法內部的程式碼，因此我猜測此時集合都是空的。繼續調試，當執行MoveNext()方法時才去執行GetResultByYield()，接著執行到yield return隨即返回main()方法輸出枚舉數所代表的集合中的值。

從上面可以看到只有呼叫MoveNext()需要用的時候才去執行方法來獲得結果，不用的時候並不會有任何結果。這個地方編譯器會有一個狀態機用來保存迭代器的狀態，以確保for迴圈時是從上一次yield return停止的狀態繼續執行。這個過程就好比小方要喝一公升的水，如果它用一個一公升的杯子喝那麼他要準備一個一公升的容器去飲水機裝滿一公升的水。

如果小方喝到一半喝不完了，那接下來剩下的水則將被回收，這樣無論能不能喝完都必須準備好一公升的水，就像第一個例子。現在讓杯子的容積縮小為0.2公升，小方喝完一杯再去飲水機去打水，每次只喝0.2公升。這樣只有他要去喝的時候才去打水，如果他喝到一半不想喝了顯然浪費的水比第一種方式多，這就像第二個例子。最後根據條件不再需要資料便可呼叫yield return來跳出while循環，如果不寫yield break仍然可以正常結束迭代。

///
    /// 不使用yield的时候
    ///
    class Program
    {
        static void Main(string[] args)
        {
            //得到一个迭代结果
            var result = GetResult();
            //输出当前的值
            Console.WriteLine(result.Current);
            Console.WriteLine("开始遍历");
            while (result.MoveNext())
            {
                Console.WriteLine(result.Current);
            }
            Console.WriteLine("遍历结束");
            Console.ReadLine();
        }
        //不使用yield来进行迭代
        static IEnumeratorint> GetResult()
        {
            var arr = new int[] { 1, 6, 8, 12,15};
            Listint> list = new Listint>();
            foreach (int item in arr)
            {
                if (item 12)
                    list.Add(item);
            }
            return list.GetEnumerator();
        }
 
    }

///
    /// 使用yield关键字
    ///
    class Program
    {
        static void Main(string[] args)
        {
            //得到一个迭代结果
            var result = GetResultByYield();
            //输出当前的值
            Console.WriteLine(result.Current);
            Console.WriteLine("开始遍历");
            while (result.MoveNext())
            {
                Console.WriteLine(result.Current);
            }
            Console.WriteLine("遍历结束");
            Console.ReadLine();  
        }
        //使用yield来进行迭代
        static IEnumerator GetResultByYield()
        {
            var arr = new int[] { 1,6,8,12,15};
            foreach (var item in arr)
            {
                yield return item;
                if (item == 12)
                    yield break;
            }
        }
 
    }

輸出結果如下：

2.深入yield

將上面第二個例子放入Reflector工具中，便得到了下面三段程式碼。第一段是完整的Pragrom類別的C#程式碼，第二段是d__0密封類別的C#展開程式碼，第三段是GetResultByYield()方法的IL程式碼。在第一段程式碼中可以看到系統自動產生了一個d__0密封類，它裡面​​聲明了一些名字很奇怪的字段，不過我們可以很清楚的看到這個類裡面有最重要的MoveNext()方法和Current屬性。

第二段程式碼則是這個密封類別的C#展開程式碼，到這裡不知道讀者有沒有跟我當初一樣的疑問：為什麼要自動產生一個密封類別呢？答案就在第三段程式碼中，可以看到在GetResultByYield()方法中並沒有遍歷數組，甚至沒有看到創建數組的newarr指令，而是newobj創建了d__0密封類別的實例物件。這也正是前面調試的時候為什麼根本就沒進去GetResultByYield()方法的原因，因為真真的實作程式碼是在密封類別裡面的MoveNext()方法中。前面也提到yield是按需所取，因此需要一個狀態機來記錄每次yield return的狀態。

在MoveNext()方法中由于密封类构造函数传进去的是一个0(在第三段代码中可以看到)，因此第一次进入到MoveNext方法时this.__state=0。此时current字段由于没赋值因此就是null了。接着创建数组并开始一个while循环(原来foreach就是while循环)，在循环中给current字段赋值并让state字段值为2，最后返回true。拿Current属性时就是拿while循环中给current赋的值，再次进入这个方法内此时state等于2于是跳转到Label_0090，也就是进入while语句块中继续循环，这就是按需所取的原理。当遇到yield break后会先执行Dispose释放资源，再执行break语句跳出循环。可以看到上述这个过程就是一个状态机，而这个密封类是为建立一个状态机来生成的，现在我们自己也可以写出一个状态机了。

internal class Program
{
    // Methods
    public Program();
    private static IEnumerator GetResultByYield();
    private static void Main(string[] args);
 
    // Nested Types
    [CompilerGenerated]
    private sealed class d__0 : IEnumeratorobject>, IEnumerator, IDisposable
    {
        // Fields
        private int 1__state;
        private object 2__current;
        public int[] 7__wrap4;
        public int 7__wrap5;
        public int[] 5__1;
        public int 5__2;
 
        // Methods
        [DebuggerHidden]
        public d__0(int 1__state);
        private void m__Finally3();
        private bool MoveNext();
        [DebuggerHidden]
        void IEnumerator.Reset();
        void IDisposable.Dispose();
 
        // Properties
        object IEnumeratorobject>.Current { [DebuggerHidden] get; }
        object IEnumerator.Current { [DebuggerHidden] get; }
    }
}

private sealed class d__0 : IEnumeratorobject>, IEnumerator, IDisposable
{
    // Fields
    private int 1__state;
    private object 2__current;
    public int[] 7__wrap4;
    public int 7__wrap5;
    public int[] 5__1;
    public int 5__2;
 
    // Methods
    [DebuggerHidden]
    public d__0(int 1__state)
    {
        this.1__state = 1__state;
    }
 
    private void m__Finally3()
    {
        this.1__state = -1;
    }
 
    private bool MoveNext()
    {
        try
        {
            switch (this.1__state)
            {
                case 0:
                    this.1__state = -1;
                    this.5__1 = new int[] { 1, 6, 8, 12, 15 };
                    this.1__state = 1;
                    this.7__wrap4 = this.5__1;
                    this.7__wrap5 = 0;
                    while (this.7__wrap5 this.7__wrap4.Length)
                    {
                        this.5__2 = this.7__wrap4[this.7__wrap5];
                        this.2__current = this.5__2;
                        this.1__state = 2;
                        return true;
                    Label_0090:
                        this.1__state = 1;
                        if (this.5__2 == 12)
                        {
                            this.System.IDisposable.Dispose();
                            break;
                        }
                        this.7__wrap5++;
                    }
                    this.m__Finally3();
                    break;
 
                case 2:
                    goto Label_0090;
            }
            return false;
        }
        fault
        {
            this.System.IDisposable.Dispose();
        }
    }
 
    [DebuggerHidden]
    void IEnumerator.Reset()
    {
        throw new NotSupportedException();
    }
 
    void IDisposable.Dispose()
    {
        switch (this.1__state)
        {
            case 1:
            case 2:
                this.m__Finally3();
                break;
        }
    }
 
    // Properties
    object IEnumeratorobject>.Current
    {
        [DebuggerHidden]
        get
        {
            return this.2__current;
        }
    }
 
    object IEnumerator.Current
    {
        [DebuggerHidden]
        get
        {
            return this.2__current;
        }
    }
}

 .method private hidebysig static class [mscorlib]System.Collections.IEnumerator GetResultByYield() cil managed
    {
        .maxstack 1
        .locals init (
            [0] class ConsoleApplication1.Program/d__0 d__,
            [1] class [mscorlib]System.Collections.IEnumerator enumerator)
        L_0000: ldc.i4.0
        L_0001: newobj instance void ConsoleApplication1.Program/d__0::.ctor(int32)
        L_0006: stloc.0
        L_0007: ldloc.0
        L_0008: stloc.1
        L_0009: br.s L_000b
        L_000b: ldloc.1
        L_000c: ret
    }

3.单例模式

单例模式没什么好说的，当然如果深挖应该也是大有学问，其中我觉得比较好的一种写法如下。单例模式的代码我看过多次不过却没怎么写，结果真真写的时候再加上时间又有点紧最后写的一塌糊涂。以后写代码要兴平气和地去写，急躁的状态写不出什么好代码。当然总会有烦躁的时候，所以只能多写代码来让自己写出高质量的代码成为一种习惯！

class A
    {
        private static A instance = new A();
        public static A Instance
        {
            get { return A.instance; }
        }
    }

以上就是C#基础之yield与Singleton的内容，更多相关内容请关注PHP中文网（www.php.cn）！