Нашли ошибку или опечатку? Выделите текст и нажмите

Поменять цветовую

гамму сайта?

Поменять
Обновления сайта
и новые разделы

Рекомендовать в Google +1

Загрузка данных

60
Исходный проект

В предыдущей статье мы рассмотрели как создаются LINQ-запросы в Entity Framework. В этой и последующих статьях мы рассмотрим операции CRUD (create, read, update, delete) для работы с данными. Для извлечения данных из таблиц в SQL используется инструкция SELECT. Знать детали SQL-запросов вам не нужно, т.к. Entity Framework заботится о преобразовании LINQ-запросов в SQL.

Для получения всех данных из таблицы вам даже не нужно использовать LINQ-запрос, вы можете просто использовать свойство класса контекста, ссылающееся на класс модели и имеющее тип DbSet<T>. Entity Framework создаст запрос в базу данных для загрузки всех данных из таблицы, связанной с этим классом модели. Давайте добавим метод GetAllCustomers() в наш консольный проект, который мы создали ранее, чтобы извлечь все данные покупателей (т.к. мы еще не рассмотрели вставку данных с помощью Entity Framework, чтобы протестировать примеры выборки данных, вы можете заполнить таблицы Customers и Orders вручную, используя средства Visual Studio или SQL Server Management Studio):

public static void GetAllCustomers()
{
    SampleContext context = new SampleContext();

    // Извлечь всех заказчиков и отобразить их имена в консоли
    foreach (Customer customer in context.Customers)
        Console.WriteLine(customer.FirstName);
}

Запрос context.Customers в этом примере извлечет все данные из таблицы Customers. Для запуска примера, вы можете вызвать метод GetAllCustomers() в методе Main() консольного приложения. Для этого примера Entity Framework сгенерирует следующий SQL-код (здесь я привожу фрагменты кода SQL для тех читателей, которые хорошо знакомы с T-SQL и хотят знать как EF транслирует запросы LINQ в SQL):

SELECT 
    [Extent1].[CustomerId] AS [CustomerId], 
    [Extent1].[FirstName] AS [FirstName], 
    [Extent1].[LastName] AS [LastName], 
    [Extent1].[Email] AS [Email], 
    [Extent1].[Age] AS [Age], 
    [Extent1].[Photo] AS [Photo]
    FROM [dbo].[Customers] AS [Extent1]

Код в этом примере возможно покажется несколько перегруженным, за счет использования псевдонима Extent1 для таблицы Customers и других псевдонимов для столбцов, а также явного указания схемы по умолчанию dbo. Это связано с тем, что Entity Framework имеет общий алгоритм построения запросов, который не только обслуживает этот очень простой запрос в примере, но также используется и для гораздо более сложных сценариев, в которых могут понадобиться эти псевдонимы.

На рисунке ниже, для наглядности, показана та область таблицы Customers, данные которой извлекаются в этом примере:

Загрузка всех данных из таблицы с помощью Entity Framework

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

public static void GetAllCustomers()
{
    SampleContext context = new SampleContext();

    // Отложенный запрос
    var customers = context.Customers;

    // Извлечь всех заказчиков и отобразить их имена в консоли
    foreach (Customer customer in customers)
        Console.WriteLine(customer.FirstName);

    // ... какой-то код

    // Еще один запрос, использующий коллекцию customers
    foreach (Customer customer in
        customers.Where(c => c.FirstName.StartsWith("В")))
    {
        Console.WriteLine(customer.FirstName);
    }
}

В этом примере используется отложенный запрос LINQ, т.е. запрос к базе данных вызывается не при инициализации переменной customers, а при вызовах циклов foreach. В результате, для этого примера будет создано два запроса к базе данных (при вызове первого и второго циклов), при этом SQL-запрос для второго цикла будет немного отличаться от первого, т.к. в нем будет использоваться инструкция WHERE. Очевидно, что такое решение для данного примера является плохим, логичнее было бы отправить один запрос к базе данных при инициализации переменной customers, а затем уже манипулировать извлеченными данными в коде. Как говорилось в предыдущей статье, для создания не отложенных запросов используются специальные методы LINQ, в частности можно использовать метод ToList():

// ...

var customers = context.Customers.ToList();

// ...

Метод ToList() указывает запросу то, что он должен быть вызван сразу же и полученные данные должны быть преобразованы в коллекцию C#, реализующую интерфейс IList<T>. Теперь запрос к базе данных будет выполнен один раз, а циклы foreach будут манипулировать коллекцией List, а не извлекать каждый раз новые данные.

Указание столбцов, условий и сортировки в запросе

В запросе данных из таблицы вы можете указать порядок сортировки, который будет использован для выборки данных. Для этого используется вспомогательный метод OrderBy(). Ниже показан пример, в котором данные заказчика сортируются по фамилии:

public static void GetAllCustomers()
{
    SampleContext context = new SampleContext();

    var customers = context.Customers
                           .OrderBy(c => c.LastName);

    foreach (Customer c in customers)
        Console.WriteLine(c.LastName + " " + c.FirstName);
}

Приведенный выше код использует LINQ для создания запроса выборки сортированных данных из таблицы, а затем перебирает результаты запроса и отображает имя и фамилию каждого покупателя. После получения коллекции данных через свойство Customers класса контекста, вы можете использовать вспомогательные LINQ-методы OrderBy(), GroupBy() и Join() для сортировки, группировки данных на основе ключа и соединения таблиц. Эти методы будут транслированы на одноименные инструкции языка SQL.

Другой часто определяемой задачей при выборке данных, является их фильтрация на основе определенного условия. В SQL для этих целей используется оператор WHERE, LINQ содержит одноименный метод Where(), с помощью которого можно добавить дополнительное условие для загрузки данных:

var customers = context.Customers
                       .Where(c => c.Age > 25)
                       .OrderBy(c => c.LastName);

В этом запросе мы выбираем всех покупателей старше 25 лет.

До сих пор мы выбирали из базы данных только коллекцию объектов модели, т.е. коллекцию IQueryable<Customer>. Зачастую извлекать все данные не нужно, а нужно извлечь данные только из определенного столбца таблицы, создавая проекцию таблицы. Такой подход позволяет улучшать производительность, когда запрашиваются данные из таблицы, содержащей много столбцов, а в приложении нужно работать только с одним или несколькими столбцами.

Например, мы могли бы захотеть выбирать только фамилии покупателей из таблицы базы данных и отбрасывать всю другую информацию. Для этих целей в LINQ используется метод Select(), которому передается делегат, в котором выбираются нужные свойства модели. Этот метод возвращает уже не коллекцию объектов Customer, а коллекцию простых типов, например, для фамилий он вернет тип IQueryable<string>. Ниже показан соответствующий пример:

public static void GetAllCustomers()
{
    SampleContext context = new SampleContext();

    var names = context.Customers
                       .OrderBy(c => c.LastName)
                       .Select(c => c.LastName);

    foreach (string lastname in names)
        Console.WriteLine(lastname);
}

Этот запрос транслируется в следующий SQL-код:

SELECT 
    [Extent1].[LastName] AS [LastName]
    FROM [dbo].[Customers] AS [Extent1]
    ORDER BY [Extent1].[LastName] ASC

Здесь видно, что из таблицы будут выбираться данные только фамилии покупателей (столбец LastName указывается после инструкции SELECT). На рисунке ниже наглядно показано, какие данные выбирает этот запрос:

Загрузка данных из одного столбца таблицы с помощью Entity Framework

Зачастую бывает нужно выбрать несколько столбцов из таблицы базы данных. Тогда возникает вопрос, коллекцию каких типов нужно вернуть для такой выборки? Тип Customer не подходит для этих целей, как и простые типы, ведь столбцы могут содержать строки, числа, даты и т.д. Для этих целей используются анонимные объекты C#, которые указываются в методе Select(). Ниже показан пример для выборки данных двух столбцов – FirstName и LastName:

var names = context.Customers
                   .OrderBy(c => c.LastName)
                   .Select(c => new
                   {
                        fname = c.FirstName,
                        lname = c.LastName
                   });

foreach (var name in names)
     Console.WriteLine(name.lname + " " + name.fname);

В этом примере мы указываем методу Select() анонимный объект с двумя свойствами – lname и fname. При перечислении коллекции объектов анонимного типа в цикле foreach, мы используем ключевое слово var языка C#, которое указывает, что компилятор должен динамически определить тип объекта. Это единственный способ сослаться на анонимный объект в цикле. На рисунке ниже показано, какие столбцы мы выберем таким образом:

Загрузка данных из нескольких столбцов таблицы с помощью Entity Framework

В нашем примере мы загружаем данные имен и фамилий в анонимный объект. Иногда бывает необходимо загрузить данные в объект модели, инициализировав только некоторые его свойства. В контексте нашего примера это означает, что мы могли бы создать коллекцию объектов Customers, в которую загрузили бы из базы данных всех пользователей, указав только два свойства FirstName и LastName. Для этих целей вы могли бы предположить, что нужно написать следующий пример:

var customers = context.Customers
                       .OrderBy(c => c.LastName)
                       .Select(c => new Customer
                       {
                            FirstName = c.FirstName,
                            LastName = c.LastName
                       });

foreach (Customer c in customers)
     Console.WriteLine(c.LastName + " " + c.FirstName);

Если вы запустите этот пример, то в приложении возникнет исключение NotSupportedException, в котором говорится, что Entity Framework не может использовать сложный тип Customer с запросом LINQ to Entities. Для этих целей вы должны сначала загрузить коллекцию анонимных объектов, которая инициализируется из базы данных, а затем создать коллекцию объектов Customer, которая инициализируется из коллекции анонимных объектов. Эту задачу можно выполнить в одном запросе, функционально разделив сложный запрос на две части – первая будет использоваться Entity Framework для извлечения данных из базы, вторая будет работать в памяти приложения и инициализировать коллекцию объектов Customer. В качестве разделителя нужно использовать метод AsEnumerable():

IEnumerable<Customer> customers = context.Customers
          .OrderBy(c => c.LastName)
          .Select(c => new
          {
              fname = c.FirstName,
              lname = c.LastName
          })
          // Разделит запрос
          .AsEnumerable()
          // Этот метод Select выполняется на коллекции объектов,
          // а не в базе данных
          .Select(an => new Customer
          {
              FirstName = an.fname,
              LastName = an.lname
          });

foreach (Customer c in customers)
    Console.WriteLine(c.LastName + " " + c.FirstName);

Метод AsEnumerable() в LINQ просто преобразует коллекцию IQueryable к IEnumerable. В простых приложениях, работающих с коллекциями данный метод практически не используется, т.к. в нем нет смысла – интерфейс IQueryable является производным от интерфейса IEnumerable. Но этот метод оказывает существенное влияние при использовании с Entity Framework, указывая, что цепочку методов в запросе до его вызова нужно выполнить, отправив запрос к базе данных, а последующие методы будут оперировать уже на коллекции в памяти приложения. Если вы запустите этот пример, то можете убедиться в его работоспособности.

Поиск в запросе

Пока вы видели запросы, которые возвращают коллекцию объектов из базы данных, но иногда нужно чтобы запрос возвращал один объект. Наиболее распространенным сценарием для запросов, возвращающих один объект, является поиск определенного объекта с заданным ключом. DbContext API позволяет делать это очень просто, используя метод Find() класса DbSet. Этот метод принимает значение, которое нужно найти в таблице и возвращает соответствующий объект, если он найден, или null если не найден.

Поиск в запросе в Entity Framework использует следующую последовательность:

  1. Сначала выполняется поиск в коллекции объектов, уже загруженных из базы данных в память приложения.

  2. Если к коллекции добавлялись новые объекты, то поиск выполняется и в них.

  3. Выполняется поиск в базе данных в объектах, которые еще не были загружены в память приложения.

Чтобы увидеть реализацию поиска, давайте добавим новый метод FindCustomer() в котором мы будем принимать идентификатор покупателя от пользователя, путем ввода его в консоль и затем будем искать покупателя с соответствующим идентификатором в базе данных:

public static void FindCustomer()
{
    Console.Write("Введите CustomerId: ");
    var id = int.Parse(Console.ReadLine());

    SampleContext context = new SampleContext();

    Customer customer = context.Customers.Find(id);

    if (customer != null)
        Console.WriteLine("{0} {1}",
            customer.FirstName, customer.LastName);
    else
        Console.WriteLine("Не найден");
}

Метод Find() осуществляет поиск по первичному ключу таблицы. Как вы знаете, первичные ключи бывают составными, поэтому методу Find() можно передать несколько значений, для поиска в ключах, при этом эти значения должны следовать в том же порядке, в котором свойства первичных ключей определены в классе модели. Напомню, что в Code-First для этого используется атрибут аннотаций данных Column, с переданным ему параметром Order, либо метод HasColumnOrder(), если вы используете для настроек Fluent API.

Если вам нужно выполнить поиск в обычных столбцах, не являющихся ключами таблицы, то для этого можно использовать условие через метод Where(). Например, если мы хотим найти всех покупателей, чья фамилия начинается на русскую букву “В”, то можем использовать следующий запрос:

var customers = context.Customers
    .Where(c => c.LastName.StartsWith("В"));

foreach (Customer c in customers)
    Console.WriteLine(c.LastName);

Локальные данные

Во всех предыдущих примерах мы использовали запрос к свойству класса контекста типа DbSet (context.Customers). Как говорилось ранее, использование этого свойства приводит к созданию запроса к базе для выборки всех данных из привязанной таблицы. Мы также использовали метод Find(), который ищет в памяти приложения данные до создания запроса к этой базе данных, в уже загруженных ранее данных.

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

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

// Загрузить данные не отложено из базы
var customers = context.Customers.ToList();

// Добавить нового покупателя в коллекцию Customers,
// предварительно не сохранив эти данные в базе
context.Customers.Add(new Customer
{
    FirstName = "Петр",
    LastName = "Сидоров",
    Age = 28
});

foreach (Customer c in customers)
    Console.WriteLine(c.LastName);

Здесь, при перечислении данных покупателей, новый добавленный покупатель не будет отображаться в списке.

Entity Framework позволяет хранить локальные данные для объектов DbSet, определяя свойство Local в этом классе. Это свойство вернет все данные, которые были загружены из базы данных плюс любые добавленные новые данные в приложении. Данные, которые были помечены в приложении как удаленные, но при этом еще не удаленные из базы данных, также будут фильтроваться в запросе.

Давайте начнем с очень простой задачи и определим, сколько на текущий момент находится объектов в памяти приложения:

public static void GetLocalCustomersCount()
{
    SampleContext context = new SampleContext();

    int count = context.Customers.Local.Count;
    Console.WriteLine("Объектов Customer в памяти {0}", count);
}

Этот метод позволяет проверить, сколько объектов Customer на данный момент находятся в памяти приложения. Если вы запустите приложение с вызовом этого метода, вы увидите, что количество объектов равно нулю. Мы получаем нулевой результат, потому что мы не выполняем никаких запросов, чтобы загрузить покупателей из базы данных, и мы не добавляли новые объекты Customer в коде. Давайте немного изменим этот метод, и запросим некоторые данные из базы:

public static void GetLocalCustomersCount()
{
    SampleContext context = new SampleContext();

    foreach (Customer c in context.Customers)
        Console.WriteLine(c.LastName);

    int count = context.Customers.Local.Count;
    Console.WriteLine("Объектов Customer в памяти {0}", count);
}

У меня в базе данных находится три заказчика, поэтому данный пример вернет следующий результат:

Загрузка объектов из памяти приложения Entity Framework

Перебор содержимого DbSet в цикле по каждому элементу является одним из способов, чтобы получить все данные из памяти приложения, но это немного неэффективно, чтобы каждый раз выполнять цикл просто ради загрузки данных. К счастью, DbContext API включает специальный метод Load() в классе DbSet, который можно вызвать для ручного запуска процесса загрузки данных из базы. Ниже показано использование этого метода (не забудьте указать пространство имен System.Data.Entity):

public static void GetLocalCustomersCount()
{
    SampleContext context = new SampleContext();

    context.Customers.Load();

    int count = context.Customers.Local.Count;
    Console.WriteLine("Объектов Customer в памяти {0}", count);
}

Этот код гораздо лаконичнее, чем тот, что мы использовали ранее. В сборке System.Data.Entity определен также расширяющий IQueryable<T> метод Load(), поэтому мы можем использовать его не только для загрузки всех данных из таблицы, но также использовать LINQ-методы для сужения выборки. Например, следующий запрос посчитает, сколько находится в памяти объектов Customer, чей возраст превышает 25 лет:

public static void GetLocalCustomersCount()
{
    SampleContext context = new SampleContext();

    context.Customers.Where(c => c.Age > 25).Load();

    int count = context.Customers.Local.Count;
    Console.WriteLine("Объектов Customer в памяти {0}", count);
}

В предыдущих примерах мы подсчитывали количество записей, хранящихся в памяти веб-приложения для определенного типа. Вы также можете манипулировать этими данными, используя различные методы LINQ. Как вы понимаете, эти изменения никак не отображаются на базе данных, т.е. вы фактически не работаете с Entity Framework, а работаете с простыми коллекциями C#. В примере ниже мы загружаем данные из базы в одном месте, а затем создаем несколько запросов, которые манипулируют данными уже в памяти приложения:

public static void LocalLinqQueryies()
{
    SampleContext context = new SampleContext();

    // В этом месте происходит загрузка данных из базы
    context.Customers.Load();


    var sortedCustomers = context.Customers.Local
        .OrderBy(c => c.LastName);

    Console.WriteLine("Все пользователи: ");
    foreach (Customer c in sortedCustomers)
        Console.WriteLine(c.LastName);


    var customers25 = context.Customers.Local
        .Where(c => c.Age > 25);

    Console.WriteLine("\nТолько те, кому за 25: ");
    foreach (Customer c in customers25)
        Console.WriteLine(c.LastName);
}

Этот код загружает всех пользователей в память приложения, а затем манипулирует полученными данными без запросов к базе, тем самым не создавая лишних запросов. Фактически, после загрузки данных в память мы больше не работаем с LINQ to Entities, а работаем с LINQ to Objects. Это два разных поставщика LINQ. При создании запросов к DbSet мы неявно используем LINQ to Entities, который специфичен для Entity Framework и использует модель и отображение, чтобы превратить ваш запрос в SQL. При использовании LINQ to Objects мы выполняем аналогичные операции с коллекциями в памяти приложения, используя среду .NET. Одинаковый синтаксис запроса может возвращать разные результаты в зависимости от поставщика которой вы используете. Например, база данных при сравнении строк не учитывает регистр символов, в то время как в приложении .NET используется регистрозависимое сравнение строк (если его явно не отключить).

Использование особенностей коллекции ObservableCollection

Если вы смотрели примеры использования локальных данных довольно внимательно, то должны были увидеть, что свойство Local возвращает специальный тип обобщенной коллекции ObservableCollection. Этот тип коллекции позволяет получать уведомления, когда добавляются или удаляются элементы из коллекции. Коллекция ObservableCollection полезна в ряде сценариев, работающих с привязкой данных. Например, мы ее использовали при рассмотрении WPF в статье “Привязка к коллекции объектов”, чтобы изменять графический интерфейс приложения, когда добавлялись данные.

Эта коллекция имеет событие CollectionChanged, в обработчике которого мы можем вносить полезные действия. В контексте локальных данных Entity Framework это событие возникает когда мы загружаем или удаляем данные из базы, работаем с данными в памяти приложения или добавляем новые объекты в DbContext. Ниже показан пример:

public static void LocalLinqQueryies()
{
    SampleContext context = new SampleContext();

    context.Customers.Local
        .CollectionChanged += (sender, args) =>
        {
            if (args.NewItems != null)
            {
                foreach (Customer c in args.NewItems)
                {
                    Console.WriteLine("Добавлен: " + c.FirstName);
                }
            }
            if (args.OldItems != null)
            {
                foreach (Customer c in args.OldItems)
                {
                    Console.WriteLine("Удален: " + c.FirstName);
                }
            }
        };
        
    context.Customers.Load();
}

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

Обработка событий изменения локальных данных в Entity Framework

Использование такого типа коллекций может упростить работу с Entity Framework в приложениях, которые работают с привязкой данных, например, в приложениях WPF.

Пройди тесты
x

Чат для изучающих C# Подписывайтесь!