Выберите Distinct Count очень медленно

Question

У меня есть цикл из около 7000 объектов, и в цикле мне нужно получить отчетливое количество списков структур. В настоящее время я использую -

foreach (var product in productsToSearch) 
{ 
    Console.WriteLine("Time elapsed: {0} start", stopwatch.Elapsed); 
    var cumulativeCount = 0; 
    productStore.Add(product); 
    var orderLinesList = totalOrderLines 
     .Where(myRows => productStore.Contains(myRows.Sku)) 
     .Select(myRows => new OrderLineStruct 
     { 
      OrderId = myRows.OrderId, 
      Sku = myRows.Sku 
     }); 
    var differences = totalOrderLines.Except(orderLinesList); 
    cumulativeCount = totalOrderLinsCount - differences.Select(x => x.OrderId).Distinct().Count(); 
    cumulativeStoreTable.Rows.Add(product, cumulativeCount);  
    Console.WriteLine("Time elapsed: {0} end", stopwatch.Elapsed); 
} 

public struct OrderLineStruct 
{ 
    public string OrderId { get; set; } 
    public string Sku { get; set; } 
} 

Это очень медленно при получении отдельного счета. Кто-нибудь знает более эффективный способ сделать это? Я попытался использовать MoreLinq, у которого есть метод DisctintBy для Linq, но он не эффективнее, поскольку я его приурочил. Я играл с PLinq, но я немного не уверен, где распараллелить этот запрос.

Таким образом, каждая итерация цикла приурочен на -
Время истекло: 00: 00: 37,1142047 старт
Время истекло: 00: 00: 37.8310148 конец

= 0.7168101 сек * 7000 = 5017,6707 (83.627845 минут)

Его линия Distinct() Count(), которая занимает больше всего времени для обработки (около 0,5 секунды). Переменные различия имеют несколько сотен тысяч OrderLineStruct, поэтому любые запросы linq на этом медленны.

UPDATE

Я изменил цикл немного, и теперь он работает в около 10 минут, а что в течение 1 часа

foreach (var product in productsToSearch) 
{ 
    var cumulativeCount = 0; 
    productStore.Add(product); 
    var orderLinesList = totalOrderLines 
     .Join(productStore, myRows => myRows.Sku, p => p, (myRows, p) => myRows) 
     .Select(myRows => new OrderLineStruct 
     { 
      OrderId = myRows.OrderId, 
      Sku = myRows.Sku 
     }); 
    totalOrderLines = totalOrderLines.Except(orderLinesList).ToList(); 
    cumulativeCount = totalOrderLinesCount - totalOrderLines.Select(x => x.OrderId).Distinct().Count(); 
    cumulativeStoreTable.Rows.Add(product, cumulativeCount); 
} 

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

Answer 1

Вы ищите проблему не в этом месте.

orderLinesList, differences и differences.Select(x => x.OrderId).Distinct() только LINQ к объектам прикована запросы методы с отложенного исполнения и методом Count() выполняет их все.

Ваш алгоритм обработки очень неэффективен. Узким местом является запрос orderLinesList, который выполняет итерацию всего списка totalOrderLines для каждого product, и он прикован (в комплекте) в Except, Distinct и т. Д. - снова внутри цикла, т.е. 7000+ раз.

Вот пример эффективный алгоритм, который ИМО делает то же самое:

Console.WriteLine("Time elapsed: {0} start", stopwatch.Elapsed); 
var productInfo = 
(
    from product in productsToSearch 
    join line in totalOrderLines on product equals line.Sku into orderLines 
    select new { Product = product, OrderLines = orderLines } 
).ToList(); 
var lastIndexByOrderId = new Dictionary<string, int>(); 
for (int i = 0; i < productInfo.Count; i++) 
{ 
    foreach (var line in productInfo[i].OrderLines) 
     lastIndexByOrderId[line.OrderId] = i; // Last wins 
} 
int cumulativeCount = 0; 
for (int i = 0; i < productInfo.Count; i++) 
{ 
    var product = productInfo[i].Product; 
    foreach (var line in productInfo[i].OrderLines) 
    { 
     int lastIndex; 
     if (lastIndexByOrderId.TryGetValue(line.OrderId, out lastIndex) && lastIndex == i) 
     { 
      cumulativeCount++; 
      lastIndexByOrderId.Remove(line.OrderId); 
     } 
    } 
    cumulativeStoreTable.Rows.Add(item.Product, cumulativeCount); 
    // Remove the next if it was just to support your processing 
    productStore.Add(item.Product); 
} 
Console.WriteLine("Time elapsed: {0} end", stopwatch.Elapsed); 

Answer 2

Откуда берутся totalOrderLines? Может быть, база данных MSSQL? Если это так, вам нужно будет иметь индекс в столбце OrderId. Выполнение отличительного() без индекса в этом столбце заставляет механизм БД перебирать все строки для идентификации отдельных значений.

Answer 3

Я рекомендую изменить эту часть вашей LINQ запросов

totalOrderLines.Where(myRows => productStore.Contains(myRows.Sku)) 

к Join читать следующим образом:

totalOrderLines.Join(productStore, myRows => myRows.Sku, p => p, (myRows, p) => myRows) 

Таким образом, вы платите стоимость когда-то вместо того, чтобы Contains пройти ваш продукт список магазина 7000 раз, что очень неэффективно. Кроме того, если вы можете создавать свои интегральные типы данных id (int, long), а не строку, вы должны иметь более быстрый поиск и сравнения. Но я предполагаю, что структура вашей модели довольно много.

Answer 4

В вашем случае, как упоминал Джон Ханна, узким местом является метод Except.
Distinct и Count имеет второй приоритет.
Вы можете проверить это, применяя перечисление на каждой части вашего метода и помещая секундомер вокруг.

foreach (var product in productsToSearch) 
{ 
    var cumulativeCount = 0; 
    productStore.Add(product); 

    olSw.Start(); 
    var orderLinesList = totalOrderLines 
     .Where(myRows => productStore.Contains(myRows.Sku)) 
     .Select(myRows => new OrderLineStruct 
     { 
      OrderId = myRows.OrderId, 
      Sku = myRows.Sku 
     }).ToList(); 
    olSw.Stop(); 

    exSw.Start(); 
    var differences = totalOrderLines.Except(orderLinesList).ToList(); 
    exSw.Stop(); 

    dcSw.Start(); 
    cumulativeCount = totalOrderLinsCount - differences.Select(x => x.OrderId).Distinct().Count(); 
    dcSw.Stop(); 
} 

Размеры:
productsToSearch счета 100
totalOrderLines счета 300 000

Total olSw time: 00:00:01.3583340
Total exSw time: 00:00:14.3304959
Total dcSw time: 00:00:04.1986018

exSw время может быть уменьшено путем явного осуществления дическим GetHashCode на OrderLineStruct

С явным GetHashCode:

Total olSw time: 00:00:01.4045676
Total exSw time: 00:00:08.4691066
Total dcSw time: 00:00:03.9439711

Общее изменение времени без избыточного перечисления:
По умолчанию GetHashCodeTotal time: 00:00:18.9649790
Явная GetHashCodeTotal time: 00:00:12.7736320

Обновление:
Также вы можете оптимизировать это, изменив логику метода.

Например, вы можете создать HashSet из totalOrderLines, а затем просто удалить элементы из него.

var orderLinesList = totalOrderLines 
    ... 
    .ToList(); 

orderLinesList.ForEach(item => totalOrderLines.Remove(item)); 

cumulativeCount = totalOrderLinsCount - totalOrderLines.Select(x => x.OrderId).Distinct().Count(); 

В моем случае это сокращает общее время до 7 секунд.
Total time: 00:00:07.0851111

В этом случае перечисление через TotalOrderLines с Dictinct является узким местом, но это занимает O(N) время, которое хорошо.