​

​

using System;

using System.Collections;

using System.Collections.Generic;

using System.Threading;

using System.Linq;

​

//----------------------------------------------------------------------

// RwLock<T> read/write value lock.

//----------------------------------------------------------------------

public class RwLock<T> {

    // internal item

    public class Item {

        public T    Value { get; set; }

        public bool Done  { get; set; } 

    }

    private Item             item;

    private ManualResetEvent write;

    private ManualResetEvent read;

    public RwLock() {

        this.item        = null;

        this.write  = new ManualResetEvent(true);

        this.read   = new ManualResetEvent(false);

    }

    // called from sending thread.

    public void Send(T value) {

        this.write.WaitOne();

        this.write.Reset();

        this.item = new Item() { Value = value, Done = false };

        this.read.Set();

    }

​

    // called from sending thread. (at end of resolver)

    public void End() {

        this.write.WaitOne();

        this.write.Reset();

        this.item = new Item() { Value = default(T), Done = true };

        this.read.Set();

    }

​

    // called from caller thread.

    public Item Read() {

        this.read.WaitOne();

        this.read.Reset();

        var item = this.item;

        this.write.Set();

        return item;

    }

}

​

//----------------------------------------------------------------------

// Source<T>Gener- asynchronously generates streams of the given type.

//----------------------------------------------------------------------

public class Source<T> : IEnumerable<T> {

    private RwLock<T> rwlock;

    public Source(Action<RwLock<T>> resolver) {

        this.rwlock = new RwLock<T>();

        ThreadPool.QueueUserWorkItem(state => {

            resolver(rwlock);

            rwlock.End();

        }, null);

    }

​

    private IEnumerable<T> Read() {

        while (true) {

            var item = this.rwlock.Read();

            if (item.Done) break;

            yield return item.Value;

        }

    }

​

    public IEnumerator<T> GetEnumerator()   

        => this.Read().GetEnumerator();

​

    IEnumerator IEnumerable.GetEnumerator() 

        => this.Read().GetEnumerator();

​

}

​

//----------------------------------------------------------------------

// implementation

//----------------------------------------------------------------------

public class Program {

    static Source<int> Numbers()

            => new Source<int>(sender => {

                sender.Send(1);

                sender.Send(2);

                sender.Send(3);

                sender.Send(4);

        });

​

    public static void Main(string[] args) {

        var source = Numbers();

        foreach (var value in source) {

            Console.WriteLine(value);

        }

    }

}

​

​