C#

var o = Observable.FromEventPattern<DownloadStringCompletedEventArgs>(wc, "DownloadStringCompleted")

                  // Let's make sure that we're not on the UI Thread
                  .ObserveOn(Scheduler.Default)

                  // When the event fires, just select the string and make
                  // an IObservable<string> instead
                  .Select(newString => BackgroundWorkerThread(newString.EventArgs.Result))

                  // Send it back to UI Thread
                  .ObserveOnDispatcher();

Pete O'Hanlon wrote:

he documentation is all over the place as the examples you tend to find relate to Rx as it was about 6 years ago and it's moved on so much

var buttonClick = Observable.FromEventPattern<RoutedEventHandler, RoutedEventArgs>(
    h => btnMainWindow.Click += h,
    h => btnMainWindow.Click -= h);

var EnumerableTest = Enumerable
    .Range(1, 10)
    .ToObservable()
    .ObserveOnDispatcher()
    .SubscribeOn(NewThreadScheduler.Default);

var DisposableEnumerable = EnumerableTest
    .Subscribe(evt =>
txtMainWindow.Text += evt + Environment.NewLine
);

buttonClick.Subscribe(evt =>
{
    DisposableEnumerable.Dispose();
});

.SubscribeOn(NewThreadScheduler.Default)

.SubscribeOnDispatcher()

List<object> entityBatch = new List<object>(batchSize);

public static class EnumerableExtensions
{
    private static IEnumerable<IEnumerable<TSource>> BatchIterator<TSource>(IEnumerable<TSource> source, int size)
    {
        int count = 0;
        var bucket = new TSource[size];
        foreach (var item in source)
        {
            bucket[count] = item;

            checked
            {
                count++;
            }

            if (count == size)
            {
                yield return bucket.Select(x => x);
                bucket = new TSource[size];
                count = 0;
            }
        }
        if (count != 0)
        {
            yield return bucket.Take(count);
        }

        // ReSharper disable once RedundantAssignment
        bucket = null;
    }

    public static IEnumerable<IEnumerable<TSource>> Batch<TSource>(this IEnumerable<TSource> source, int size)
    {
        if (source == null) throw new ArgumentNullException(nameof(source));
        if (size < 1) throw new ArgumentOutOfRangeException(nameof(size));
        return BatchIterator(source, size);
    }
}

Richard Deeming wrote:

Don't measure the performance of your code using DateTime; use the Stopwatch class[^] instead.

Richard Deeming wrote:

Did you make sure to "warm up" the code before you timed it, and run the test over many iterations?

Richard Deeming wrote:

Since you know the maximum number of items you'll be adding to the list, you should set its capacity when you create it:

C#

List<object> entityBatch = new List<object>(batchSize);

If you don't set the capacity, it starts at 4 and doubles each time it runs out of space.

Richard Deeming wrote:

You need to check the value returned from enumerator.MoveNext; if it returns false, you've reached the end of the sequence. Your code currently continues adding the final items from the sequence to the list until you reach the batch size.

Richard Deeming wrote:

You should consider using proper generic types, rather than a List<object>; that way, you avoid having to cast the items back to the correct type when you read the batches.

Richard Deeming wrote:

It's probably best to wrap this sort of thing up as a extension method

RichardGrimmer wrote:

not possible in this instance - it's in an abstract base class, which operates over several types of similar but not related types and exists in a (necessarily) singleton class....

public abstract class MyBaseClass
{
    public void ProcessList<T>(IEnumerable<T> listToProcess) where T : MyBaseClass
    {
        ...
    }
}

public class ChildItem
{
  public ChildItem()
  {
    Count = int.MaxValue;
    LongCount = long.MaxValue;
    Nullable2 = int.MaxValue - 3;
    Nullable3 = Nullable2.Value - 2;
  }
  public int Count { get; set; }
  public long LongCount { get; set; }
  public int? Nullable1 { get; set; }
  public int? Nullable2 { get; set; }
  public int? Nullable3 { get; set; }
}
public class MasterList
{
  private List<ChildItem> children = new List<ChildItem>();
  public MasterList()
  {
    for (int i = 0; i < 6; i++)
    {
      children.Add(new ChildItem());
    }
    Master1 = "Hi";
    Master2 = "Hi";
    Master3 = "Hi";
    Master4 = "Hi";
    Master5 = "Hi";
    Master6 = "Hi";
    Master7 = "Hi";
    Master8 = "Hi";
    Master9 = "Hi";
    Master10 = "Hi";
    Master11 = "Hi";
    Master12 = "Hi";
  }

  public IEnumerable<ChildItem> Children => children;

  public string Master1 { get; set; }
  public string Master2 { get; set; }
  public string Master3 { get; set; }
  public string Master4 { get; set; }
  public string Master5 { get; set; }
  public string Master6 { get; set; }
  public string Master7 { get; set; }
  public string Master8 { get; set; }
  public string Master9 { get; set; }
  public string Master10 { get; set; }
  public string Master11 { get; set; }
  public string Master12 { get; set; }
}
public class TestIt
{
  private List<MasterList> items = new List<MasterList>(700000);

  public TestIt()
  {
    for (int i = 0; i < 700000; i++)
    {
      items.Add(new MasterList());
    }
    Console.WriteLine("Ready");
  }

  public void StartTest(string text = "Dummy run")
  {
    var enumerator = items.GetEnumerator();

    enumerator.MoveNext();

    List<object> entityBatch = new List<object>();

    Stopwatch sw = new Stopwatch();
    sw.Start();

    for (int iterStep = 0; iterStep < 700000; iterStep++)
    {
      entityBatch.Add(enumerator.Current);
      enumerator.MoveNext();
    }
    sw.Stop();

    Console.WriteLine(text);
    Console.WriteLine("Total time {0}", sw.ElapsedMilliseconds);
  }
}