Задачи TPL + динамические == OutOfMemoryException?

Это больше связано с тем, что производитель намного опережает потребителя, чем с DLR. Цикл создает задачи как можно быстрее — и задачи не запускаются «немедленно». Легко понять, насколько он может отставать:

        int count = 0;

        new Timer(_ => Console.WriteLine(count), 0, 0, 500);

        while (true)
        {
            Interlocked.Increment(ref count);

            Task.Factory.StartNew(() =>
            {
                dynamic dyn2 = new ExpandoObject();
                dyn2.text = Get500kOfText() + Get500kOfText() + DateTime.Now.ToString() +
                  DateTime.Now.Millisecond.ToString();

                Interlocked.Decrement(ref count);
            });
        }

Вывод:

324080
751802
1074713
1620403
1997559
2431238

Это много для трехсекундного планирования. Удаление Task.Factory.StartNew (однопоточное выполнение) дает стабильную память.

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

Проблема здесь не в том, что задачи, которые вы создаете, не очищаются. Asti продемонстрировал, что ваш код создает задачи быстрее, чем они могут быть обработаны, поэтому, пока вы очищаете память о выполненных задачи, вы все равно закончите в конце концов.

Вы сказали:

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

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

int numConcurrentActions = 100000;
BlockingCollection<Task> tasks = new BlockingCollection<Task>();

Action someAction = () =>
{
    dynamic dyn = new System.Dynamic.ExpandoObject();

    dyn.text = Get500kOfText() + Get500kOfText() 
        + DateTime.Now.ToString() + DateTime.Now.Millisecond.ToString();
};

//add a fixed number of tasks
for (int i = 0; i < numConcurrentActions; i++)
{
    tasks.Add(new Task(someAction));
}

//take a task out, set a continuation to add a new one when it finishes, 
//and then start the task.
foreach (Task t in tasks.GetConsumingEnumerable())
{
    t.ContinueWith(_ =>
    {
        tasks.Add(new Task(someAction));
    });
    t.Start();
}

Этот код гарантирует, что одновременно будет выполняться не более 100 000 задач. Когда я запускаю это, память стабильна (при усреднении за несколько секунд). Он ограничивает задачи, создавая фиксированное число, а затем устанавливая продолжение для планирования новой задачи всякий раз, когда завершается существующая.

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

Хотя обычно я бы сказал, что люди склонны пытаться оптимизировать код, когда он уже работает «достаточно быстро», это явно не ваш случай. У вас есть довольно жесткий контрольный показатель, который вам нужно достичь; вам нужно обрабатывать элементы быстрее, чем они приходят. В настоящее время вы не соответствуете этому критерию (но, поскольку он работает некоторое время, прежде чем дать сбой, вы не должны быть этими далеко).