以前是否发现过 C# 中 async / await 的这种用法？ [关闭]

Question

在 stackoverflow 上关于 async / await 的上一个问题之后，在我看来，await 比市场营销建议的更强大和更通用。它似乎是一种构建计算表达式的通用方法，就像在 F# 中一样。因此，经过一番挣扎，我想出了一些成功执行的代码，如下所示。

    using FluentAssertions;
    using System.Collections.Generic;

    namespace EnumerableViaAwait.Specs
    {
        [global::Microsoft.VisualStudio.TestTools.UnitTesting.TestClass]
        public class MyTestClass
        {
            public IEnumerable<int> Numbers()
            {
                return EnumeratorMonad.Build<int>(async Yield =>
                {
                    await Yield(11);
                    await Yield(22);
                    await Yield(33);
                });
            }

            [Microsoft.VisualStudio.TestTools.UnitTesting.TestMethod]
            public void TestEnum()
            {
                var v = Numbers();
                var e = v.GetEnumerator();

                int[] expected = { 11, 22, 33 };

                Numbers().Should().ContainInOrder(expected);

            }

        }
    }

现在仔细注意这里发生了什么。我不构建了一个反应性的 observable。我正在构建一个 IEnumerable。它严格来说是一个拉动系统。我可以很高兴地写。

    foreach item in Numbers(){
            Console.WriteLine(item);
    }

它会打印出来

    11
    22
    33

这很有趣，因为系统不是严格异步的，但我滥用了 await 框架和“等待任何东西”的能力，如此处所述。 http://blogs.msdn.com/b/pfxteam/archive/2011/01/13/10115642.aspx.The 问题是。

1. 这种对 await / async 的滥用能走多远？
2. 这种模式是否与 F# 计算表达式一样强大
3. 传统的 IEnumerator / Yield 模式只是评估的语法糖吗 完全符合这种模式

实现该模式的代码如下

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Runtime.CompilerServices;
    using System.Text;
    using System.Threading.Tasks;

    namespace EnumerableViaAwait
    {

        public class EnumeratorMonad<T> : IEnumerable<T>, IEnumerator<T>
        {
            public class Yield
            {
                private EnumeratorMonad<T> _Monad;

                public Yield(EnumeratorMonad<T> monad)
                {
                    _Monad = monad;
                }

                public YieldAwaiter GetAwaiter()
                {
                    return new YieldAwaiter(_Monad);
                }
            }

            public class YieldAwaiter : INotifyCompletion
            {
                EnumeratorMonad<T> _Monad;

                public YieldAwaiter(EnumeratorMonad<T> monad)
                {
                    _Monad = monad;
                }

                public bool IsCompleted
                {
                    get { return _Monad.IsCompleted(); }
                }

                public void GetResult()
                { }

                public void OnCompleted(Action continuation)
                {
                    _Monad.Next = continuation; 
                }

            }

            private bool Completed { get; set; }

            public EnumeratorMonad()
            {
                Completed = false;
            }

            public bool IsCompleted()
            {
                return Completed;
            }

            public void Build(Func<Func<T, Yield>, Task> action)
            {
                Func<T, Yield> yielder = (T value) => { 
                    _Current = value;
                    return new Yield(this);
                };
                Next = async () => { 
                    await action(yielder);
                    Completed = true;
                };
            }

            private T _Current;
            public T Current
            {
                get { return _Current; }
            }

            public void Dispose()
            {
            }

            object System.Collections.IEnumerator.Current
            {
                get { return _Current; }
            }


            Action Next;
            public bool MoveNext()
            {
                if (!Completed )
                {
                    Next();
                }
                return !Completed;
            }

            public void Reset()
            {
                throw new NotImplementedException();
            }



            IEnumerator<T> IEnumerable<T>.GetEnumerator()
            {
                return this;
            }

            System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
            {
                return this;
            }
        }

        public class EnumeratorMonad{
            public static EnumeratorMonad<T> Build<T>(Func<Func<T, EnumeratorMonad<T>.Yield>, Task> action)
            {
                var monad = new EnumeratorMonad<T>();
                monad.Build(action);
                return monad;
            }
        }

}

Answer 1

yield return 和 await/async 只是协程的不同特殊形式。你已经证明你可以（基本上）使用await/async 来实现yield return，我不会惊讶地发现反过来也可能。我确信它们的实现方式非常相似。

在实践中，当然，我不会使用await/async 进行迭代，因为yield return 更简单、更清晰。

所以，

1. 您可以尽情享受这种“虐待”。
2. 对 F# 不够熟悉，无法回答。
3. 不，但 IIRC 功能的实现方式或多或少相同。