LINQ с запросом "Память"

Ответ 1

Итак, это... возможно. Но это далеко не показатель производительности.

var res = query.Select(q => new {
    original = q, 
    matches = query.Where(innerQ => areBarsSimilar(q.Bars, innerQ.Bars))
}).Select(g => new { original = g, joinKey = string.Join(",", g.matches.Select(m => m.Id)) })
.GroupBy (g => g.joinKey)
.Select(g => g.First().original.original)
.Take(N);

Это предполагает, что Id уникальны для каждого Foo (вы также можете использовать их GetHashCode(), я полагаю).

Гораздо лучшее решение - либо сохранить то, что вы сделали, либо реализовать пользовательский сопоставитель, как показано ниже:

class MyComparer : IEqualityComparer<Foo>
{
    public bool Equals(Foo left, Foo right)
    {
        return left.Bars.Count() == right.Bars.Count() && //have the same amount of bars
            left.Bars.Select(x => x.Id)
            .Except(right.Bars.Select(y => y.Id))
            .ToList().Count == 0; //and when excepted returns 0, mean similar bar
    }

    public int GetHashCode(Foo foo)
    {
        unchecked {
            int hc = 0;
            if (foo.Bars != null)
                foreach (var p in foo.Bars)
                hc ^= p.GetHashCode();
            return hc;
        }
    }
}

И тогда ваш запрос будет просто:

var res = query
    .GroupBy (q => q, new MyComparer())
    .Select(g => g.First())
    .Take(N);

Ответ 2

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

Сначала рассмотрим запись IEqualityComparer<Foo>, которая использует коллекцию Bars для измерения равенства. Здесь я предполагаю, что списки могут содержать повторяющиеся записи, поэтому имеют довольно строгое определение сходства:

public class FooSimilarityComparer:IEqualityComparer<Foo>
{
    public bool Equals(Foo a, Foo b)
    {
        //called infrequently
        return a.Bars.OrderBy(bar => bar.Id).SequenceEqual(b.Bars.OrderBy(bar => bar.Id));
    }
    public int GetHashCode(Foo foo)
    {
        //called frequently
        unchecked
        {
            return foo.Bars.Sum(b => b.GetHashCode());
        }
    }
}

Вы можете эффективно получить верхние N не похожие элементы, используя HashSet с IEqualityComparer выше:

IEnumerable<Foo> someFoos; //= some list of Foo
var hs = new HashSet<Foo>(new FooSimilarityComparer());
foreach(var f in someFoos)
{
    hs.Add(f); //hashsets don't add duplicates, as measured by the FooSimilarityComparer
    if(hs.Count >= 50)
    {
        break;
    }
}

Подход @Rob s выше аналогичен и показывает, как вы можете использовать компаратор непосредственно в LINQ, но обратите внимание на комментарии, которые я сделал для его ответа.

Ответ 3

IEnumerable<Foo> dissimilarFoos =
  from foo in query
  let key = string.Join('|',
    from bar in foo.Bars
    order by bar.Id
    select bar.Id.ToString())
  group foo by key into g
  select g.First();

IEnumerable<Foo> firstDissimilarFoos =
  dissimilarFoos.Take(50);

Иногда вам может не нравиться поведение groupby в вышеуказанных запросах. Во время перечисления запроса groupby будет перечислять весь источник. Если вам требуется только частичное перечисление, вы должны переключиться на Distinct и Comparer:

class FooComparer : IEqualityComparer<Foo>
{
  private string keyGen(Foo foo)
  {
    return string.Join('|',
      from bar in foo.Bars
      order by bar.Id
      select bar.Id.ToString());
  }
  public bool Equals(Foo left, Foo right)
  {
    if (left == null || right == null) return false;
    return keyGen(left) == keyGen(right);
  }
  public bool GetHashCode(Foo foo)
  {
    return keyGen(foo).GetHashCode();
  }
}

тогда напишите:

IEnumerable<Foo> dissimilarFoos = query.Distinct(new FooComparer());
IEnumerable<Foo> firstDissimilarFoos = dissimilarFoos.Take(50);

Ответ 4

Идея. Возможно, вы сможете что-то взломать, разработав собственный свободно управляемый интерфейс мутаторов над кешем, который вы бы захватили в предложениях "let x =..." в строках

from q in query
let qc = ... // your cache mechanism here
select ...

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

'НТН,

Ответ 5

Я полагаю, что "full LINQ" означает стандартные методы LINQ/ Enumerable.

Я не думаю, что это можно сделать с помощью синтаксиса запроса LINQ. Из стандартных методов единственное, поддерживающее изменчивое состояние обработки, - Enumerable.Aggregate, но оно дает вам не что иное, как аромат LINQ над простой foreach:

var result = query.Aggregate(new List<Foo>(), (list, next) =>
{
    if (list.Count < 50 && !list.Any(item => areBarsSimilar(item.Bars, next.Bars)))
        list.Add(next);
    return list;
});

Так как нам нравится использовать вспомогательные методы (например, areBarsSimilar), самое лучшее, что мы можем сделать, это сделать его, по крайней мере, более LINQ-ish, определив и используя собственный метод расширения

var result = query.Aggregate(new List<Foo>(), (list, next) => list.Count < 50 && 
    !list.Any(item => areBarsSimilar(item.Bars, next.Bars)) ? list.Concat(next) : list);

где пользовательский метод

public static class Utils
{
    public static List<T> Concat<T>(this List<T> list, T item) { list.Add(item); return list; }
}

Но обратите внимание, что по сравнению с vanilla foreach, Aggregate имеет дополнительный недостаток в том, что он не может выйти раньше, поэтому будет потреблять всю входную последовательность (которая помимо производительности также означает, что она не работает с бесконечными последовательностями).

Заключение:. Хотя это должно ответить на ваш первоначальный вопрос, т.е. технически можно делать то, о чем вы просите, LINQ (например, стандартный SQL) не подходит для такого типа обработки.