Ограничение перечислений запросов LINQ только одним - PullRequest
Новая
       12

Ограничение перечислений запросов LINQ только одним

0 голосов
/ 08 апреля 2019

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

var numbers = Enumerable.Range(1, 10).OnlyOnce();
Console.WriteLine(numbers.Count()); // shows 10
Console.WriteLine(numbers.Count()); // throws InvalidOperationException: The query cannot be enumerated more than once.

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

var tasks = Enumerable.Range(1, 10).Select(n => Task.Run(() => Console.WriteLine(n)));
Task.WaitAll(tasks.ToArray()); // Lets wait for the tasks to finish...
Console.WriteLine(String.Join(", ", tasks.Select(t => t.Id))); // Lets see the completed task IDs...
// Oups! A new set of tasks started running!

Ответы [ 3 ]

2 голосов
/ 08 апреля 2019

Я хочу избежать ошибочного перечисления дважды.

Вы можете обернуть коллекцию коллекцией, которая выбрасывает, если она перечисляется дважды.

например: 

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp8
{
    public static class EnumExtension
    {
        class OnceEnumerable<T> : IEnumerable<T>
        {
            IEnumerable<T> col;
            bool hasBeenEnumerated = false;
            public OnceEnumerable(IEnumerable<T> col)
            {
                this.col = col;
            }

            public IEnumerator<T> GetEnumerator()
            {
                if (hasBeenEnumerated)
                {
                    throw new InvalidOperationException("This collection has already been enumerated.");
                }
                this.hasBeenEnumerated = true;
                return col.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }

        public static IEnumerable<T> OnlyOnce<T>(this IEnumerable<T> col)
        {
            return new OnceEnumerable<T>(col);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
             var col = Enumerable.Range(1, 10).OnlyOnce();

             var colCount = col.Count(); //first enumeration
             foreach (var c in col) //second enumeration
             {
                 Console.WriteLine(c);
             }
        }
    }
}
2 голосов
/ 08 апреля 2019

Перечисляются перечисления, конец истории. Вам просто нужно позвонить ToList или ToArray

// this will enumerate and start the tasks
var tasks = Enumerable.Range(1, 10)
                      .Select(n => Task.Run(() => Console.WriteLine(n)))
                      .ToList();

// wait for them all to finish
Task.WaitAll(tasks.ToArray());
Console.WriteLine(String.Join(", ", tasks.Select(t => t.Id)));

Хмм, если вы хотите параллелизма 

Parallel.For(0, 100, index => Console.WriteLine(index) );

или если вы используете шаблон асинхронного ожидания и ожидания 

public static async Task DoWorkLoads(IEnumerable <Something> results)
{
   var options = new ExecutionDataflowBlockOptions
                     {
                        MaxDegreeOfParallelism = 50
                     };

   var block = new ActionBlock<Something>(MyMethodAsync, options);

   foreach (var result in results)
      block.Post(result);

   block.Complete();
   await block.Completion;

}

...

public async Task MyMethodAsync(Something result)
{       
   await SomethingAsync(result);
}

Update, так как вам нужен способ управления максимальной степенью параллелизма, вы можете использовать это 

public static async Task<IEnumerable<Task>> ExecuteInParallel<T>(this IEnumerable<T> collection,Func<T, Task> callback,int degreeOfParallelism)
{
   var queue = new ConcurrentQueue<T>(collection);

   var tasks = Enumerable.Range(0, degreeOfParallelism)
                         .Select(async _ =>
                          {
                             while (queue.TryDequeue(out var item))
                                await callback(item);
                          })
                         .ToArray();

   await Task.WhenAll(tasks);

   return tasks;
}
1 голос
/ 08 апреля 2019

Rx, безусловно, является опцией для управления параллелизмом. 

var query =
    Observable
        .Range(1, 10)
        .Select(n => Observable.FromAsync(() => Task.Run(() => new { Id = n })));

var tasks = query.Merge(maxConcurrent: 3).ToArray().Wait();

Console.WriteLine(String.Join(", ", tasks.Select(t => t.Id)));
...