以无特定顺序将两个无限 C# IEnumerables 连接在一起

Question

I have two methods that each return infinite IEnumerable that never ends. I want to concatenate them so whenever any of the IEnumerable s return a value, I can instantly get and process it.

        static void Main(string[] args)
        {
            var streamOfBoth = get1().Concat(get2());
            foreach(var item in streamOfBoth)
            {
                Console.WriteLine(item);
               // I'd expect mixed numbers 1 and 2
               // Instead I receive only 1s
            }
         }

        static IEnumerable<int> get1()
        {
            while (true)
            {
                System.Threading.Thread.Sleep(1000);
                yield return 1;
            }
        }

        static IEnumerable<int> get2()
        {
            while (true)
            {
                System.Threading.Thread.Sleep(200);
                yield return 2;
            }
        }

Is there a way to do this with IEnumerables without having to use threads?

Answer 1

This is fairly easily achieved with System.Reactive

static void Main()
{
    get1().ToObservable(TaskPoolScheduler.Default).Subscribe(Print);
    get2().ToObservable(TaskPoolScheduler.Default).Subscribe(Print);
}

static void Print(int i)
{
    Console.WriteLine(i);
}

static IEnumerable<int> get1()
{
    while (true)
    {
        System.Threading.Thread.Sleep(1000);
        yield return 1;
    }
}

static IEnumerable<int> get2()
{
    while (true)
    {
        System.Threading.Thread.Sleep(200);
        yield return 2;
    }
}

This produces the following output on my machine:

2 2 2 2 1 2 2 2 2 2 1 2 2 2 2 2 1 2 2 2 2 2 1 2 2 2 2 2 1 2 2 2 2 2 1 ...

Note that ToObservable is called with the argument TaskPoolScheduler.Default ; just calling ToObservable without it will result in synchronous execution, meaning it will keep enumerating the first sequence forever and never get to the second one.

Answer 2

You may want to interleave get1 and get2 (take item from get1 , then from get2 , then again from get1 and then from get2 etc.). Generalized ( IEnumerable<T> are not necessary infinite and of the same size) Interleave<T> extension method can be like this:

   public static partial class EnumerableExtensions {
     public static IEnumerable<T> Interleave<T>(this IEnumerable<T> source, 
                                                params IEnumerable<T>[] others) {
      if (null == source)
        throw new ArgumentNullException(nameof(source));
      else if (null == others)
        throw new ArgumentNullException(nameof(others));

      IEnumerator<T>[] enums = new IEnumerator<T>[] { source.GetEnumerator() }
          .Concat(others
          .Where(item => item != null)
          .Select(item => item.GetEnumerator()))
        .ToArray();

      try {
        bool hasValue = true;

        while (hasValue) {
          hasValue = false;

          for (int i = 0; i < enums.Length; ++i) {
            if (enums[i] != null && enums[i].MoveNext()) {
              hasValue = true;

              yield return enums[i].Current;
            }
            else {
              enums[i].Dispose();
              enums[i] = null;
            }
          }
        }
      }
      finally {
        for (int i = enums.Length - 1; i >= 0; --i)
          if (enums[i] != null)
            enums[i].Dispose();
      }
    }
  }

Then use it:

   var streamOfBoth = get1().Interleave(get2());

   foreach(var item in streamOfBoth)
   {
       Console.WriteLine(item);
   }

Edit: if

" whenever any ... return a value, I can instantly get and process"

is crucial phrase in your question you can try BlockingCollection and implementproducer-consumer pattern :

static BlockingCollection<int> streamOfBoth = new BlockingCollection<int>();

// Producer #1 
static void get1() {
  while (true) {
    System.Threading.Thread.Sleep(1000);

    streamOfBoth.Add(1); // value (1) is ready and pushed into streamOfBoth
  }
}

// Producer #2
static void get2() {
  while (true) {
    System.Threading.Thread.Sleep(200);

    streamOfBoth.Add(2); // value (2) is ready and pushed into streamOfBoth
  }
}

...

Task.Run(() => get1()); // Start producer #1
Task.Run(() => get2()); // Start producer #2

...

// Cosumer: when either Producer #1 or Producer #2 create a value
// consumer can starts process it 
foreach(var item in streamOfBoth.GetConsumingEnumerable()) {
  Console.WriteLine(item);
}

Answer 3

Here is a generic Merge method that merges IEnumerable s. Each IEnumerable is enumerated in a dedicated thread.

using System.Reactive.Linq;
using System.Reactive.Concurrency;

public static IEnumerable<T> Merge<T>(params IEnumerable<T>[] sources)
{
    IEnumerable<IObservable<T>> observables = sources
        .Select(source => source.ToObservable(NewThreadScheduler.Default));
    IObservable<T> merged = Observable.Merge(observables);
    return merged.ToEnumerable();
}

Usage example:

var streamOfBoth = Merge(get1(), get2());

Enumerating the resulting IEnumerable will block the current thread until the enumeration is finished.

This implementation depends on the System.Reactive and System.Interactive.Async packages.