c# Ограничение скорости для итераций foreach

Ваш код был почти идеальным.

Попробуйте это вместо этого:

public static void RateLimitedForEach<T>(this List<T> list, double minumumDelay, Action<T> action)
{
    list
        .ToObservable()
        .Zip(Observable.Interval(TimeSpan.FromSeconds(minumumDelay)), (v, _) => v)
        .Do(action)
        .ToArray()
        .Wait();
}

но это не должно быть сделано с помощью RX

Вот как вы можете сделать это синхронно:

public static void RateLimitedForEach<T>(
    this List<T> list,
    double minumumDelay,
    Action<T> action)
{
    foreach (var item in list)
    {
        Stopwatch sw = Stopwatch.StartNew();

        action(item);

        double left = minumumDelay - sw.Elapsed.TotalSeconds;

        if(left > 0)
            Thread.Sleep(TimeSpan.FromSeconds(left));
    }
}

А вот как вы можете сделать это асинхронно (асинхронны только потенциальные ожидания):

public static async Task RateLimitedForEachAsync<T>(
    this List<T> list,
    double minumumDelay,
    Action<T> action)
{
    foreach (var item in list)
    {
        Stopwatch sw = Stopwatch.StartNew();

        action(item);

        double left = minumumDelay - sw.Elapsed.TotalSeconds;

        if (left > 0)
            await Task.Delay(TimeSpan.FromSeconds(left));
    }
}    

Обратите внимание, что вы можете изменить асинхронную версию, чтобы сделать действие само асинхронным, например:

public static async Task RateLimitedForEachAsync<T>(
    this List<T> list,
    double minumumDelay,
    Func<T,Task> async_task_func)
{
    foreach (var item in list)
    {
        Stopwatch sw = Stopwatch.StartNew();

        await async_task_func(item);

        double left = minumumDelay - sw.Elapsed.TotalSeconds;

        if (left > 0)
            await Task.Delay(TimeSpan.FromSeconds(left));

    }
}    

Это полезно, если действие, которое необходимо выполнить для каждого элемента, является асинхронным.

Последнюю версию можно использовать так:

List<string> list = new List<string>();

list.Add("1");
list.Add("2");

var task = list.RateLimitedForEachAsync(1.0, async str =>
{
    //Do something asynchronous here, e.g.:
    await Task.Delay(500);
    Console.WriteLine(DateTime.Now + ": " + str);
});

Теперь вы должны дождаться окончания task. Если это метод Main, то нужно синхронно ждать вот так:

task.Wait();

С другой стороны, если вы находитесь внутри асинхронного метода, вам нужно асинхронно ждать так:

await task;

Концепция, которую вам нужно понять, заключается в том, что основной поток не ожидает завершения вашего вызова RateLimitedForEach. Кроме того, в вашем консольном приложении процесс завершается, как только заканчивается основной поток.

Что это значит? Это означает, что процесс завершится независимо от того, что наблюдатель на RateLimitedForEach завершил выполнение.

Примечание. Пользователь по-прежнему может принудительно завершить выполнение вашего приложения, и это хорошо. Вы можете использовать приложение формы, если хотите иметь возможность ждать без зависания пользовательского интерфейса, вы можете использовать службу, если вы не хотите, чтобы пользователь закрывал окна, связанные с процессом.

Использование Task — это превосходное решение того, что я представляю ниже.

Обратите внимание, что при использовании Задач в консольном приложении вам все равно нужно ждать выполнения задачи, чтобы предотвратить завершение основного потока до того, как RateLimitedForEach завершит свою работу. По-прежнему рекомендуется отказаться от консольного приложения.

Если вы настаиваете на продолжении использования своего кода, вы можете настроить его таким образом, чтобы вызывающий поток зависал до завершения:

public static void RateLimitedForEach<T>
(
    this List<T> list,
    double minumumDelay,
    Action<T> action
)
{
    using (var waitHandle = new ManualResetEventSlim(false))
    {

        var mainObservable = list.ToObservable();
        var intervalObservable = Observable.Interval(TimeSpan.FromSeconds(minumumDelay));  
        var zipObservable = mainObservable .Zip(intervalObservable, (v, _) => v);
        zipObservable.Subscribe
        (
            action,
            error => GC.KeepAlive(error), // Ingoring them, as you already were
            () => waitHandle.Set() // <-- "Done signal"
        );

        waitHandle.Wait(); // <--- Waiting on the observer to complete
    }
}

RX Throttle не делает то, что вы хотите?

https://msdn.microsoft.com/en-us/library/hh229400(v=vs.103).aspx