若是人人读过dapper源码,你会发现这内部有许多方式都用到了yield关键词,那yield到底是用来干嘛的,能不能拿掉,拿掉与不拿掉有多大的差异,首先上一段dapper中精简后的Query方式,先让人人眼见为实。

   private static IEnumerable<T> QueryImpl<T>(this IDbConnection cnn, CoMMAndDefinition command, Type effectiveType)
    {
        object param = command.Parameters;
        VAR identity = new Identity(command.CommandText, command.CommandType, cnn, effectiveType, param?.GetType());
        var info = GetCacheInfo(identity, param, command.AddToCache);

        IDbCommand cmd = null;
        IDataReader reader = null;

        bool wasClosed = cnn.State == ConnectionState.Closed;
        try
        {
            while (reader.Read())
            {
                object val = func(reader);
                if (val == null || val is T)
                {
                    yield return (T)val;
                }
                else
                {
                    yield return (T)Convert.ChangeType(val, convertToType, CultureInfo.InvariantCulture);
                }
            }
        }
    }

一:yield探讨

1. 骨架代码料想

骨架代码实在很简朴,方式的返回值是IEnumerable,然后return被yield开了光,让人疑心的地方就是既然方式的返回值是IEnumerable却在方式体内没有看到任何实现这个接口的子类,以是第一感受就是这个yield不简朴,既然代码可以跑,那底层一定帮你实现了一个继续IEnumerable接口的子类,你说对吧?

2. msdn注释

有自己的料想还不行,还得信赖权威,看msdn的注释:https://docs.Microsoft.com/zh-cn/dotnet/csharp/language-reference/keywords/yield

若是你在语句中使用 yield 上下文关键字,则意味着它在其中泛起的方式、运算符或 get 接见器是迭代器。通过使用 yield 界说迭代器,可在实现自界说聚集类型的 IEnumerator 和 IEnumerable 模式时无需其他显式类(保留枚举状态的类,有关示例,请参阅 IEnumerator)。

没用过yield之前,看这句话一定是一头雾水,只有在营业开发中踩过坑,才气体会到yield所带来的快感。

3. 从IL入手

为了利便探讨原理,我来写一个不能再简朴的例子。

    public static void Main(string[] args)
    {
        var list = GetList(new int[] { 1, 2, 3, 4, 5 });
    }

    public static IEnumerable<int> GetList(int[] nums)
    {
        foreach (var num in nums)
        {
            yield return num;
        }
    }

对,就是这么简朴,接下来用ILSpy反编译打开这其中的神秘面纱。

从截图中看最让人好奇的有两点。

<1 style="box-sIZing: border-box;"> 无缘无故的多了一个叫做\d__1 类

好奇心驱使着我看一下这个类到底都有些什么?由于IL代码太多,我做一下精简,从下面的IL代码中可以发现,果然是实现了IEnumerable接口,若是你领会设计模式中的迭代器模式,那这里的MoveNext,Current是不是异常熟悉?

.class nested private auto ansi sealed beforefieldinit '<GetList>d__1'
    extends [mscorlib]System.Object
    implements class [mscorlib]System.Collections.Generic.IEnumerable`1<int32>,
               [mscorlib]System.Collections.IEnumerable,
               class [mscorlib]System.Collections.Generic.IEnumerator`1<int32>,
               [mscorlib]System.IDisposable,
               [mscorlib]System.Collections.IEnumerator
{
    .method private final hidebysig Newslot virtual
        instance bool MoveNext () cil managed
    {
        ...
    } // end of method '<GetList>d__1'::MoveNext

    .method private final hidebysig specialname NEWSlot virtual
        instance int32 'System.Collections.Generic.IEnumerator<System.Int32>.get_Current' () cil managed
    {
        ...
    } // end of method '<GetList>d__1'::'System.Collections.Generic.IEnumerator<System.Int32>.get_Current'

    .method private final hidebysig specialname newslot virtual
        instance object System.Collections.IEnumerator.get_Current () cil managed
    {
        ...
    } // end of method '<GetList>d__1'::System.Collections.IEnumerator.get_Current

    .method private final hidebysig newslot virtual
        instance class [mscorlib]System.Collections.Generic.IEnumerator`1<int32> 'System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator' () cil managed
    {
        ...
    } // end of method '<GetList>d__1'::'System.Collections.Generic.IEnumerable<System.Int32>.GetEnumerator'

} // end of class <GetList>d__1

<2 style="box-sizing: border-box;"> GetList方式体现在会酿成啥样?

.method public hidebysig static
    class [mscorlib]System.Collections.Generic.IEnumerable`1<int32> GetList (
        int32[] nums
    ) cil managed
{
    // (no C# code)
    IL_0000: lDC.i4.s -2
    IL_0002: newobj instance void ConsoleApp2.Program/'<GetList>d__1'::.ctor(int32)
    IL_0007: dup
    IL_0008: ldarg.0
    IL_0009: stfld int32[] ConsoleApp2.Program/'<GetList>d__1'::'<>3__nums'
    IL_000e: ret
} // end of method Program::GetList

可以看到这地方做了一个new ConsoleApp2.Program/'d1'操作,然后举行了<>3nums=0,最后再把这个迭代类返回出来,这就注释了为什么你的GetList可以是IEnumerable而不报错。

,

皇冠APP下载

:www.huangguan.us是一个提供皇冠代理APP下载、皇冠会员APP下载、皇冠体育最新登录线路、新2皇冠网址的的体育平台。新皇冠体育官网是多年来值得广大客户信赖的平台,我们期待您的到来!

,

4. 打回C#代码

你可能会说,你说了这么多有啥用?IL代码我也看不懂,若是能回写成C#代码那就了,还好回写成C#代码不算太难。。。

namespace ConsoleApp2
{
    class GetListEnumerable : IEnumerable<int>, IEnumerator<int>
    {
        private int state;
        private int current;
        private int threadID;
        public int[] nums;
        public int[] s1_nums;
        public int s2;
        public int num53;

        public GetListEnumerable(int state)
        {
            this.state = state;
            this.threadID = Environment.CurrentManagedThreadId;
        }
        public int Current => current;

        public IEnumerator<int> GetEnumerator()
        {
            GetListEnumerable rangeEnumerable;

            if (state == -2 && threadID == Environment.CurrentManagedThreadId)
            {
                state = 0;
                rangeEnumerable = this;
            }
            else
            {
                rangeEnumerable = new GetListEnumerable(0);
            }

            rangeEnumerable.nums = nums;
            return rangeEnumerable;
        }

        public bool MoveNext()
        {
            switch (state)
            {
                case 0:

                    state = -1;
                    s1_nums = nums;
                    s2 = 0;
                    num53 = s1_nums[s2];
                    current = num53;
                    state = 1;
                    return true;
                case 1:
                    state = -1;
                    s2++;

                    if (s2 < s1_nums.Length)
                    {
                        num53 = s1_nums[s2];
                        current = num53;
                        state = 1;
                        return true;
                    }

                    s1_nums = null;
                    return false;
            }
            return false;
        }
        object IEnumerator.Current => Current;
        public void Dispose() { }
        public void Reset() { }
        IEnumerator IEnumerable.GetEnumerator() { return this.GetEnumerator(); }
    }
}

接下来GetList就可以是另一种写法了,做一个new GetListEnumerable 即可。

到目前为止,我以为这个yield你应该彻底的懂了,否则就是我的失败(┬_┬)...

二:yield到底有什么利益

以我自己几年开发履历(不想把自己说的太老(┬_┬))来看,有如下两点利益。

1. 现阶段还不清晰用什么聚集来承载这些数据

这话什么意思?同样的一堆聚集数据,你可以用List承载,你也可以用SortList,HashSet甚至还可以用Dictionary承载,对吧,你那时界说方式的时刻返回值那里是一定要先界说好吸收聚集,但这个吸收聚集真的合适吗?你那时也是不知道的。若是你还不明了,我举个例子:

    public static class Program
    {
        public static void Main(string[] args)
        {
            //哈哈,我最后想要HashSet。。。由于我要做高效的聚集去重
            var hashSet1 = new HashSet<int>(GetList(new int[] { 1, 2, 3, 4, 5 }));
            var hashSet2 = new HashSet<int>(GetList2(new int[] { 1, 2, 3, 4, 5 }));
        }

        //编码阶段就预先决议了用List<int>承载
        public static List<int> GetList(int[] nums)
        {
            return nums.Where(num => num % 2 == 0).ToList();
        }

        //编码阶段还没想好用什么聚集承载,有可能是HashSet,SortList,鬼知道呢?
        public static IEnumerable<int> GetList2(int[] nums)
        {
            foreach (var num in nums)
            {
                if (num % 2 == 0) yield return num;
            }
        }
    }

先看代码中的注释,从上面例子中可以看到我真正想要的是HashSet,而此时hashSet2 比 hashSet1 少了一个中转历程,无形中这就大大提高了代码性能,对不对?

  • hashSet1 实在是 int[] -> List -> HashSet 的历程。
  • hashSet2 实在是 int[] -> HashSet 的历程。

2. 可以让我无限制的叠加筛选塑形条件

这个又是什么意思呢?有时刻方式挪用栈是稀奇深的,你无法对一个聚集在最底层举行整体一次性筛选,而是在每个方式中执行追加式筛选塑性,请看如下示例代码。

public static class Program
{
    public static void Main(string[] args)
    {
        var nums = M1(true).ToList();
    }

    public static IEnumerable<int> M1(bool desc)
    {
        return desc ? M2(2).OrderByDescending(m => m) : M2(2).OrderBy(m => m);
    }

    public static IEnumerable<int> M2(int mod)
    {
        return M3(0, 10).Where(m => m % mod == 0);
    }

    public static IEnumerable<int> M3(int start, int end)
    {
        var nums = new int[] { 1, 2, 3, 4, 5 };
        return nums.Where(i => i > start && i < end);
    }
}

上面的M1,M2,M3方式就是实现了这么一种操作,最后使用ToList一次性输出,由于没有中间商,以是灵活性和性能可想而知。

三:总结

函数式编程将会是以后的主流偏向,C#中险些所有的新特征都是为了给函数式编程提供便利性,而这个yield就是C#函数式编程中的一个基柱,你还可以补看Enumerable中的种种扩展方式增添一下我的说法可信度。

 static IEnumerable<TSource> TakeWhileIterator<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate) {
            foreach (TSource element in source) {
                if (!predicate(element)) break;
                yield return element;
            }
        }

static IEnumerable<TSource> WhereIterator<TSource>(IEnumerable<TSource> source, Func<TSource, int, bool> predicate) {
            int index = -1;
            foreach (TSource element in source) {
                checked { index++; }
                if (predicate(element, index)) yield return element;
            }
        }

好了,本篇就说到这里,希望对你有辅助。