foreach (var element in enumerable)
  await element;

	List<Task> list = new List<Task>();
	foreach (Task task2 in tasks)
	{
		if (task2 == null)
		{
			throw new ArgumentException(Environment.GetResourceString("Task_MultiTaskContinuation_NullTask"), "tasks");
		}
		list.Add(task2);
	}
	return Task.InternalWhenAll(list.ToArray());

using System;
using System.Linq;
using System.Threading.Tasks;
using System.Collections.Concurrent;
using System.Diagnostics;
using Profiling;
using System.IO;

namespace Leo.Loader.Service
{
    public class RmqThreadManagerConsumer2<T> where T : class
    {
        static object Locker = new object();
        Func<Tuple<T[], string, Action>> _getter;
        Action<T> _runner;
        ConcurrentQueue<double> concurrentQueue = new ConcurrentQueue<double>();
        System.Timers.Timer timer2;
        volatile int Counter;
        Logics.FileWriter inputFileWriter;// = new Logics.FileWriter(System.Configuration.ConfigurationManager.AppSettings[])
        Logics.FileWriter errorFileWriter;
        public RmqThreadManagerConsumer2(Func<Tuple<T[], string, Action>> getter, Action<T> runner, string queueName, string inputRoot, string errorRoot)
        {
            _getter = getter ?? throw new ArgumentNullException(nameof(getter));
            _runner = runner ?? throw new ArgumentNullException(nameof(runner));
            if (string.IsNullOrEmpty(queueName))
                throw new ArgumentNullException(nameof(queueName));
            inputFileWriter = new Logics.FileWriter(inputRoot);
            errorFileWriter = new Logics.FileWriter(errorRoot);
            timer2 = new System.Timers.Timer(1000);
            timer2.SynchronizingObject = new SynchronizeInvoke();
            timer2.Elapsed += (o, a) => 
            {
                Run();
            };
            timer2.Start();
        }

        void Run()
        {
            lock (Locker)
            {
                Measure();
            }
        }
        void Grow(double d)
        {
            var agg = concurrentQueue.Count < 1 ? 1 : concurrentQueue.Count;
            var summ = concurrentQueue.Sum();
            var avg = summ / agg;
            Console.WriteLine("avg-" + avg);
            if ((1.1*d) > avg)//время выросло
            {
                if (Counter > 2)
                    Counter--;
            }
            else//время уменьшилось
            {
                if (Counter < 100)
                    Counter++;
            }
            concurrentQueue.Enqueue(d);
            if (agg > 100)
            {
                concurrentQueue.TryDequeue(out double x);
            }
        }
        void Measure()
        {
            Tuple<T[], string, Action> t = null;
            try
            {
                var c = Counter;

                while (c-- >= 0)
                {
                    Stopwatch sv = new Stopwatch();
                    bool IsNull = false;
                    t = _getter();
                    var res = Task.Factory.StartNew(() =>
                    {
                        sv.Start();
                        
                        if (t?.Item1 == null)
                        {
                            IsNull = true;
                            return;
                        }
                        foreach (var x in t.Item1)
                        {
                            _runner(x);
                        }
                        if (!string.IsNullOrEmpty(t.Item2))
                        {
                            lock (inputFileWriter)
                            {
                                inputFileWriter.Write(DateTime.Now, t.Item2, Path.GetRandomFileName() + ".json");
                            }
                        }
                    }).ContinueWith(task =>
                    {
                        var exc = task.Exception;
                        sv.Stop();
                        if (!IsNull)
                            Grow(sv.ElapsedMilliseconds);
                    });
                    var sdf = res.Exception;
                    if (sdf != null)
                    {
                        Logger.Instance.Error(sdf);
                        continue;
                    }
                    //помечаем сообщение обработанным
                    t?.Item3?.Invoke();
                    //res.Wait();
                }
            }
            catch (Exception exc)
            {
                Logger.Instance.Error(exc, "Ошибка в Measure");
                lock (errorFileWriter)
                {
                    errorFileWriter.Write(DateTime.Now, t?.Item2, Path.GetRandomFileName() + ".json");
                }
            }
        }
    }
}