Почему оператор Contains () так резко снижает производительность Entity Framework?

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

используйте обходной путь и обходной путь в случае проблемы с производительностью, а EF означает прямой SQL. В этом нет ничего плохого. Глобальная идея, что использование EF = больше не использует SQL, является ложью. У вас есть SQL Server 2008 R2 Итак:

• создать хранимую процедуру, принимающую возвращающий табличное значение параметр для передачи идентификаторов
• пусть ваша хранимая процедура возвращает несколько результирующих наборов для эмуляции Include логика оптимальным способом
• Если вам нужно какое-то сложное построение запросов, используйте динамический SQL внутри хранимой процедуры
• использовать SqlDataReader получить результаты и построить свои лица
• прикрепить их к контексту и работать с ними, как если бы они были загружены из Эф

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

мы смогли решить проблему EF Contains, добавив промежуточную таблицу и присоединившись к этой таблице из запроса LINQ, который должен был использовать предложение Contains. Мы смогли добиться потрясающих результатов при таком подходе. У нас есть большая модель EF, и поскольку "содержит" не допускается при предварительной компиляции запросов EF, мы получаем очень низкую производительность для запросов, которые используют предложение "содержит".

общие сведения:

• создать таблицу в SQL Server-for пример HelperForContainsOfIntType С HelperID на Guid тип данных и ReferenceID на int столбцы типа данных. Создавать различные таблицы с ReferenceID различных типов данных по мере необходимости.

• создать объект / EntitySet для HelperForContainsOfIntType и другие такие таблицы в модели EF. При необходимости создайте разные сущности / EntitySet для разных типов данных.

• создать вспомогательный метод в коде .NET, который принимает ввод IEnumerable<int> и возвращает Guid. Этот метод генерирует новый Guid и вставляет значения из IEnumerable<int> на HelperForContainsOfIntType вместе с генерируемым Guid. Далее метод возвращает это вновь сгенерированное Guid для звонящего. Для быстрой вставки в HelperForContainsOfIntType таблица, создать хранимую процедуру, которая принимает ввод списка значений и делает вставку. Смотрите возвращающие табличное значение параметры в SQL Server 2008 (ADO.NET). создайте разные помощники для разных типов данных или создайте общий вспомогательный метод для обработки разных тип данных.

• создать EF скомпилированный запрос, который похож на что-то вроде ниже:

  static Func<MyEntities, Guid, IEnumerable<Customer>> _selectCustomers =
      CompiledQuery.Compile(
          (MyEntities db, Guid containsHelperID) =>
              from cust in db.Customers
              join x in db.HelperForContainsOfIntType on cust.CustomerID equals x.ReferenceID where x.HelperID == containsHelperID
              select cust 
      );
  

• вызовите вспомогательный метод со значениями, которые будут использоваться в Contains предложение и получить Guid для использования в запросе. Например:

  var containsHelperID = dbHelper.InsertIntoHelperForContainsOfIntType(new int[] { 1, 2, 3 });
  var result = _selectCustomers(_dbContext, containsHelperID).ToList();
  

редактирование моего исходного ответа - существует возможный обходной путь, в зависимости от сложности ваших объектов. Если вы знаете sql, который EF генерирует для заполнения ваших сущностей, вы можете выполнить его непосредственно с помощью DbContext.База данных.SQL-запрос. В EF 4, я думаю, вы могли бы использовать ObjectContext.ExecuteStoreQuery, но я не пробовал.

например, используя код из моего исходного ответа ниже, чтобы создать инструкцию sql с помощью StringBuilder, Я смог сделать следующее

var rows = db.Database.SqlQuery<Main>(sql).ToArray();

и общее время пошло от приблизительно 26 секунд до 0,5 секунды.

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

обновление

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

чтобы проверить это, я создал Target таблица с той же схемой, как Main. Затем я использовал StringBuilder создать INSERT команды для заполнения Target таблица в партиях по 1000, так как это самый SQL Server будет принимать в одном INSERT. Непосредственное выполнение инструкций sql было намного быстрее, чем прохождение EF (около 0,3 секунды против 2,5 секунд), и я считаю, что все будет в порядке, так как схема таблицы не должно измениться.

и, наконец, выбрав с помощью join привело к гораздо более простому запросу и выполняется менее чем за 0,5 секунды.

ExecuteStoreCommand("DELETE Target");

var ids = Main.Select(a => a.Id).ToArray();
var sb = new StringBuilder();

for (int i = 0; i < 10; i++)
{
    sb.Append("INSERT INTO Target(Id) VALUES (");
    for (int j = 1; j <= 1000; j++)
    {
        if (j > 1)
        {
            sb.Append(",(");
        }
        sb.Append(i * 1000 + j);
        sb.Append(")");
    }
    ExecuteStoreCommand(sb.ToString());
    sb.Clear();
}

var rows = (from m in Main
            join t in Target on m.Id equals t.Id
            select m).ToArray();

rows.Length.Dump();

и sql, созданный EF для соединения:

SELECT 
[Extent1].[Id] AS [Id]
FROM  [dbo].[Main] AS [Extent1]
INNER JOIN [dbo].[Target] AS [Extent2] ON [Extent1].[Id] = [Extent2].[Id]

---

(оригинал ответа)

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

SQL Profiler показывает задержку между выполнением первого запроса (Main.Select) и второй Main.Where запрос, поэтому я подозревал, что проблема заключалась в создании и отправке запроса такого размера (48 980 байт).

однако построение одного и того же оператора sql в T-SQL динамически занимает менее 1 секунды и принимает ids из своего Main.Select оператор, создавая тот же оператор sql и выполняя его с помощью SqlCommand заняло 0,112 секунды, и это в том числе время, чтобы записать содержимое на консоль.

на данный момент я подозреваю, что EF делает некоторый анализ/обработку для каждого из 10 000 ids как он строит запрос. Жаль, что я не могу дать окончательный ответ и решение :(.

вот код, который я пробовал в SSMS и LINQPad (пожалуйста, не критикуйте слишком резко, я спешу, пытаясь уйти с работы):

declare @sql nvarchar(max)

set @sql = 'SELECT 
[Extent1].[Id] AS [Id]
FROM [dbo].[Main] AS [Extent1]
WHERE [Extent1].[Id] IN ('

declare @count int = 0
while @count < 10000
begin
    if @count > 0 set @sql = @sql + ','
    set @count = @count + 1
    set @sql = @sql + cast(@count as nvarchar)
end
set @sql = @sql + ')'

exec(@sql)

---

var ids = Mains.Select(a => a.Id).ToArray();

var sb = new StringBuilder();
sb.Append("SELECT [Extent1].[Id] AS [Id] FROM [dbo].[Main] AS [Extent1] WHERE [Extent1].[Id] IN (");
for(int i = 0; i < ids.Length; i++)
{
    if (i > 0) 
        sb.Append(",");     
    sb.Append(ids[i].ToString());
}
sb.Append(")");

using (SqlConnection connection = new SqlConnection("server = localhost;database = Test;integrated security = true"))
using (SqlCommand command = connection.CreateCommand())
{
    command.CommandText = sb.ToString();
    connection.Open();
    using(SqlDataReader reader = command.ExecuteReader())
    {
        while(reader.Read())
        {
            Console.WriteLine(reader.GetInt32(0));
        }
    }
}

Я не знаком с Entity Framework, но лучше ли perf, если вы сделаете следующее?

вместо этого:

var ids = Main.Select(a => a.Id).ToArray();
var rows = Main.Where (a => ids.Contains(a.Id)).ToArray();

Как насчет этого (предполагая, что ID является int):

var ids = new HashSet<int>(Main.Select(a => a.Id));
var rows = Main.Where (a => ids.Contains(a.Id)).ToArray();

Это было исправлено на Entity Framework 6 Alpha 2:http://entityframework.codeplex.com/SourceControl/changeset/a7b70f69e551

http://blogs.msdn.com/b/adonet/archive/2012/12/10/ef6-alpha-2-available-on-nuget.aspx

кэшируемая альтернатива Contains?

Это просто укусило меня, поэтому я добавил свои два пенса в ссылку Entity Framework Feature Suggestions.

проблема, безусловно, при создании SQL. У меня есть клиент на данные ВОЗ генерация запроса была 4 секунды, но выполнение было 0.1 секунд.

Я заметил, что при использовании dynamic LINQ и ORs поколение sql занимало столько же времени, но оно генерировало что-то, что может быть cached. Поэтому при повторном выполнении это было до 0,2 секунд.

обратите внимание, что SQL in все еще был сгенерирован.

просто что-то еще, чтобы рассмотреть, если вы можете переварить первоначального обращения, количество не сильно изменится, и выполнить много запросов. (Протестировано в LINQ Pad)

проблема заключается в создании SQL Entity Framework. Он не может кэшировать запрос, если один из параметров представляет собой список.

чтобы получить EF для кэширования запроса, вы можете преобразовать свой список в строку и сделать a .Содержит в строке.

Так, например, этот код будет работать намного быстрее, так как EF может кэшировать запрос:

var ids = Main.Select(a => a.Id).ToArray();
var idsString = "|" + String.Join("|", ids) + "|";
var rows = Main
.Where (a => idsString.Contains("|" + a.Id + "|"))
.ToArray();

когда этот запрос будет сгенерирован, он, скорее всего, будет сгенерирован с использованием Like вместо In, поэтому он ускорит ваш C#, но он может потенциально замедлить SQL. В моем случае я не заметил снижения производительности при выполнении SQL, и C# работал значительно быстрее.