Code first entity framework c

Code first entity framework c

Данное руководство устарело. Актуальное руководство: Руководство по Entity Framework Core

Чтобы непосредственно начать работать с Entity Framework, создадим первое приложение. Для этого нам нужна будет, во-первых, среда разработки. В качестве среды разработки выберем Visual Studio 2017.

Теперь первым делом добавим новый класс, который будет описывать данные. Пусть наше приложение будет посвящено работе с пользователями. Поэтому добавим в проект новый класс User:

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

Надо отметить, что Entity Framework при работе с Code First требует определения ключа элемента для создания первичного ключа в таблице в бд. По умолчанию при генерации бд EF в качестве первичных ключей будет рассматривать свойства с именами Id или [Имя_класса]Id (то есть UserId). Если же мы хотим назвать ключевое свойство иначе, то нам нужно будет внести дополнительную логику на c#.

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

Затем в появившемся окне управления NuGet-пакетами в окне поиска введем слово «Entity» и выберем пакет собственно Entity Framework и установим его:

После установки пакета добавим в проект новый класс UserContext:

Основу функциональности Entity Framework составляют классы, находящиеся в пространстве имен System.Data.Entity. Среди всего набора классов этого пространства имен следует выделить следующие:

DbContext : определяет контекст данных, используемый для взаимодействия с базой данных.

DbModelBuilder : сопоставляет классы на языке C# с сущностями в базе данных.

DbSet/DbSet : представляет набор сущностей, хранящихся в базе данных

В любом приложении, работающим с БД через Entity Framework, нам нужен будет контекст (класс производный от DbContext) и набор данных DbSet, через который мы сможем взаимодействовать с таблицами из БД. В данном случае таким контекстом является класс UserContext.

Содержимое файла в каждом конкретном случае может отличаться. Но в любом случае после добавления EntityFramework в проект в нем будет содержаться элемент configSections. И после закрывающего тега добавим следующий элемент:

Теперь перейдем к файлу Program.cs и изменим его содержание следующим образом:

В конструкции using создаются два объекта User и добавляются в базу данных. Для их сохранения нам достаточно использовать метод Add : db.Users.Add(user1)

Чтобы получить список данных из бд, достаточно воспользоваться свойством Users контекста данных: db.Users

В результате после запуска программа выведет на консоль:

Таким образом, Entity Framework обеспечивает простое и удобное управление объектами из базы данных. При том в данном случае нам не надо даже создавать базу данных и определять в ней таблицы. Entity Framework все сделает за нас на основе определения класса контекста данных и классов моделей. И если база данных уже имеется, то EF не будет повторно создавать ее.

Источник

Entity Framework Code First на практике

В этой публикации хочу поделиться личным опытом использования Entity Framework (EF) в реальном приложении и дать несколько полезных советов использования данного фреймворка.

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

Первое, что нужно сделать, если у вас уже есть готовая база данных — это создать классы, которые бы соответствовали таблицам. Вручную это делать очень утомительно, поэтому:

Совет №1. Генерация класса на основе таблицы

Cкрипт T-SQL, который можно взять отсюда, реально работает и очень удобен.

Совет №2. Прегенерация view

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

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

Совет №3. Массовое обновление данных с помощью DetectChanges

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

Запустив его, многие наверняка будут удивлены, что основное время будет потрачено не собственно на запрос к базе данных, а на вставку объектов в сам dbContext. Дело в том, что при изменении данных внутри DbContext-а происходит масса проверок и других малоизученных вещей, подробнее о которых можно прочесть здесь. Чтобы этого избежать можно отключить слежение за изменениями в классе DbContext, а затем явно вызвать метод DetectChanges(), который сам эти изменения обнаружит. Так, данный код будет работать значительно быстрее:

Совет №4. Следите за sql-запросами, которые формирует фреймворк

Это довольно универсальный совет, применимый, наверное, ко всем ORM, но многие почему-то о нем забывают. И после внедрения приложения, открыв профайлер и увидев 50 запросов к БД для показа довольно простой формы, бывают крайне удивлены.

Между тем, фреймворк предлагает механизмы для некоторой оптимизации. Среди этих механизмов наиболее известный — метод Include, который «вытягивает» дочерние объекты в том же запросе. Например:

Совет №5. Изолируйте логику работы с базой данных

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

Проблема этого кода в том, что он плотно привязывает все части приложения к Entity Framework. Это не хорошо и не плохо само по себе, но при этом вы должны понимать, что существенно осложняете себе жизнь, если архитектуру доступа к данным придется менять. А вариантов тут может быть масса:

Этот подход хорош тем, что ваше приложение будет знать только о ваших объектах и о том, как их можно получить из БД и как сохранить в БД. Поверьте, этим вы существенно облегчите себе жизнь.

Источник

Соглашения Code First

Вы можете дополнительно настроить модель с помощью заметок к данным или свободного API. Приоритет предоставляется для настройки с помощью свободного API, за которым следуют заметки к данным, а затем соглашения. Дополнительные сведения см. в заметках к данным, API Fluent — связи, API Fluent — типы & и API Fluent с VB.NET.

Подробный список соглашений Code First доступен в документации по API. В этом разделе представлен обзор соглашений, используемых Code First.

Обнаружение типов

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

В следующем примере для класса SchoolEntities (Departments) определено только одно свойство DbSet. Code First использует это свойство для обнаружения и извлечения любых ссылочных типов.

Если вы хотите исключить тип из модели, используйте атрибут NotMapped или API DbModelBuilder.Ignore fluent API.

Соглашение о первичном ключе

Code First определяет, что свойство является первичным ключом, если свойство класса имеет имя ID (без учета регистра) или имя класса, за которым следует «ID». Если тип свойства первичного ключа является числовым или GUID, он будет настроен как столбец идентификаторов.

Соглашение о связях

В Entity Framework свойства навигации обеспечивают возможность навигации по связям между двумя типами сущностей. Каждый объект может обладать свойством навигации для каждого отношения, в котором участвует. Свойства навигации позволяют перемещаться по связям в обоих направлениях и управлять ими, возвращая ссылочный объект (если кратность равна одному или нулю или одному) или коллекции (если кратность имеет много). Code First определяет связи на основе свойств навигации, определенных для типов.

Помимо свойств навигации рекомендуется включить свойства внешнего ключа для типов, представляющих зависимые объекты. Любое свойство с тем же типом данных, что и свойство основного первичного ключа и с именем, следующим за одним из следующих форматов, представляет внешний ключ для связи: » > основного класса имени> свойства основного первичного ключа». Если найдено несколько совпадений, приоритет будет указан в указанном выше порядке. Обнаружение внешнего ключа не учитывает регистр. При обнаружении свойства внешнего ключа Code First определяет кратность связи на основе допустимости null внешнего ключа. Если свойство допускает значение NULL, то связь регистрируется как необязательная; в противном случае связь регистрируется по мере необходимости.

Если внешний ключ для зависимой сущности не допускает значения NULL, code First устанавливает каскадное удаление для связи. Если внешний ключ для зависимой сущности допускает значение NULL, Code First не устанавливает каскадное удаление для связи, а когда субъект удаляется, внешний ключ будет иметь значение NULL. Поведение кратности и каскадного удаления, обнаруженные соглашением, можно переопределить с помощью свободного API.

В следующем примере свойства навигации и внешний ключ используются для определения связи между классами Department и Course.

Соглашение о сложных типах

Когда Code First обнаруживает определение класса, в котором не удается вывести первичный ключ, и первичный ключ не регистрируется с помощью заметок к данным или свободного API, тип автоматически регистрируется как сложный тип. Для обнаружения сложных типов также требуется, чтобы тип не имеет свойств, ссылающихся на типы сущностей и не ссылающихся на него из свойства коллекции другого типа. Учитывая следующие определения классов Code First, выявит, что Details является сложным типом, так как он не имеет первичного ключа.

Соглашение о строке подключения

Чтобы узнать о соглашениях, используемых DbContext для обнаружения подключения, см. статью «Подключения и модели».

Удаление соглашений

Вы можете удалить любые соглашения, определенные в пространстве имен System.Data.Entity.ModelConfiguration.Conventions. В следующем примере удаляется PluralizingTableNameConvention.

Настраиваемые соглашения

Пользовательские соглашения поддерживаются в EF6 и более поздних версиях. Дополнительные сведения см. в разделе «Пользовательские соглашения о первом коде».

Источник

Использование Code-First

В предыдущей статье мы кратко рассмотрели структуру различных подходов для работы с Entity Framework. В этой статье мы более подробно остановимся на подходе Code-First и рассмотрим примеры работы с Code-First. Мы создадим две таблицы, описывающие данные заказчика в интернет магазине и его заказами. Отношение между этими таблицами будет “один ко многим” (one-to-many).

Создание проекта

Во всех статьях на нашем сайте, которые посвящены описанию Entity Framework, мы используем проект простого веб-приложения ASP.NET. В этом разделе мы покажем как создать этот проект, а позже будем ссылаться на эту статью, чтобы каждый раз не описывать одни и те же шаги:

Запустите Visual Studio 2012 (в примерах всех статей мы будем использовать версию Visual Studio 2012 в сочетании с Entity Framework 6).

Добавьте в решение проект, имеющий шаблон библиотеки классов (Class Library) и назовите его CodeFirst:

Добавьте в новый проект файл класса Model.cs, в котором мы будем описывать модель данных.

Добавьте ссылку на проект CodeFirst в базовом проекте веб-приложения. Для этого щелкните правой кнопкой мыши по вкладке References в окне Solution Explorer базового проекта и выберите пункт Add Reference. В открывшемся диалоговом окне перейдите на вкладку Solution и выберите проект CodeFirst.

Определение классов модели

Как вы уже знаете, при использовании подхода Code-First сначала определяется модель в коде, а затем, на ее основе создается (или модифицируется) база данных. Для нашего примера потребуется создать два класса, описывающих заказчика и его товары. Эти классы добавляются в файл Model.cs, созданный в предыдущем разделе:

Класс Order содержит идентификатор заказа, который позволяет уникальным образом распознать каждый заказ в таблице. Кроме того этот класс содержит свойства, описывающие название товара, его количество, описание и дату заказа. Также здесь указана ссылка на покупателя в виде свойства Customer.

Установка Entity Framework 6 в проект

Всякий раз, когда вам впервые понадобится использовать Entity Framework в проекте при подходе Code-First, вы должны будете добавить ссылки на библиотеки EF, после чего можно будет работать с Entity Framework в коде. Используйте для этого следующие шаги:

Начиная с версии 4, библиотека Entity Framework входит в удобный менеджер пакетов NuGet. Чтобы добавить поддержку в Entity Framework с помощью NuGet, выберите в окне Solution Explorer проект CodeFirst, щелкните по нему правой кнопкой мыши и выполните команду из контекстного меню Manage Nuget Packages.

После этого появится окно с описанием лицензии на использование Entity Framework. Согласитесь с условиями и на жмите кнопку “I accept”, после чего NuGet установит в ваш проект Entity Framewrok.

Повторите эти действия без 4 пункта для установки Entity Framework в проект ASP.NET.

Класс контекста данных

Сами по себе классы модели, созданные ранее, не имеют ничего общего с Entity Framework. На данном этапе они просто описывают структуру бизнес-модели, которая используется в приложении. Чтобы Entity Framework был в курсе, что эти классы служат также для управления данными в базе данных, нужно использовать класс контекста. EF имеет два базовых класса контекста:

ObjectContext

Этот класс является более общим классом контекста данных, и используется начиная с самых ранних версий Entity Framework.

DbContext

Этот класс контекста данных появился в Entity Framework 4.1 и он обеспечивает поддержку подхода Code-First (ObjectContext также обеспечивает работу подхода Code-First, но он труднее в использовании). Далее мы будем использовать DbContext.

Для создания класса контекста добавьте следующий новый класс SampleContext в проект CodeFirst:

Этот небольшой класс контекста представляет полный слой данных, который можно использовать в приложениях. Благодаря DbContext, вы сможете запросить, изменить, удалить или вставить значения в базу данных. Обратите внимание на использование конструктора в этом классе с вызовом конструктора базового класса DbContext и передачей ему строкового параметра. В этом параметре указывается либо имя базы данных либо строка подключения к базе данных (Entity Framework достаточно интеллектуален чтобы отличить тип параметра). В данном случае мы указываем явно имя базы данных, т.к. по умолчанию, при генерации базы данных Entity Framework использует имя приложения и контекста данных (например CodeFirst.SampleContext), которое нам не подходит.

После этого скомпилируйте приложение (горячая клавиша F6 ), чтобы исключить наличие ошибок на данном этапе.

Работа с данными

В данный момент у вас уже есть классы данных и контекста, необходимые для работы с базой данных, которая еще не существует. Простое создание этих классов не приводит к автоматическому созданию (изменению) базы данных при запуске приложения. Чтобы создать базу данных, нужно добавить код работы с данными с помощью Entity Framework, например, написать код вставки данных в таблицу. Имея это в виду, ниже описаны шаги, с помощью которых мы добавим веб-форму в наш проект в которой будем взаимодействовать с базой данных:

Измените разметку формы на ту, которая показана в примере ниже:

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

Теперь нужно добавить в файл отделенного кода веб-формы Default.aspx.cs обработку данных формы:

В этом коде мы используем механизм привязки моделей ASP.NET – очень удобного средства, пришедшего из ASP.NET MVC. Поле Photo хранит массив двоичных данных файла и для него привязка не работает, поэтому картинку в виде двоичного объекта мы загружаем вручную. Мы специально усложнили пример, добавив поле типа byte[], чтобы показать широкие возможности Entity Framework по поддержке работы с базами данных (в частности в этом случае поле Photo будет проецироваться в базе данных на объект BLOB (Binary Large OBject), имеющий тип VARBINARY(max)).

Код работы с Entity Framework в этом примере создает объект контекста SampleContext и использует его, чтобы добавить новые данные в таблицу Customers. Вызов метода SaveChanges() сохраняет изменения в базе данных и при первой вставке данных вызов SaveChanges() создаст базу данных.

Запустите это приложение, введите данные в форму и нажмите кнопку “Вставить в БД”:

После отправки формы вы можете повторить действия и вставить новых заказчиков. Обратите внимание, что при первой отправке возникает заметная задержка в ответе от сервера – именно в данной точке и создается база данных. Когда вы отправляете форму второй раз, эта задержка исчезает, т.к. данные вставляются в уже существующую базу данных.

Соглашения о конфигурации сгенерированной базы данных

После проделанных действий особый интерес вызывает структура сгенерированной базы данных. Чтобы проверить, что код выполнился правильно, откройте окно Server Explorer в Visual Studio, нажмите на кнопке Connect to Database, в открывшемся окне выберите поставщик SQL Server и настройте подключение к созданной базе данных MyShop, используя имя сервера “.\SQLEXPRESS” в окне Add Connection. После этого в окне Server Explorer отобразится новое подключение:

Обратив пристальный взгляд на структуру таблиц, вы сможете увидеть некоторые соглашения о проецировании сущностных классов, которые используются в Code-First. Например, свойства CustomerId и OrderId в сущностном классе Entity Framework преобразовал в первичные ключи в базе данных (EF автоматически ищет подстроку “Id” в именах свойств модели с помощью механизма рефлексии). Эти поля используют автоинкремент с помощью инструкции IDENTITY (1,1) и не могут иметь значение NULL.

в Entity Framework позволяют организовать взаимодействие между таблицами базами данных. Как вы уже видели, чтобы в родительском классе сослаться на другой связанный класс, навигационное свойство помечается как виртуальное. В Code-First есть также различные свойства для реализации отношений 0..1-1, 1-1 и many-to-many в таблицах, с которыми мы познакомимся позже, при подробном изучении аспектов Entity Framework.

Обратите внимание также на то, что Entity Framework сгенерировал еще одну таблицу с названием __MigrationHistory. Эта таблица хранит различные версии изменения структуры базы данных. В частности, в поле Model эта таблица хранит метаданные модели, представленные в виде двоичного объекта BLOB. Если позже вы измените модель в своем коде, Entity Framework вставит в эту таблицу новую запись, с метаданными новой модели.

Переопределение соглашений о конфигурации базы данных

Все указанные в предыдущем разделе соглашения можно переопределить с помощью средств Entity Framework. Для этого используются аннотации в виде атрибутов C# или строгая типизация с помощью Fluent API.

Использование аннотаций метаданных

Аннотации метаданных являются простейшей формой конфигурации и применяются непосредственно к классам и свойствам класса в виде атрибутов. Эти атрибуты доступны в приложении при наличии ссылок на сборки System.ComponentModel.DataAnnotations.dll и EntityFramework.dll. Помните, что аннотации позволяют простым образом настраивать конфигурацию Entity Framework, но при этом, с помощью аннотаций нельзя настроить некоторые сложные моменты, для которых используется Fluent API.

Как уже было сказано выше, аннотации используют синтаксис атрибутов языка C# или Visual Basic. В случае если вы не знакомы с использованием атрибутов, в C#, атрибуты применяются с использованием квадратных скобок. Например, аннотация данных для идентификации ключа в C# описывается как:

а в Visual Basic, используются угловые скобки:

В атрибутах может использоваться именованный параметр, в C# это выражается с помощью знака равенства:

в то время как Visual Basic использует двоеточие перед знаком равенства:

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

Поле Name не должно иметь значение NULL в таблице базы данных и длина поля не должна превышать 30 символов.

Максимальная длина поля email не должна превышать 100 символов.

Поле Age должно находиться в пределах от 8 до 100.

Фотография должна хранится в типе изображения Image SQL Server, а не в VARBINARY (max).

Для этого сначала нужно добавить ссылки на пространства имен System.ComponentModel.DataAnnotations и System.ComponentModel.DataAnnotations.Schema в файле Model.cs приложения CodeFirst. После этого измените структуру класса Customer, чтобы указать условия, приведенные выше:

Атрибут Required не нуждается в указании дополнительных параметров, в то время, как в атрибутах MaxLength, Range и Column эти параметры указаны. Атрибут Column влияет на схему базы данных (в частности позволяет менять тип данных столбца таблицы). Поэтому данный атрибут находится в пространстве имен System.ComponentModel.DataAnnotations.Schema, в отличие от других атрибутов. Аннотации являются компонуемыми, это означает, что вы можете использовать несколько атрибутов к одному свойству или классу, как это было сделано для свойства Name.

Помимо атрибутов, которые могут влиять на структуру базы данных, в пространстве имен System.ComponentModel.DataAnnotations существует атрибуты, которые Entity Framework просто игнорирует (атрибут Range, показанный выше, не влияет на структуру таблицы). Например, к типу Name можно использовать атрибут [MinLegth(3)], чтобы нельзя было указать в качестве имени покупателя строку, короче 3 символов. В T-SQL нельзя напрямую указать минимальную длину поля (хотя существует обходное решение с использованием инструкции CASE), поэтому Entity Framework будет игнорировать этот атрибут. Это показывает, что атрибуты метаданных, являются универсальными и могут использовать не только Entity Framework. Например, атрибуты MinLegth и Range могут использоваться в клиент-серверном коде проверки модели ASP.NET.

После того, как мы внесли изменения в модель данных, будет интересно как Enity Framework изменит структуру базы данных. Если вы теперь запустите приложение и попытаетесь вставить нового заказчика, то вы получите исключение InvalidOperationException. Мы ничего плохого не сделали с моделью данных, проблема заключается в способе инициализации базы данных, используемом в Code-First. Ниже показан текст исключения:

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

Другим решением проблемы, которое мы будем использовать в нашем приложении, является использование возможности Code-First обнаруживать изменения в модели данных и автоматически удалять и генерировать новую базу данных. Поведением Code-First в данной ситуации можно управлять с помощью статического метода SetInitializer() класса Database. По умолчанию, этому методу передается экземпляр класса CreateDatabaseIfNotExists, который указывает, что создавать базу данных нужно только в том случае, если базы данных не существует, а если модель изменилась, то нужно сгенерировать исключение.

Давайте изменим это поведение и передадим этому методу экземпляр объекта DropCreateDatabaseIfModelChanges, который указывает Code-First, что при изменении модели данных, базу данных нужно будет удалить и воссоздать с новой структурой. Метод SetInitializer() должен вызываться до непосредственной работы с Entity Framework, в нашем случае мы можем вызвать его в начале метода Page_Load:

Теперь, когда вы запустите приложение и попытаетесь вставить данные, Code First найдет разницу в новой модели и, с разрешения инициализатора, удалит и заново создаст базу данных. Если вы открыли таблицу базы данных для чтения данных где-то еще (например, в окне Server Explorer среды Visual Studio), Code First будет не в состоянии удалить базу данных, т.к. она используется другим процессом. В этом случае, возникнет заметная задержка при вставке данных, пока EF пытается удалить базу данных, а затем в конце концов будет сгенерировано следующее исключение:

Для решения этой проблемы зачастую хватает закрыть и открыть снова проект в Visual Studio.

Я также рекомендую вам рассмотреть возможность подхода к работе, когда вы вручную изменяете структуру базы данных с помощью T-SQL, а затем отражаете эти изменения в классах модели. Такой подход к работе еще называют Code-Second. Этот подход лишает вас одного из главных преимуществ Code-First – отсутствие непосредственной работы с базой данных, но он является единственной возможностью изменить структуру базы данных не удаляя ее (чтобы не удалять уже вставленные данные).

Допустим, нам нужно изменить структуру таблицы Customer изменив имя столбца Name на FirstName и добавив новый столбец LastName. Чтобы воспользоваться подходом Code-Second выполните следующие шаги:

Используя программу SQL Server Management Studio или окно Server Explorer в Visual Studio удалите таблицу __MigrationHistory.

Выполните следующий SQL-код для изменения структуры таблиц (для этого щелкните правой кнопкой мыши по имени таблицы Customer в окне Server Explorer и выберите из контекстного меню команду New Query):

Обновите модель данных, чтобы отразить эти изменения:

Далее нам понадобится изменить разметку веб-формы и код обработчика, чтобы использовать эти изменения:

В коде обработчика Default.aspx.cs удалите вызов метода SetInitializer().

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

Использование Fluent API

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

Концепция Fluent API заключается в вызове ряда стандартных методов для описания настройки конфигурации базы данных. Использование средства IntelliSense в редакторе кода Visual Studio облегчает использование этих методов. Например, в Code-First Fluent API, вы можете использовать метод Entity(), чтобы выбрать объект для настройки. IntelliSense покажет вам все методы, которые могут быть использованы для настройки объекта. Если вы затем используете метод Property(), чтобы выбрать свойство объекта сущности, то вы увидите все доступные настройки для конфигурирования.

Еще одним преимуществом Fluent API перед аннотациями является то, что он не засоряет код модели и организует взаимосвязь модели с контекстом данных.

Когда приходит время для построения модели, DbContext смотрит на структуру классов модели. Fluent API позволяет вмешаться в этот процесс и передать контексту дополнительные данные для конфигурации. Это становится возможным, благодаря переопределению метода DbContext.OnModelCreating(), который вызывается перед тем, как контекст построит сущностную модель данных. Этот метод является виртуальным, так что вы можете изменить его и вставить собственную логику, используя средства Fluent API.

Структура этого метода следующая:

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

Подходы с использованием аннотаций и Fluent API можно использовать в Code-First, преимущество при указании одинаковых правил отдается Fluent API.

Если у вас используется много настроек конфигурации Fluent API, то код метода OnModelCreating() может быстро стать перегруженным. Можно организовать код настроек Fluent API с помощью создания специальных классов конфигурации, унаследованных от EntityTypeConfiguration. Например, мы добавили следующий файл EntityConfigurations.cs в проект CodeFirst:

Чтобы добавить эту конфигурацию, в вызове OnModelCreating() можно использовать свойство Configurations класса DbModelBuilder:

На этом мы заканчиваем краткое рассмотрение подхода для работы с Code-First, позже, при описании Entity Framework, мы более подробно познакомимся со всеми деталями использования аннотаций данных и Fluent API.

Источник

Code First Conventions

A detailed list of Code First conventions is available in the API Documentation. This topic provides an overview of the conventions used by Code First.

Type Discovery

If your types participate in an inheritance hierarchy, it is enough to define a DbSet property for the base class, and the derived types will be automatically included, if they are in the same assembly as the base class.

In the following example, there is only one DbSet property defined on the SchoolEntities class (Departments). Code First uses this property to discover and pull in any referenced types.

If you want to exclude a type from the model, use the NotMapped attribute or the DbModelBuilder.Ignore fluent API.

Primary Key Convention

Code First infers that a property is a primary key if a property on a class is named “ID” (not case sensitive), or the class name followed by «ID». If the type of the primary key property is numeric or GUID it will be configured as an identity column.

Relationship Convention

In Entity Framework, navigation properties provide a way to navigate a relationship between two entity types. Every object can have a navigation property for every relationship in which it participates. Navigation properties allow you to navigate and manage relationships in both directions, returning either a reference object (if the multiplicity is either one or zero-or-one) or a collection (if the multiplicity is many). Code First infers relationships based on the navigation properties defined on your types.

In addition to navigation properties, we recommend that you include foreign key properties on the types that represent dependent objects. Any property with the same data type as the principal primary key property and with a name that follows one of the following formats represents a foreign key for the relationship: ‘

Источник

Создание базы данных с помощью Code First

Это видео и пошаговое руководство содержат общие сведения о разработке Code First, предназначенной для новой базы данных. Этот сценарий включает в себя нацеливание на базу данных, которая не существует, и Code First создаст или пустую базу данных, в которую Code First добавит новые таблицы. Code First позволяет определить модель с помощью C# или VB.Net классов. При необходимости можно выполнить дополнительную настройку с помощью атрибутов для классов и свойств или с помощью свободного API.

Просмотреть видео

Это видео содержит общие сведения о разработке Code First, предназначенной для новой базы данных. Этот сценарий включает в себя нацеливание на базу данных, которая не существует, и Code First создаст или пустую базу данных, в которую Code First добавит новые таблицы. Code First позволяет определить модель с помощью C# или VB.Net классов. При необходимости можно выполнить дополнительную настройку с помощью атрибутов для классов и свойств или с помощью свободного API.

Предварительные требования

Для выполнения этого пошагового руководства необходимо установить по крайней мере Visual Studio 2010 или Visual Studio 2012.

1. Создание приложения

Чтобы упростить работу, мы создадим базовое консольное приложение, использующее Code First для доступа к данным.

2. Создание модели

Давайте определим очень простую модель с помощью классов. Мы просто определяем их в файле Program.cs, но в реальном приложении вы разделите классы на отдельные файлы и, возможно, отдельный проект.

Под определением класса Program в Program.cs добавьте следующие два класса.

Вы заметите, что мы делаем два свойства навигации (Blog.Posts и Post.Blog) виртуальными. Это позволяет использовать функцию отложенной загрузки Entity Framework. Отложенная загрузка означает, что содержимое этих свойств автоматически загружается из базы данных при попытке доступа к ним.

3. Создание контекста

Теперь пришло время определить производный контекст, представляющий сеанс с базой данных, что позволяет запрашивать и сохранять данные. Мы определяем контекст, производный от System.Data.Entity.DbContext и предоставляющий типизированный dbSet для каждого класса в нашей модели.

Теперь мы начинаем использовать типы из Entity Framework, поэтому необходимо добавить пакет NuGet EntityFramework.

Добавьте оператор using для System.Data.Entity в начало Файла Program.cs.

Под классом Post в Program.cs добавьте следующий производный контекст.

Ниже приведен полный список содержимого Program.cs.

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

4. Чтение & данных записи

Реализуйте метод Main в Файле Program.cs, как показано ниже. Этот код создает новый экземпляр контекста, а затем использует его для вставки нового блога. Затем он использует запрос LINQ для получения всех блогов из базы данных в алфавитном порядке по названию.

Теперь вы можете запустить приложение и протестировать его.

Где мои данные?

По соглашению DbContext создала базу данных для вас.

Это только соглашения по умолчанию, и существуют различные способы изменения базы данных, которые code First использует, дополнительные сведения доступны в разделе «Как DbContext обнаруживает модель и подключение к базе данных «. Вы можете подключиться к этой базе данных с помощью обозревателя серверов в Visual Studio

Представление —> обозреватель серверов

Щелкните правой кнопкой мыши подключения к данным и выберите «Добавить подключение».

Если вы еще не подключились к базе данных из обозревателя серверов, перед тем как выбрать Microsoft SQL Server в качестве источника данных

Подключение к LocalDB или SQL Express в зависимости от установленного экземпляра

Теперь можно проверить схему, созданную code First.

DbContext разработал классы для включения в модель, просмотрев свойства DbSet, которые мы определили. Затем он использует набор соглашений Code First по умолчанию для определения имен таблиц и столбцов, определения типов данных, поиска первичных ключей и т. д. Далее в этом пошаговом руководстве мы рассмотрим, как можно переопределить эти соглашения.

5. Работа с изменениями модели

Теперь пришло время внести некоторые изменения в модель, когда мы внося эти изменения также необходимо обновить схему базы данных. Для этого мы будем использовать функцию с именем Code First Migrations или миграции.

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

Первым шагом является включение Code First Migrations для нашего BloggingContext.

Средства —> диспетчер пакетов библиотеки —> консоль диспетчера пакетов

Запустите команду Enable-Migrations в консоли диспетчера пакетов.

В наш проект добавлена новая папка Migrations, содержащая два элемента:

Теперь давайте внесите изменения в нашу модель, добавьте свойство URL-адреса в класс Blog:

Новый столбец URL-адреса теперь добавляется в таблицу «Блоги» в базе данных:

6. Заметки к данным

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

Новая таблица теперь добавляется в базу данных:

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

7. API Fluent

В предыдущем разделе мы рассмотрели использование заметок к данным для дополнения или переопределения того, что было обнаружено соглашением. Другой способ настройки модели — с помощью API Code First fluent.

Большинство конфигураций модели можно выполнить с помощью простых заметок к данным. Текучий API — это более сложный способ указания конфигурации модели, которая охватывает все, что могут делать заметки к данным, в дополнение к более сложной конфигурации с заметками к данным. Заметки к данным и текучий API можно использовать вместе.

Чтобы получить доступ к свободному API, переопределите метод OnModelCreating в DbContext. Предположим, что мы хотели переименовать столбец, в который хранится User.DisplayName, в display_name.

Теперь столбец DisplayName переименован в display_name:

Сводка

В этом пошаговом руководстве мы рассмотрели разработку Code First с помощью новой базы данных. Мы определили модель с помощью классов, а затем использовали ее для создания базы данных и хранения и извлечения данных. После создания базы данных мы использовали Code First Migrations для изменения схемы по мере развития модели. Мы также узнали, как настроить модель с помощью заметок к данным и API Fluent.

Источник

Code First to a New Database

This video and step-by-step walkthrough provide an introduction to Code First development targeting a new database. This scenario includes targeting a database that doesn’t exist and Code First will create, or an empty database that Code First will add new tables to. Code First allows you to define your model using C# or VB.Net classes. Additional configuration can optionally be performed using attributes on your classes and properties or by using a fluent API.

Watch the video

This video provides an introduction to Code First development targeting a new database. This scenario includes targeting a database that doesn’t exist and Code First will create, or an empty database that Code First will add new tables to. Code First allows you to define your model using C# or VB.Net classes. Additional configuration can optionally be performed using attributes on your classes and properties or by using a fluent API.

Presented By: Rowan Miller

Pre-Requisites

You will need to have at least Visual Studio 2010 or Visual Studio 2012 installed to complete this walkthrough.

If you are using Visual Studio 2010, you will also need to have NuGet installed.

1. Create the Application

To keep things simple we’re going to build a basic console application that uses Code First to perform data access.

2. Create the Model

Let’s define a very simple model using classes. We’re just defining them in the Program.cs file but in a real world application you would split your classes out into separate files and potentially a separate project.

Below the Program class definition in Program.cs add the following two classes.

You’ll notice that we’re making the two navigation properties (Blog.Posts and Post.Blog) virtual. This enables the Lazy Loading feature of Entity Framework. Lazy Loading means that the contents of these properties will be automatically loaded from the database when you try to access them.

3. Create a Context

Now it’s time to define a derived context, which represents a session with the database, allowing us to query and save data. We define a context that derives from System.Data.Entity.DbContext and exposes a typed DbSet for each class in our model.

We’re now starting to use types from the Entity Framework so we need to add the EntityFramework NuGet package.

Add a using statement for System.Data.Entity at the top of Program.cs.

Below the Post class in Program.cs add the following derived context.

Here is a complete listing of what Program.cs should now contain.

That is all the code we need to start storing and retrieving data. Obviously there is quite a bit going on behind the scenes and we’ll take a look at that in a moment but first let’s see it in action.

4. Reading & Writing Data

Implement the Main method in Program.cs as shown below. This code creates a new instance of our context and then uses it to insert a new Blog. Then it uses a LINQ query to retrieve all Blogs from the database ordered alphabetically by Title.

You can now run the application and test it out.

Where’s My Data?

By convention DbContext has created a database for you.

These are just the default conventions and there are various ways to change the database that Code First uses, more information is available in the How DbContext Discovers the Model and Database Connection topic. You can connect to this database using Server Explorer in Visual Studio

Right click on Data Connections and select Add Connection…

If you haven’t connected to a database from Server Explorer before you’ll need to select Microsoft SQL Server as the data source

Connect to either LocalDB or SQL Express, depending on which one you have installed

We can now inspect the schema that Code First created.

DbContext worked out what classes to include in the model by looking at the DbSet properties that we defined. It then uses the default set of Code First conventions to determine table and column names, determine data types, find primary keys, etc. Later in this walkthrough we’ll look at how you can override these conventions.

5. Dealing with Model Changes

Now it’s time to make some changes to our model, when we make these changes we also need to update the database schema. To do this we are going to use a feature called Code First Migrations, or Migrations for short.

Migrations allows us to have an ordered set of steps that describe how to upgrade (and downgrade) our database schema. Each of these steps, known as a migration, contains some code that describes the changes to be applied.В

The first step is to enable Code First Migrations for our BloggingContext.

Run the Enable-Migrations command in Package Manager Console

A new Migrations folder has been added to our project that contains two items:

Now let’s make a change to our model, add a Url property to the Blog class:

The new Url column is now added to the Blogs table in the database:

6. Data Annotations

So far we’ve just let EF discover the model using its default conventions, but there are going to be times when our classes don’t follow the conventions and we need to be able to perform further configuration. There are two options for this; we’ll look at Data Annotations in this section and then the fluent API in the next section.

The new table is now added to the database:

The full list of annotations supported by EF is:

7. Fluent API

In the previous section we looked at using Data Annotations to supplement or override what was detected by convention. The other way to configure the model is via the Code First fluent API.

Most model configuration can be done using simple data annotations. The fluent API is a more advanced way of specifying model configuration that covers everything that data annotations can do in addition to some more advanced configuration not possible with data annotations. Data annotations and the fluent API can be used together.

To access the fluent API you override the OnModelCreating method in DbContext. Let’s say we wanted to rename the column that User.DisplayName is stored in to display_name.

The DisplayName column is now renamed to display_name:

Summary

In this walkthrough we looked at Code First development using a new database. We defined a model using classes then used that model to create a database and store and retrieve data. Once the database was created we used Code First Migrations to change the schema as our model evolved. We also saw how to configure a model using Data Annotations and the Fluent API.

Источник

Code First to an Existing Database

Это пошаговое руководство содержит общие сведения о разработке Code First, предназначенной для существующей базы данных. Code First позволяет определить модель с помощью C# или VB.Net классов. При необходимости можно выполнить дополнительную настройку с помощью атрибутов для классов и свойств или с помощью свободного API.

Предварительные требования

Для выполнения этого пошагового руководства потребуется установить Visual Studio 2012 или Visual Studio 2013.

1. Создание существующей базы данных

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

Давайте создадим базу данных.

Открытие Visual Studio

Представление —> обозреватель серверов

Щелкните правой кнопкой мыши подключения к данным —> добавить подключение.

Если вы еще не подключились к базе данных из обозревателя серверов, перед тем как выбрать Microsoft SQL Server в качестве источника данных

Подключитесь к экземпляру LocalDB и введите blogging в качестве имени базы данных.

Нажмите кнопку «ОК», и вам будет предложено создать новую базу данных, нажмите кнопку «Да«

Новая база данных появится в обозревателе серверов, щелкните ее правой кнопкой мыши и выберите «Создать запрос».

Скопируйте следующий код SQL в новый запрос, а затем щелкните запрос правой кнопкой мыши и выберите «Выполнить».

2. Создание приложения

Чтобы упростить работу, мы создадим базовое консольное приложение, использующее Code First для доступа к данным:

3. Модель реконструирования

Мы будем использовать инструменты Entity Framework для Visual Studio, чтобы помочь нам создать исходный код для сопоставления с базой данных. Эти средства просто создают код, который можно также вводить вручную, если вы предпочитаете.

Проект —> добавление нового элемента.

Выберите «Данные » в меню слева, а затем ADO.NET модель данных сущности

Введите bloggingContext в качестве имени и нажмите кнопку «ОК»

Откроется мастер модели данных сущностей.

Выберите code First из базы данных и нажмите кнопку «Далее»

Выберите подключение к базе данных, созданной в первом разделе, и нажмите кнопку «Далее»

Установите флажок рядом с таблицами, чтобы импортировать все таблицы, и нажмите кнопку «Готово«

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

Файл конфигурации

Файл App.config добавлен в проект, этот файл содержит строку подключения к существующей базе данных.

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

Производный контекст

Классы модели

4. Чтение & данных записи

Теперь можно запустить приложение и протестировать его.

Что делать, если моя база данных изменяется?

Мастер code First to Database предназначен для создания начального набора классов, которые затем можно настроить и изменить. Если схема базы данных изменится, можно вручную изменить классы или выполнить другой реконструирование, чтобы перезаписать классы.

Использование Code First Migrations к существующей базе данных

Если вы хотите использовать Code First Migrations с существующей базой данных, см. Code First Migrations в существующую базу данных.

Сводка

В этом пошаговом руководстве мы рассмотрели разработку Code First с использованием существующей базы данных. Мы использовали инструменты Entity Framework для Visual Studio для реконструирования набора классов, сопоставленных с базой данных, и их можно использовать для хранения и извлечения данных.

Источник

Tutorial: Get Started with Entity Framework 6 Code First using MVC 5

For new development, we recommend ASP.NET Core Razor Pages over ASP.NET MVC controllers and views. For a tutorial series similar to this one using Razor Pages, see Tutorial: Get started with Razor Pages in ASP.NET Core. The new tutorial:

In this series of tutorials, you learn how to build an ASP.NET MVC 5 application that uses Entity Framework 6 for data access. This tutorial uses the Code First workflow. For information about how to choose between Code First, Database First, and Model First, see Create a model.

This tutorial series explains how to build the Contoso University sample application. The sample application is a simple university website. With it, you can view and update student, course, and instructor information. Here are two of the screens you create:

In this tutorial, you:

Prerequisites

Create an MVC web app

Open Visual Studio and create a C# web project using the ASP.NET Web Application (.NET Framework) template. Name the project ContosoUniversity and select OK.

By default, the Authentication option is set to No Authentication. For this tutorial, the web app doesn’t require users to sign in. Also, it doesn’t restrict access based on who’s signed in.

Select OK to create the project.

Set up the site style

A few simple changes will set up the site menu, layout, and home page.

Open Views\Shared\_Layout.cshtml, and make the following changes:

The changes are highlighted in the following code snippet:

In Views\Home\Index.cshtml, replace the contents of the file with the following code to replace the text about ASP.NET and MVC with text about this application:

Press Ctrl+F5 to run the web site. You see the home page with the main menu.

Install Entity Framework 6

From the Tools menu, choose NuGet Package Manager, and then choose Package Manager Console.

In the Package Manager Console window, enter the following command:

This step is one of a few steps that this tutorial has you do manually, but that could have been done automatically by the ASP.NET MVC scaffolding feature. You’re doing them manually so that you can see the steps required to use Entity Framework (EF). You’ll use scaffolding later to create the MVC controller and views. An alternative is to let scaffolding automatically install the EF NuGet package, create the database context class, and create the connection string. When you’re ready to do it that way, all you have to do is skip those steps and scaffold your MVC controller after you create your entity classes.

Create the data model

Next you’ll create entity classes for the Contoso University application. You’ll start with the following three entities:

Course Enrollment Student

Entities	Relationship
Course to Enrollment	One-to-many
Student to Enrollment	One-to-many

There’s a one-to-many relationship between Student and Enrollment entities, and there’s a one-to-many relationship between Course and Enrollment entities. In other words, a student can be enrolled in any number of courses, and a course can have any number of students enrolled in it.

In the following sections, you’ll create a class for each one of these entities.

If you try to compile the project before you finish creating all of these entity classes, you’ll get compiler errors.

The Student entity

In the Models folder, create a class file named Student.cs by right-clicking on the folder in Solution Explorer and choosing Add > Class. Replace the template code with the following code:

The ID property will become the primary key column of the database table that corresponds to this class. By default, Entity Framework interprets a property that’s named ID or classname ID as the primary key.

The Enrollments property is a navigation property. Navigation properties hold other entities that are related to this entity. In this case, the Enrollments property of a Student entity will hold all of the Enrollment entities that are related to that Student entity. In other words, if a given Student row in the database has two related Enrollment rows (rows that contain that student’s primary key value in their StudentID foreign key column), that Student entity’s Enrollments navigation property will contain those two Enrollment entities.

Navigation properties are typically defined as virtual so that they can take advantage of certain Entity Framework functionality such as lazy loading. (Lazy loading will be explained later, in the Reading Related Data tutorial later in this series.)

The Enrollment entity

In the Models folder, create Enrollment.cs and replace the existing code with the following code:

The EnrollmentID property will be the primary key; this entity uses the classname ID pattern instead of ID by itself as you saw in the Student entity. Ordinarily you would choose one pattern and use it throughout your data model. Here, the variation illustrates that you can use either pattern. In a later tutorial, you’ll see how using ID without classname makes it easier to implement inheritance in the data model.

The Grade property is an enum. The question mark after the Grade type declaration indicates that the Grade property is nullable. A grade that’s null is different from a zero grade — null means a grade isn’t known or hasn’t been assigned yet.

Entity Framework interprets a property as a foreign key property if it’s named

Источник

Руководство. Начало работы с Entity Framework 6 Code First с помощью MVC 5

Для новой разработки рекомендуется ASP.NET Core Razor Pages по ASP.NET контроллерам и представлениям MVC. Серия руководств, аналогичная этой, с помощью Razor Pages, см. в руководстве по началу работы с Razor Pages в ASP.NET Core. Новое руководство.

В этой серии руководств вы узнаете, как создать приложение ASP.NET MVC 5, использующее Entity Framework 6 для доступа к данным. В этом руководстве используется рабочий процесс Code First. Сведения о выборе между code First, Database First и Model First см. в разделе «Создание модели».

В этой серии руководств объясняется, как создать пример приложения Contoso University. Пример приложения — это простой веб-сайт университета. С его помощью можно просматривать и обновлять сведения о учащихся, курсах и преподавателях. Вот два экрана, которые вы создаете:

Изучив это руководство, вы:

Предварительные требования

Создание веб-приложения MVC

В новом веб-приложении ASP.NET — ContosoUniversity выберите MVC.

По умолчанию для параметра «Проверка подлинности » задано значение «Нет проверки подлинности«. Для работы с этим руководством веб-приложение не требует входа пользователей. Кроме того, он не ограничивает доступ в зависимости от того, кто выполнил вход.

Чтобы создать проект, щелкните ОК.

Настройка стиля сайта

Выполните незначительную настройку меню, макета и домашней страницы сайта.

Откройте views\Shared\_Layout.cshtml и внесите следующие изменения:

Изменения выделены в следующем фрагменте кода:

В Views\Home\Index.cshtml замените содержимое файла следующим кодом, чтобы заменить текст о ASP.NET и MVC текстом об этом приложении:

Нажмите клавиши CTRL+F5, чтобы запустить веб-сайт. Вы увидите домашнюю страницу с главным меню.

Установка Entity Framework 6

В меню «Сервис» выберите диспетчер пакетов NuGet и выберите консоль диспетчера пакетов.

В окне Консоль диспетчера пакетов введите следующую команду:

Этот шаг является одним из нескольких шагов, выполняемых в этом руководстве вручную, но это можно было бы сделать автоматически с помощью функции формирования шаблонов MVC ASP.NET MVC. Вы выполняете их вручную, чтобы просмотреть шаги, необходимые для использования Entity Framework (EF). Позже вы будете использовать формирование шаблонов для создания контроллера и представлений MVC. Альтернативой является автоматическое установку пакета NuGet EF, создание класса контекста базы данных и создание строки подключения. Когда вы будете готовы сделать это таким образом, все, что вам нужно сделать, это пропустить эти шаги и сформировать шаблон контроллера MVC после создания классов сущностей.

Создание модели данных

Теперь необходимо создать классы сущностей для приложения университета Contoso. Начните со следующих трех сущностей:

Курс Enrollment-Student

Сущности	Связь
Курс регистрации	Один ко многим
Учащийся для регистрации	Один ко многим

В следующих разделах вы создадите класс для каждой из этих сущностей.

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

Сущность Student

В папке Models создайте файл класса с именем Student.cs, щелкнув правой кнопкой мыши папку в Обозреватель решений и выбрав «Добавить>класс«. Замените код шаблона следующим кодом:

Свойство ID будет использоваться в качестве столбца первичного ключа в таблице базы данных, соответствующей этому классу. По умолчанию Entity Framework интерпретирует свойство, именованное ID или имя ID класса, как первичный ключ.

Свойство Enrollments является свойством навигации. Свойства навигации содержат другие сущности, связанные с этой сущностью. В этом случае свойство сущности Student будет содержать все Enrollment сущности, Enrollments связанные с этой Student сущностью. Другими словами, если заданная Student строка в базе данных содержит две связанные Enrollment строки (строки, содержащие значение первичного ключа учащегося в столбце StudentID внешнего ключа), то свойство навигации этой Student сущности Enrollments будет содержать эти две Enrollment сущности.

Сущность Enrollment

В папке Models создайте файл Enrollment.cs и замените существующий код следующим кодом:

Свойство Grade является перечислением. Знак вопроса после объявления типа Grade указывает, что свойство Grade допускает значение NULL. Класс, который имеет значение NULL, отличается от нуля. Значение NULL означает, что оценка не известна или еще не назначена.

Entity Framework интерпретирует свойство как свойство внешнего ключа, если оно называется свойства первичного ключа (например, StudentID для Student свойства навигации, так как Student первичный ключ сущности ). ID Свойства внешнего ключа также можно назвать таким же просто свойства первичного ключа (например, CourseID так как Course первичный ключ сущности имеет значение CourseID ).

Сущность Course

В папке Models создайте Файл Course.cs, заменив код шаблона следующим кодом:

Более подробное описание атрибута DatabaseGeneratedAttribute будет приведено в одном из следующих учебников этой серии. Фактически, этот атрибут позволяет ввести первичный ключ для курса, а не использовать базу данных, чтобы создать его.

Создание контекста базы данных

Чтобы создать папку в проекте ContosoUniversity, щелкните правой кнопкой мыши проект в Обозреватель решений и выберите команду «Добавить» и выберите команду «Создать папку«. Назовите новую папку DAL (для уровня доступа к данным). В этой папке создайте файл класса с именем SchoolContext.cs и замените код шаблона следующим кодом:

Указание наборов сущностей

Этот код создает свойство DbSet для каждого набора сущностей. В терминологии Entity Framework набор сущностей обычно соответствует таблице базы данных, а сущность соответствует строке в таблице.

Вы можете опустить DbSet операторы и DbSet инструкции, и они будут работать одинаково. Entity Framework будет включать их неявно, так как Student сущность ссылается на Enrollment сущность, а Enrollment сущность ссылается на Course сущность.

Указание строки подключения

Имя строки подключения (которую вы добавите в файл Web.config позже) передается конструктору.

Можно также передать саму строку подключения, а не имя той, которая хранится в файле Web.config. Дополнительные сведения о параметрах для указания используемой базы данных см. в строках подключения и моделях.

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

Указание имен сингулярных таблиц

Инициализация базы данных с тестовыми данными

Entity Framework может автоматически создавать (или удалять и повторно создавать) базу данных при запуске приложения. Вы можете указать, что это должно выполняться при каждом запуске приложения или только в том случае, если модель не синхронизирована с существующей базой данных. Вы также можете написать Seed метод, который Entity Framework автоматически вызывает после создания базы данных, чтобы заполнить ее тестовыми данными.

Поведение по умолчанию заключается в создании базы данных только в том случае, если она не существует (и создается исключение, если модель изменилась и база данных уже существует). В этом разделе вы укажете, что база данных должна быть удалена и повторно создана при каждом изменении модели. Удаление базы данных приводит к потере всех данных. Обычно это нормально во время разработки, так как Seed метод будет выполняться при повторном создании базы данных и будет повторно создавать тестовые данные. Но в рабочей среде обычно не требуется терять все данные при каждом изменении схемы базы данных. Далее вы узнаете, как обрабатывать изменения модели с помощью Code First Migrations для изменения схемы базы данных вместо удаления и повторного создания базы данных.

В папке DAL создайте файл класса с именем SchoolInitializer.cs и замените код шаблона следующим кодом, что приводит к созданию базы данных при необходимости и загрузке тестовых данных в новую базу данных.

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

Чтобы указать Entity Framework использовать класс инициализатора, добавьте элемент entityFramework в элемент в файле Web.config приложения (в папке корневого проекта), как показано в следующем примере:

Теперь приложение настроено таким образом, чтобы при первом доступе к базе данных в заданном запуске приложения Entity Framework сравнивала базу данных с моделью (классы сущностей и вашей SchoolContext сущности). Если есть разница, приложение удаляет и повторно создает базу данных.

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

Настройка EF 6 для использования LocalDB

LocalDB — это упрощенная версия ядра СУБД SQL Server Express. Легко установить и настроить, запускать по запросу и запускаться в пользовательском режиме. LocalDB выполняется в специальном режиме выполнения SQL Server Express, что позволяет работать с базами данных в виде MDF-файлов. Файлы базы данных LocalDB можно поместить в папку App_Data веб-проекта, если вы хотите скопировать базу данных с проектом. Функция экземпляра пользователя в SQL Server Express также позволяет работать с MDF-файлами, но функция экземпляра пользователя является устаревшей. Поэтому для работы с MDF-файлами рекомендуется использовать LocalDB. LocalDB устанавливается по умолчанию в Visual Studio.

Как правило, SQL Server Express не используется для рабочих веб-приложений. LocalDB, в частности, не рекомендуется использовать в рабочей среде с веб-приложением, так как он не предназначен для работы со службами IIS.

На самом деле в файлеWeb.config не требуется строка подключения. Если строка подключения не задана, Entity Framework использует строку подключения по умолчанию на основе класса контекста. Дополнительные сведения см. в разделе Code First to a New Database.

Создание контроллера и представлений

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

Щелкните правой кнопкой мыши папку Controllers в Обозреватель решений, выберите «Добавить» и выберите «Создать шаблонный элемент«.

В диалоговом окне «Добавление шаблонов » выберите контроллер MVC 5 с представлениями с помощью Entity Framework и нажмите кнопку «Добавить«.

В диалоговом окне «Добавить контроллер » сделайте следующее, а затем нажмите кнопку «Добавить«.

Класс модели: Student (ContosoUniversity.Models). (Если этот параметр не отображается в раскрывающемся списке, выполните сборку проекта и повторите попытку.)

Класс контекста данных: SchoolContext (ContosoUniversity.DAL).

Имя контроллера: StudentController (не StudentsController).

Оставьте значения по умолчанию для других полей.

Представление Student\Index.cshtml отображает этот список в таблице:

Чтобы запустить проект, нажмите сочетание клавиш CTRL+F5. (Если возникает ошибка «Не удается создать теневое копирование», закройте браузер и повторите попытку.)

Просмотр базы данных

Когда вы запустили страницу «Учащиеся» и приложение попыталось получить доступ к базе данных, EF обнаружила, что база данных не создана и создана. Затем EF выполнил метод начального значения, чтобы заполнить базу данных данными.

Для просмотра базы данных в Visual Studio можно использовать обозреватель серверов или SQL Server обозреватель объектов (SSOX). В этом руководстве вы будете использовать обозреватель серверов.

В обозревателе серверов разверните узел «Подключения к данным» (может потребоваться сначала нажать кнопку обновления), разверните контекст учебного заведения (ContosoUniversity) и разверните «Таблицы «, чтобы просмотреть таблицы в новой базе данных.

Щелкните правой кнопкой мыши таблицу Student и выберите команду «Показать данные таблицы «, чтобы просмотреть созданные столбцы и строки, вставленные в таблицу.

Файлы базы данных ContosoUniversity1.mdf и LDF находятся в папке %USERPROFILE%.

Соглашения

Объем кода, который необходимо написать, чтобы Платформа Entity Framework могла создавать полную базу данных, минимальна из-за соглашений или предположений, которые делает Entity Framework. Некоторые из них уже были отмечены или были использованы без вашего осознания:

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

Получение кода

Дополнительные ресурсы

Дополнительные сведения о EF 6 см. в следующих статьях:

Источник

Code First to an Existing Database

This step-by-step walkthrough provides an introduction to Code First development targeting an existing database. Code First allows you to define your model using C# or VB.Net classes. Optionally additional configuration can be performed using attributes on your classes and properties or by using a fluent API.

Pre-Requisites

You will need to have Visual Studio 2012 or Visual Studio 2013 installed to complete this walkthrough.

You will also need version 6.1 (or later) of the Entity Framework Tools for Visual Studio installed. See Get Entity Framework for information on installing the latest version of the Entity Framework Tools.

1. Create an Existing Database

Typically when you are targeting an existing database it will already be created, but for this walkthrough we need to create a database to access.

Let’s go ahead and generate the database.

Open Visual Studio

If you haven’t connected to a database from Server Explorer before you’ll need to select Microsoft SQL Server as the data source

Connect to your LocalDB instance, and enter Blogging as the database name

Select OK and you will be asked if you want to create a new database, select Yes

The new database will now appear in Server Explorer, right-click on it and select New Query

Copy the following SQL into the new query, then right-click on the query and select Execute

2. Create the Application

To keep things simple we will build a basic console application that uses Code First to do the data access:

3. Reverse Engineer Model

We will use the Entity Framework Tools for Visual Studio to help us generate some initial code to map to the database. These tools are just generating code that you could also type by hand if you prefer.

Select Data from the left menu and then ADO.NET Entity Data Model

Enter BloggingContext as the name and click OK

This launches the Entity Data Model Wizard

Select Code First from Database and click Next

Select the connection to the database you created in the first section and click Next

Click the checkbox next to Tables to import all tables and click Finish

Once the reverse engineer process completes a number of items will have been added to the project, let’s take a look at what’s been added.

Configuration file

An App.config file has been added to the project, this file contains the connection string to the existing database.

You’ll notice some other settings in the configuration file too, these are default EF settings that tell Code First where to create databases. Since we are mapping to an existing database these setting will be ignored in our application.

Derived Context

A BloggingContext class has been added to the project. The context represents a session with the database, allowing us to query and save data. The context exposes a DbSet for each type in our model. You’ll also notice that the default constructor calls a base constructor using the name= syntax. This tells Code First that the connection string to use for this context should be loaded from the configuration file.

You should always use the name= syntax when you are using a connection string in the config file. This ensures that if the connection string is not present then Entity Framework will throw rather than creating a new database by convention.

Model classes

4. Reading & Writing Data

Now that we have a model it’s time to use it to access some data. Implement the Main method in Program.cs as shown below. This code creates a new instance of our context and then uses it to insert a new Blog. Then it uses a LINQ query to retrieve all Blogs from the database ordered alphabetically by Title.

You can now run the application and test it.

What if My Database Changes?

The Code First to Database wizard is designed to generate a starting point set of classes that you can then tweak and modify. If your database schema changes you can either manually edit the classes or perform another reverse engineer to overwrite the classes.

Using Code First Migrations to an Existing Database

If you want to use Code First Migrations with an existing database, see Code First Migrations to an existing database.

Summary

In this walkthrough we looked at Code First development using an existing database. We used the Entity Framework Tools for Visual Studio to reverse engineer a set of classes that mapped to the database and could be used to store and retrieve data.

Источник

Entity Framework Core Code First

If you have used Entity Framework in the past, you will probably have heard about the Code First approach.

To start using Entity Framework, use the following steps;

The first step is to create a new project and then add all the required NuGet Packages for EF Core. Once all the NuGet packages are installed, add your conceptual model.

It is a very simple model which contains only two classes, Order and OrderDetail has a one-to-many relationship. The next step is to add a new context class and make sure to inherit from the DbContext class

In EF Core, the DbContext has a virtual method called onConfiguring which will get called internally by EF Core, and it will also pass in an optionsBuilder instance, and you can use that optionsBuilder to configure options for the DbContext.

The optionsBuilder has UseSqlServer method; it expects a connection string as a parameter. Once you have a model, you can use migrations to create a database.

Now to create a database using migrations from your model, install the following packages;

Once these packages are installed, run the following command in Package Manager Console.

This command scaffold a migration to create the initial set of tables for your model. When it is executed successfully, then run the following command.

Now you will see a database in Object Explorer with two tables.

Источник

Заметки к данным Code First

Только EF4.1 — функции, API и т. д., рассмотренные на этой странице, были представлены в Entity Framework 4.1. Если вы используете более раннюю версию, некоторые или все эти сведения не применяются.

Содержимое на этой странице адаптировано из статьи, первоначально написанной Джули Лерман ( ).

Entity Framework Code First позволяет использовать собственные классы предметной области для представления модели, которую EF использует для выполнения запросов, отслеживания изменений и обновления функций. Code First использует шаблон программирования, называемый «соглашением по конфигурации». Code First предполагает, что классы следуют соглашениям Entity Framework, и в этом случае автоматически выработает, как выполнять свою работу. Однако если классы не соответствуют этим соглашениям, вы можете добавлять конфигурации в классы для предоставления EF необходимых сведений.

Code First предоставляет два способа добавления этих конфигураций в классы. Один из них использует простые атрибуты, называемые DataAnnotations, а второй — API Fluent Code First, который позволяет описать конфигурации императивно в коде.

Модель

Я продемонстрируем Code First DataAnnotations с простой парой классов: Blog и Post.

По мере их использования классы Blog и Post удобно следуют соглашению о коде и не требуют настройки для обеспечения совместимости EF. Однако заметки также можно использовать для предоставления дополнительных сведений EF о классах и базе данных, с которыми они сопоставляются.

Entity Framework использует все сущности, имеющие ключевое значение, используемое для отслеживания сущностей. Одно соглашение Code First — это неявные ключевые свойства; Code First будет искать свойство с именем «Id» или сочетание имени класса и идентификатора, например «BlogId». Это свойство будет сопоставляться со столбцом первичного ключа в базе данных.

Классы Blog и Post соответствуют этому соглашению. Что, если они этого не сделали? Что делать, если блог использовал вместо него имя PrimaryTrackingKey или даже foo? Если код сначала не находит свойство, соответствующее этому соглашению, оно вызовет исключение из-за требования Entity Framework, которое должно иметь свойство ключа. С помощью заметки к ключу можно указать, какое свойство следует использовать в качестве EntityKey.

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

Составные ключи

Entity Framework поддерживает составные ключи — первичные ключи, состоящие из нескольких свойств. Например, у вас может быть класс Passport, первичный ключ которого является сочетанием PassportNumber и IssuingCountry.

Попытка использовать приведенный выше класс в модели EF приведет к : InvalidOperationException

Не удалось определить упорядочение составного первичного ключа для типа Passport. Используйте метод ColumnAttribute или HasKey, чтобы указать порядок составных первичных ключей.

Чтобы использовать составные ключи, Entity Framework требует определить порядок свойств ключа. Это можно сделать с помощью заметки к столбцу, чтобы указать порядок.

Значение порядка является относительным (а не на основе индекса), поэтому можно использовать любые значения. Например, 100 и 200 будут приемлемы вместо 1 и 2.

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

Обязательно

Заметка Required сообщает EF, что требуется определенное свойство.

При добавлении обязательных к свойству Title будет принудительно выполняться EF (и MVC), чтобы оно удостовериться, что свойство содержит данные.

Без дополнительных изменений кода или разметки в приложении приложение MVC выполняет проверку на стороне клиента, даже динамически создавая сообщение с помощью имен свойств и заметок.

Обязательный атрибут также повлияет на созданную базу данных, сделав сопоставленное свойство не допускаемым значением NULL. Обратите внимание, что поле title изменилось на «не null».

В некоторых случаях столбец в базе данных может быть не допускает значения NULL, даже если это свойство является обязательным. Например, при использовании стратегии наследования TPH для нескольких типов данные хранятся в одной таблице. Если производный тип содержит обязательное свойство, столбец нельзя сделать не допускаемым значением NULL, так как не все типы в иерархии будут иметь это свойство.

MaxLength и MinLength

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

Заметка MaxLength повлияет на базу данных, задав для свойства длину 10.

Заметка на стороне клиента MVC и заметка на стороне сервера EF 4.1 будут учитывать эту проверку, опять же динамически создавая сообщение об ошибке: «Поле BloggerName должно быть строкой или типом массива с максимальной длиной «10». Это сообщение немного длинное. Многие заметки позволяют указать сообщение об ошибке с атрибутом ErrorMessage.

Вы также можете указать ErrorMessage в обязательной заметке.

NotMapped

Первое соглашение кода определяет, что каждое свойство, являющееся поддерживаемым типом данных, представлено в базе данных. Но это не всегда так в приложениях. Например, у вас может быть свойство в классе Блога, которое создает код на основе полей Title и BloggerName. Это свойство можно создавать динамически и не требуется хранить. Вы можете пометить любые свойства, которые не сопоставляются с базой данных с помощью заметки NotMapped, например этого свойства BlogCode.

ComplexType

Это не редкость, чтобы описать сущности домена в наборе классов, а затем распределить эти классы, чтобы описать полную сущность. Например, можно добавить класс с именем BlogDetails в модель.

Обратите внимание, что BlogDetails свойство ключа не имеет какого-либо типа. В управляемом доменом дизайне BlogDetails называется объектом значения. Entity Framework ссылается на объекты значений как сложные типы. Сложные типы не могут отслеживаться самостоятельно.

Теперь вы можете добавить свойство в Blog класс для представления BlogDetails этого блога.

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

ConcurrencyCheck

Давайте посмотрим, как ConcurrencyCheck работает, добавив его в BloggerName свойство.

TimeStamp

Чаще всего используются поля rowversion или timestamp для проверки параллелизма. Но вместо использования заметки ConcurrencyCheck можно использовать более конкретную TimeStamp заметку, если тип свойства является массивом байтов. Сначала код будет обрабатывать Timestamp свойства так же, как ConcurrencyCheck свойства, но также гарантирует, что поле базы данных, которое сначала создает код, не допускает значения NULL. В данном классе может быть только одно свойство метки времени.

Добавление следующего свойства в класс Blog:

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

Таблица и столбец

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

Не путайте атрибут Column TypeName с dataType DataAnnotation. DataType — это заметка, используемая для пользовательского интерфейса и игнорируемая code First.

DatabaseGenerated

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

Индекс

Ef6.1 Onwards Only — Index атрибут появился в Entity Framework 6.1. Если вы используете более раннюю версию, сведения в этом разделе не применяются.

Индекс можно создать для одного или нескольких столбцов с помощью IndexAttribute. Добавление атрибута в одно или несколько свойств приведет к тому, что EF создаст соответствующий индекс в базе данных при создании базы данных или создаст шаблон соответствующих вызовов CreateIndex при использовании Code First Migrations.

Например, следующий код приведет к созданию индекса для Rating столбца Posts таблицы в базе данных.

По умолчанию индексы не являются уникальными, но можно использовать IsUnique именованный параметр, чтобы указать, что индекс должен быть уникальным. В следующем примере представлен уникальный индекс User имени входа.

Индексы Multiple-Column

Индексы, охватывающие несколько столбцов, задаются с помощью одного имени в нескольких заметках индекса для данной таблицы. При создании индексов с несколькими столбцами необходимо указать порядок для столбцов в индексе. Например, следующий код создает индекс Rating с несколькими столбцами и BlogId вызывается IX_BlogIdAndRating. BlogId — первый столбец в индексе и Rating второй.

Атрибуты связи: InverseProperty и ForeignKey

Эта страница содержит сведения о настройке связей в модели Code First с помощью заметок к данным. Общие сведения о связях в EF и о том, как получить доступ к данным и управлять ими с помощью связей, см. в разделе «Свойства навигации связей&».*

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

Используется InverseProperty при наличии нескольких связей между классами.

Post В классе вы можете следить за тем, кто написал запись блога, а также кто его редактировал. Ниже приведены два новых свойства навигации для класса Post.

Сначала код не может сопоставить свойства в двух классах самостоятельно. Таблица базы данных Posts должна иметь один внешний ключ для CreatedBy пользователя и один для UpdatedBy пользователя, но код сначала создаст четыре свойства внешнего ключа: Person_Id, Person_Id1, CreatedBy_Id и UpdatedBy_Id.

Чтобы устранить эти проблемы, можно использовать заметку InverseProperty для указания выравнивания свойств.

Сводка

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

Хотя они являются очень гибкими, имейте в виду, что DataAnnotations предоставляют только самые распространенные необходимые изменения конфигурации, которые можно внести в код в первые классы. Чтобы настроить классы для некоторых пограничных вариантов, необходимо ознакомиться с альтернативным механизмом настройки API Fluent Code First.

Источник

Code First Data Annotations

The content on this page is adapted from an article originally written by Julie Lerman ( ).

Entity Framework Code First allows you to use your own domain classes to represent the model that EF relies on to perform querying, change tracking, and updating functions. Code First leverages a programming pattern referred to as ‘convention over configuration.’ Code First will assume that your classes follow the conventions of Entity Framework, and in that case, will automatically work out how to perform its job. However, if your classes do not follow those conventions, you have the ability to add configurations to your classes to provide EF with the requisite information.

Code First gives you two ways to add these configurations to your classes. One is using simple attributes called DataAnnotations, and the second is using Code First’s Fluent API, which provides you with a way to describe configurations imperatively, in code.

The model

I’ll demonstrate Code First DataAnnotations with a simple pair of classes: Blog and Post.

As they are, the Blog and Post classes conveniently follow code first convention and require no tweaks to enable EF compatability. However, you can also use the annotations to provide more information to EF about the classes and the database to which they map.

Entity Framework relies on every entity having a key value that is used for entity tracking. One convention of Code First is implicit key properties; Code First will look for a property named “Id”, or a combination of class name and “Id”, such as “BlogId”. This property will map to a primary key column in the database.

The Blog and Post classes both follow this convention. What if they didn’t? What if Blog used the name PrimaryTrackingKey instead, or even foo? If code first does not find a property that matches this convention it will throw an exception because of Entity Framework’s requirement that you must have a key property. You can use the key annotation to specify which property is to be used as the EntityKey.

If you are using code first’s database generation feature, the Blog table will have a primary key column named PrimaryTrackingKey, which is also defined as Identity by default.

Composite keys

Attempting to use the above class in your EF model would result in an InvalidOperationException :

Unable to determine composite primary key ordering for type ‘Passport’. Use the ColumnAttribute or the HasKey method to specify an order for composite primary keys.

In order to use composite keys, Entity Framework requires you to define an order for the key properties. You can do this by using the Column annotation to specify an order.

The order value is relative (rather than index based) so any values can be used. For example, 100 and 200 would be acceptable in place of 1 and 2.

If you have entities with composite foreign keys, then you must specify the same column ordering that you used for the corresponding primary key properties.

Only the relative ordering within the foreign key properties needs to be the same, the exact values assigned to Order do not need to match. For example, in the following class, 3 and 4 could be used in place of 1 and 2.

Required

The Required annotation tells EF that a particular property is required.

Adding Required to the Title property will force EF (and MVC) to ensure that the property has data in it.

With no additional code or markup changes in the application, an MVC application will perform client side validation, even dynamically building a message using the property and annotation names.

The Required attribute will also affect the generated database by making the mapped property non-nullable. Notice that the Title field has changed to “not null”.

In some cases it may not be possible for the column in the database to be non-nullable even though the property is required. For example, when using a TPH inheritance strategy data for multiple types is stored in a single table. If a derived type includes a required property the column cannot be made non-nullable since not all types in the hierarchy will have this property.

MaxLength and MinLength

Here is the BloggerName with length requirements. The example also demonstrates how to combine attributes.

The MaxLength annotation will impact the database by setting the property’s length to 10.

MVC client-side annotation and EF 4.1 server-side annotation will both honor this validation, again dynamically building an error message: “The field BloggerName must be a string or array type with a maximum length of ’10’.” That message is a little long. Many annotations let you specify an error message with the ErrorMessage attribute.

You can also specify ErrorMessage in the Required annotation.

NotMapped

Code first convention dictates that every property that is of a supported data type is represented in the database. But this isn’t always the case in your applications. For example you might have a property in the Blog class that creates a code based on the Title and BloggerName fields. That property can be created dynamically and does not need to be stored. You can mark any properties that do not map to the database with the NotMapped annotation such as this BlogCode property.

ComplexType

It’s not uncommon to describe your domain entities across a set of classes and then layer those classes to describe a complete entity. For example, you may add a class called BlogDetails to your model.

Notice that BlogDetails does not have any type of key property. In domain driven design, BlogDetails is referred to as a value object. Entity Framework refers to value objects as complex types.В Complex types cannot be tracked on their own.

Now you can add a property in the Blog class to represent the BlogDetails for that blog.

In the database, the Blog table will contain all of the properties of the blog including the properties contained in its BlogDetail property. By default, each one is preceded with the name of the complex type, «BlogDetail».

ConcurrencyCheck

Let’s see how ConcurrencyCheck works by adding it to the BloggerName property.

If someone has changed the blogger name for that blog in the meantime, this update will fail and you’ll get a DbUpdateConcurrencyException that you’ll need to handle.

TimeStamp

It’s more common to use rowversion or timestamp fields for concurrency checking. But rather than using the ConcurrencyCheck annotation, you can use the more specific TimeStamp annotation as long as the type of the property is byte array. Code first will treat Timestamp properties the same as ConcurrencyCheck properties, but it will also ensure that the database field that code first generates is non-nullable. You can only have one timestamp property in a given class.

Adding the following property to the Blog class:

results in code first creating a non-nullable timestamp column in the database table.

Table and Column

If you are letting Code First create the database, you may want to change the name of the tables and columns it is creating. You can also use Code First with an existing database. But it’s not always the case that the names of the classes and properties in your domain match the names of the tables and columns in your database.

The Column annotation is a more adept in specifying the attributes of a mapped column. You can stipulate a name, data type or even the order in which a column appears in the table. Here is an example of the Column attribute.

Don’t confuse Column’s TypeName attribute with the DataType DataAnnotation. DataType is an annotation used for the UI and is ignored by Code First.

DatabaseGenerated

You can use database generated on byte or timestamp columns when code first is generating the database, otherwise you should only use this when pointing to existing databases because code first won’t be able to determine the formula for the computed column.

Index

You can create an index on one or more columns using the IndexAttribute. Adding the attribute to one or more properties will cause EF to create the corresponding index in the database when it creates the database, or scaffold the corresponding CreateIndex calls if you are using Code First Migrations.

For example, the following code will result in an index being created on the Rating column of the Posts table in the database.

By default, the index will be named IX_

By default, indexes are non-unique, but you can use the IsUnique named parameter to specify that an index should be unique. The following example introduces a unique index on a User ‘s login name.

Multiple-Column Indexes

Indexes that span multiple columns are specified by using the same name in multiple Index annotations for a given table. When you create multi-column indexes, you need to specify an order for the columns in the index. For example, the following code creates a multi-column index on Rating and BlogId called IX_BlogIdAndRating. BlogId is the first column in the index and Rating is the second.

Relationship Attributes: InverseProperty and ForeignKey

This page provides information about setting up relationships in your Code First model using Data Annotations. For general information about relationships in EF and how to access and manipulate data using relationships, see Relationships & Navigation Properties.*

Code first convention will take care of the most common relationships in your model, but there are some cases where it needs help.

When generating the database, code first sees the BlogId property in the Post class and recognizes it, by the convention that it matches a class name plus Id, as a foreign key to the Blog class. But there is no BlogId property in the blog class. The solution for this is to create a navigation property in the Post and use the ForeignKey DataAnnotation to help code first understand how to build the relationship between the two classes (using the Post.BlogId property) as well as how to specify constraints in the database.

The InverseProperty is used when you have multiple relationships between classes.

In the Post class, you may want to keep track of who wrote a blog post as well as who edited it. Here are two new navigation properties for the Post class.

Code first is not able to match up the properties in the two classes on its own. The database table for Posts should have one foreign key for the CreatedBy person and one for the UpdatedBy person but code first will create four foreign key properties: Person_Id, Person_Id1, CreatedBy_Id and UpdatedBy_Id.

To fix these problems, you can use the InverseProperty annotation to specify the alignment of the properties.

Summary

DataAnnotations not only let you describe client and server side validation in your code first classes, but they also allow you to enhance and even correct the assumptions that code first will make about your classes based on its conventions. With DataAnnotations you can not only drive database schema generation, but you can also map your code first classes to a pre-existing database.

Источник

Шаблон Code First в ADO.NET Entity Framework 4.1

Роуэн Миллер

Продукты и технологии:

Entity Framework 4.1

В статье рассматриваются:

Entity Framework 4.1 доступна отдельно (msdn.microsoft.com/data/ee712906) как NuGet-пакет EntityFramework, а также включена в ASP.NET MVC 3.01.

В Entity Framework 4.1 появились две основные новые возможности: DbContext API и Code First. В этой статье я расскажу, как задействовать эти возможности при разработке приложений. Мы кратко рассмотрим, как приступить к работе с Code First, а затем подробно обсудим некоторые более продвинутые возможности.

DbContext API — это упрощенная абстракция существующего типа ObjectContext и некоторых других типов, которые были введены в предыдущих выпусках Entity Framework. DbContext API оптимизирован для распространенных задач и шаблонов кодирования. Стандартная функциональность предоставляется на корневом уровне, а более продвинутая — доступна при углублении в этот API.

Code First — новый шаблон разработки для Entity Framework и альтернатива существующим шаблонам Database First и Model First. Code First позволяет определить модель, используя CLR-классы, а затем сопоставить эти классы с существующей базой данных или сгенерировать на их основе схему базы данных. Дополнительное конфигурирование обеспечивается через аннотации данных или через текучий API.

Приступаем к работе с шаблоном Code First

Code First существует уже некоторое время, поэтому я не стану вдаваться в детали того, как начать с ним работу. Если вы не знакомы с основами, то можете последовать «Code First Walkthrough» (bit.ly/evXlOc). На рис. 1 приведен полный исходный код, помогающий быстро начать разработку приложения на основе шаблона Code First.

Рис. 1. Приступаем к работе с шаблоном Code First

Простоты ради я предпочел сделать так, чтобы Code First генерировал базу данных. В моем случае база данных будет создана при первом использовании BlogContext для сохранения и запроса данных. Остальная часть статьи в равной мере применима к тем случаям, где Code First сопоставляется с существующей базой данных. Вы увидите, что на протяжении всей статьи я использую инициализатор базы данных для удаления и повторного создания базы данных после внесения любых изменений в модель.

Сопоставление с помощью текучего API

Code First начинает с анализа ваших CLR-классов для логического определения «контуров» вашей модели. При распознавании многих вещей вроде основных ключей применяется ряд соглашений. Вы можете переопределить (или добавить) то, что распознается по соглашению, используя аннотации данных (Data Annotations) или текучий API (fluent API). О решении распространенных задач с помощью текучего API уже написано довольно много статей, поэтому я намерен рассмотреть некоторые из более сложных случаев. В частности, я сосредоточусь на разделах «сопоставления» (mapping) этого API. Конфигурацию сопоставления можно использовать для сопоставления со схемой существующей базы данных или для изменения сгенерированной схемы. Текучий API предоставляется через тип DbModelBuilder, и к нему проще всего обращаться с помощью переопределенного метода OnModelCreating объекта DbContext.

В Entity Framework 4.1 появились две основные новые возможности: DbContext API и Code First.

Расщепление сущностей Позволяет распределять свойства типа сущности по нескольким таблицам. Например, я хочу выделить фотоснимки для публикации в отдельную таблицу, чтобы их можно было хранить в другой файловой группе. При расщеплении сущности используется серия вызовов Map для сопоставления подмножества свойств с конкретной таблицей. На рис. 2 я сопоставляю свойство Photo с таблицей PostPhotos, а остальные свойства — с таблицей Posts. Заметьте, что я не включил основной ключ в список свойств. Основной ключ всегда должен быть в каждой таблице; я мог бы включить его самостоятельно, но Code First добавляет его за меня автоматически.

Рис. 2. Расщепление сущностей

Наследование Table-per-Hierarchy (TPH) В случае TPH данные для иерархии наследования хранятся в одной таблице и используется поле различения (discriminator) для идентификации типа каждой записи. Если вы не предоставляете свою конфигурацию, Code First будет использовать TPH по умолчанию. Поле различения названо соответствующим образом — Discriminator, и его значением является имя каждого CLR-типа.

В предыдущем примере я все еще применяю отдельное поле для различения типов, но знаю, что экземпляры RssEnabledBlog можно идентифицировать по наличию у них RSS-канала. Я могу переписать сопоставление, чтобы сообщить Entity Framework о необходимости использования поля, где хранится Blog.RssFeed, для различения типов. Если в поле содержится значение, отличное от null, значит, это RssEnabledBlog:

Наследование Table-per-Concrete Type (TPC) В случае TPC данные для каждого типа хранятся в отдельной таблице без ограничений по внешнему ключу между ними. Конфигурирование выполняется аналогично сопоставлению TPT, но при конфигурировании каждого производного типа добавляется вызов MapInheritedProperties. Этот метод сообщает Code First заново сопоставить все свойства, унаследованные от базового класса, с новыми полями в таблице производного класса:

По соглашению, Code First будет использовать для целочисленных основных ключей поля идентификации (identity columns). Однако в случае TPC у вас не будет единственной таблицы, содержащей все блоги, на основе которой можно сгенерировать основные ключи. Из-за этого Code First отключит идентификацию при использовании сопоставления TPC. Если сопоставление осуществляется с существующей базой данных, которая была настроена на генерацию уникальных значений между несколькими таблицами, то можно заново включить идентификацию через раздел конфигурирования свойств в текучем API.

Гибридные сопоставления Конечно, ваша схема не всегда будет соответствовать одному из перечисленных шаблонов, особенно при сопоставлении с существующей базой данных. Хорошая новость в том, что API сопоставления является композиционным и вы можете комбинировать несколько стратегий сопоставления. На рис. 3 показан пример, демонстрирующий, как скомбинировать расщепление сущностей с сопоставлением TPT. Данные, общие для блогов, разделяются между таблицами Blogs и BlogAbstracts, а данные, специфичные для блогов с RSS-каналом, хранятся в отдельной таблице RssBlogs.

Рис. 3. Комбинация расщепления сущностей и сопоставления TPT

API для отслеживания изменений

Рассмотрев конфигурирование сопоставлений с базой данных, немного поработаем с данными и обсудим некоторые более сложные сценарии. (Если вы не знакомы с базовыми принципами доступа к данным, сначала прочитайте документ «Code First Walkthrough», о котором я уже упоминал.)

Информация о состоянии единственной сущности Во многих случаях, например при ведении журнала, полезно иметь доступ к информации о состоянии сущности. DbContext предоставляет доступ к такой информации для индивидуальных сущностей через метод Entry. Фрагмент кода на рис. 4 загружает один Blog из базы данных, модифицирует одно из свойств, а затем выводит в консоль текущее и исходное значения каждого свойства.

Рис. 4. Получение информации о состоянии сущности

При выполнении кода с рис. 4 вы получите следующий вывод в консоли:

BlogId
Original Value: 1
Current Value: 1

Name
Original Value: blogs.msdn.com/data
Current Value: ADO.NET Team Blog

Abstract
Original Value:
Current Value:

Информация о состоянии нескольких сущностей DbContext позволяет получать информацию о состоянии нескольких сущностей через метод ChangeTracker.Entries. Он существует в двух версиях: обобщенной (для получения сущностей конкретного типа) и обычной (для получения всех сущностей). Параметр обобщенной версии не обязательно должен быть типом сущности. Например, вы могли бы получать записи по всем загруженным объектам, которые реализуют специфический интерфейс. Код на рис. 5 демонстрирует загрузку всех объектов блогов в память, модификацию свойства одного из них и вывод в консоль состояния каждого отслеживаемого объекта блога.

Рис. 5. Доступ к информации о нескольких сущностях с помощью DbContext

При выполнении кода с рис. 5 вы получите следующий вывод в консоли:

BlogId: 1
State: Modified

BlogId: 2
State: Unchanged

Запрос локальных экземпляров Всякий раз, когда вы выполняете LINQ-запрос к DbSet, запрос отправляется в базу данных для обработки. Это гарантирует, что вы всегда будете получать актуальные результаты, но, если известно, что все необходимые данные уже находятся в памяти, можно избежать цикла обмена данными с базой данных, запросив локальные данные. Код на рис. 6 загружает в память все объекты блогов, а затем выполняет два LINQ-запроса, не требующие обращения к базе данных.

Рис. 6. Выполнение LINQ-запросов к данным в памяти

При выполнении кода с рис. 6 вы получите следующий вывод в консоли:

All Blogs:
— blogs.msdn.com/data
— romiller.com

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

Расщепление сущностей позволяет распределять свойства типа сущности по нескольким таблицам.

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

Рис. 7. Получение количества элементов в базе данных с помощью отложенной загрузки

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

К счастью, этот код можно оптимизировать, используя метод Entry объекта DbContext для получения запроса, который представляет набор сообщений, связанных с блогом. Поскольку LINQ-запросы поддерживают композицию, я могу объединить в цепочку оператор Count и отправить в базу данных весь запрос, чтобы она вернула мне лишь один целочисленный результат (рис. 8).

Рис. 8. Применение DbContext для оптимизации кода запроса и экономии ресурсов

Соображения по развертыванию

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

Вот как выглядит обновленный код контекста:

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

Инициализаторы базы данных По умолчанию Code First будет создавать базу данных автоматически, если целевой базы данных нет. Для некоторых такая функциональность будет предпочтительной даже при развертывании — производственная база данных будет создаваться просто при первом запуске приложения. Если в вашей производственной среде имеется DBA, то гораздо вероятнее, что именно DBA будет создавать за вас производственную базу данных, и, как только ваше приложение будет развернуто, вы получите сообщение об ошибке. В этой статье я также переопределял логику инициализатора по умолчанию и при каждом изменении схемы удалял и заново создавал базу данных. Это явно не то, что вы предпочтете оставить при развертывании приложения в производственной среде.

Рекомендуемый подход к изменению или отключению логики инициализатора при развертывании — использование файла App.config (или Web.config для веб-приложений). В раздел appSettings добавьте запись с ключом DatabaseInitializerForType, а за ним имя типа контекста и сборку, в которой он определен. Значением может быть либо «Disabled», либо имя типа инициализатора с именем сборки, где он определен.

TВ следующем примере отключается любая логика инициализатора для контекста:

А здесь инициализатору возвращается исходная логика, в соответствии с которой он создает базу данных, только если она отсутствует:

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

По умолчанию Code First будет создавать базу данных автоматически, если целевой базы данных нет.

Где узнать больше

В этой статье я показал, как приступить к разработке с применением Code First и использовать новый DbContext API; обе эти возможности появились в ADO.NET Entity Framework 4.1. Вы увидели, как можно использовать текучий API для сопоставления с существующей базой данных или изменения схемы, генерируемой Code First. Затем мы рассмотрели API для отслеживания изменений и то, как применять его для запроса локальных экземпляров сущностей и дополнительной информации об этих экземплярах. Наконец, я высказал несколько соображений по развертыванию приложения, использующего Code First для доступа к данным.

Если вы хотите узнать больше о любых средствах, появившихся в Entity Framework 4.1, зайдите на сайт msdn.com/data/ef. Кроме того, на форуме Data Developer Center (bit.ly/166o1Z) вам всегда помогут в использовании Entity Framework 4.1.

Роуэн Миллер — менеджер программ в группе Microsoft Entity Framework. Дополнительную информацию об Entity Framework можно получить в его блоге на romiller.com.

Выражаю благодарность за рецензирование статьи эксперту Артуру Викерсу (Arthur Vickers).

Источник

Разработка баз данных с Code First

Повсеместно принято, что в «серьезных» CRUD приложениях база данных становится во главу угла. Ее проектируют самой первой, она обрастает хранимыми процедурами (stored procedures), с ней приходиться возиться больше всего. Но это не единственный путь! Для Entity Framework есть Code First подход, где главным становится код, а не база. Преимущества:

Есть и пара недостатков, но они скорее связаны с Entity Framework, а не с Code First подходом как таковым; о них чуть позже.

Ниже я покажу на примере, насколько просто разрабатывать с Code First подходом.

Пример

Возьмем простую модель:

В качестве фронт-энда будет ASP.NET MVC, так что создаем соответствующий проект. Выбираем No Authentication — в этом проекте нельзя будет логиниться и весь контент доступен для всех.

Я сделал еще 2 проекта — для бизнес-объектов и DAL, но при желании можно просто создать соответствующие папки в web проекте. Не забудте установить Entity Framework в соответствующие проекты через NuGet.

Создаем классы, которые будут отображать сущности (entities):

Как видно, все повторяющееся свойства (properties) можно убрать в абстрактный класс и наследоваться от него. В данном случае у каждой таблицы будет Primary Key колонка типа Guid, который будет генерироваться при записи в базу.

Grade — это просто энумератор, ничего особенного:

Создаем контекстный класс:

Отношения дефинированы через Fluent API, читаются с конца — например, Student — Enrollment относятся как one (Student): many (Enrollment).

Стоит отметить, что конфигурировать модели можно как через Fluent API, так и аннотациями. Для некоторых настроек аннотаций не существует, но их можно создать самим. Я предпочитаю все-же Fluent API.

И, наконец, заполнение базы данными:

Примечание: как следует из названия DropCreateDatabaseIfModelChanges, база будет дропаться при изменениях в соответствующих классах моделей. То есть данные — капут.
Как реализовать миграции, чтобы данные не капут, выходит за область этой статьи.

Последнее, что надо сделать — добавить информацию в web.config. Используем LocalDb, которая идет вместе с Visual Studio, которой вполне достаточно для целей этого проекта. Следующий код идет в элемент configuration:

А следующая разметка — в элемент entityFramework:

В атрибуте type элемента context указываются через запятую название класса контекста и assembly, где этот класс находится. То же самое для инициализатора в элементе databaseInitializer.

Это вообщем-то и все, проект готов к запуску.

Скачать пример можно тут.

Недостатки

Во-первых, к существующей базе данных подобный подход применить сложно. Так что вообщем-то это для разработки с нуля.
Часто подножки ставит Entity Framework, который часто принимает решения за программиста — есть так называемые конвенции, что, допустим, property который называется Id, будет по умолчанию преобразован в Primary Key таблицы. Мне такой подход не нравится.

Продолжение темы

Разработка с помощью Code First подхода в Entity Framework достаточно объемная тема. Я не касался вопроса миграций, проблем с многопоточностью (concurrency) и многого другого. Если сообществу интересно, я могу продолжить эту тему в дальнейших статьях.

1. Getting started with Entity Framework 6 Code First using MVC 5

2. Database initialization in Code-First

3. Lerman J., Miller R. — Programming Entity Framework. Code First (2011)

Источник

Использование Entity Framework Core code-first с СУБД SQLite при разработке WinForms-приложений в VisualStudio 2015

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

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

1. Устанавливаем Windows Management Framework 5.0 чтобы обновить PowerShell до версии 5.0. У меня (после установки Windows 7 и Visual Studio 2015 и всех обновлений к ним) в системе была версия 2.0 и далее в процессе я получил сообщение об ошибке с требованием более новой версии

3. Обновляем расширение Visual Studio для работы с репозиториями NuGet. Для этого либо скачиваем актуальную на данный момент версию 3.5.0.1996 по прямой ссылке либо добавляем в настройки Visual Studio соответствующий репозиторий расширений для автоматического обновления.

6. Создаём файлы исходного кода классов модели данных. Для порядка я поместил их в подпапку «Model» (некоторые называют её «Entities», некоторые кидают все классы в корень проекта, а некоторые и вовсе в один файл). Модель описывает учебный пример базы данных, хранящей список городов и людей в/из них. Каждый человек может быть связан только с одним городом, может быть неизвестно из какого он города вообще.

7. Разрешаем скрипты PowerShell, если этого не сделать может возникнуть ошибка «. \packages\Microsoft.EntityFrameworkCore.Tools.1.1.0-preview4-final\tools\init.ps1 cannot be loaded because running scripts is disabled on this system.» Для этого переходим в командную строку NuGet (выбрать Tools — NuGet Package Manager — Package Manager Console в меню) и выполняем следующую команду

8. Создаём «миграции». Для этого, сохранив и откомпилировав наш код (просто чтобы удостовериться в отсутствии явных опечаток) переходим в командную строку NuGet и выполняем следующую команду.

в результате у нас в проекте должна появиться папка «Migrations» и два файла в ней: «Vs2015WinFormsEfcSqliteCodeFirst20170304ExampleContextModelSnapshot.cs» и «20170304204355_Vs2015WinFormsEfcSqliteCodeFirst20170304ExampleMigration.cs» (разумеется число в начале последнего у вас будет другое — это ни что иное, как дата и время в момент генерации в очевидном формате, я её потом вообще удалил оставив только «Vs2015WinFormsEfcSqliteCodeFirst20170304ExampleMigration.cs»).

9. Редактируем сгенерированные файлы чтобы добавить условие уникальности (unique constraint, также известное как вторичный ключ) на имя города (в реальности, конечно, бывают города с одинаковыми именами, но для примера будет не лишним)

10. Генерируем файл БД. Для этого в командной строке NuGet выполняем следующую команду

Файл БД создастся в той же директории, где находится скомпилированный exe-шник нашего приложения, у меня это «. \Vs2015WinFormsEfcSqliteCodeFirst20170304Example\bin\Debug\Vs2015WinFormsEfcSqliteCodeFirst20170304Example.sqlite».

На данном этапе мы уже можем заглянуть внутрь созданного файла, например с помощью официального консольного клиента sqlite3 или бесплатной кроссплатформенной GUI оболочки DB Browser for SQLite, и удостовериться, что таблицы создались корректно. Помимо наших таблиц «Cities» и «People» мы также найдём там таблицу «__EFMigrationsHistory» со служебной информацией EF Core и «sqlite_sequence» со служебной информацией SQLite.

11. Теперь перейдём к дизайнеру нашей формы, разместим на ней кнопочку, щёлкнем и на ней дважды чтобы создать обработчик события нажатия на кнопку и перейти к редактированию его кода. Ниже привожу свой код, демонстрирующий основные действия с записями БД. Я ещё имею привычку всегда переименовывать Form1 в MainForm и контролы аналогично по смыслу (в данном случае единственный контрол button1 в mainButton), но это дело вкуса и принятых в вашей команде стандартов именования.

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

Скачать весь приведённый выше и сопутствующий код можно тут.

Источник

Подходы для работы с Entity Framework

При использовании Entity Framework в приложении существует три подхода для организации взаимодействия Entity Framework с базой данных: Code-First, Model-First и Database-First. В этой статье мы кратко рассмотрим эти подходы и проведем их сравнительный анализ, а более подробное описание каждого из подходов с использованием примеров будет приведено в следующих статьях.

Подход Code-First

, который впервые появился в Entity Framework 4.1, обычно используется, когда у вас есть уже существующее приложение, содержащее модель данных. Эта модель, как правило, описывается с помощью нескольких классов и кода взаимодействия между этими классами. Например, вы можете создать класс по имени Customer, который будет содержать данные покупателя в интернет-магазине:

Вы можете использовать этот класс модели в своем приложении без создания базы данных. Добавив дополнительный код, вы могли бы хранить объекты этого класса, например, на диске в формате XML или в памяти рабочего процесса программы. Однако когда ваше приложение расширяется и становится крупным, эти данные необходимо будет хранить в базе данных. Эта та точка, в которой и начинает работать подход Code-First – вы можете использовать существующий код для создания базы данных не беспокоясь о деталях реализации базы данных (этим займется Entity Framework), а вы можете сфокусировать свое внимание на коде.

Важно отметить, что класс, представляющий модель данных, должен иметь поле Id, которое будет использоваться в таблице базы данных в качестве первичного ключа. Entity Framework автоматически находит такое поле с помощью механизма рефлексии (в его имени должна содержаться строка “Id”, поэтому поле CustomerId в примере выше будет автоматически использоваться в качестве первичного ключа.) Это ограничение можно обойти, использовав свойство с произвольным именем и помеченное специальными атрибутами метаданных C#, которые используются в Entity Framework. Здесь мы их описывать не будем, я лишь заострил свое внимание на этом моменте, потому что он показывает, что любые настройки первичных и внешних ключей, ограничения между таблицами и т.д. при подходе Code-First указываются в модели (т.е. в управляемом коде C#), а потом проецируются на базу данных.

Подход Code-First появился позже подходов Model-First и Database-First и, как вы уже поняли, больше всего подходит для разработчиков, которые хотят писать код, а не работать с дизайнером модели EDM или средствами работы с базами данных (SQL Server Management Studio и T-SQL). Вы можете создать модель для вашего приложения, используя объекты CLR (Common Language Runtime) и специальные объекты POCO (Plain Old CLR Object).

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

Важным нововведением версии Entity Framework 5 в плане подхода Code-First, является то, что созданная модель классов теперь сразу является сущностной моделью данных EDM (Entity Data Model), поэтому отпала необходимость использовать файл EDMX. В более ранних версиях разработчику, использующему подход Code-First, приходилось добавлять отношения между моделью классов и файлом EDMX, т.е. отображать любые изменения модели сразу в двух местах. Очевидно, что этот подход приводил к появлению кучи ошибок, если разработчик забывал синхронизировать эти изменения в обоих файлах.

Чтобы указать среде Visual Studio, что модель классов является моделью EDM, нужно во-первых установить сборки Entity Framework в проект, а во-вторых добавить класс контекста базы данных, унаследованный от класса DbContext, находящегося в пространстве имен System.Data.Entity, как показано в примере ниже (установку Entity Framework и настройку класса контекста мы более подробно будем рассматривать позже):

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

Этот код является немного упрощенным, но все же показывает суть работы с Entity Framework. Конечно, вы можете глубже контролировать каждую операцию с базой данных. Этот пример использует максимальную автоматизацию и дает приемлемые результаты, по крайней мере в небольшом приложении. В последующих статьях мы рассмотрим более подробно настройки подхода Code-First, которые можно использовать для удовлетворения конкретных потребностей.

Подход Model-First

, впервые появившийся в версии Entity Framework 4, применяется разработчиками, которые не хотят использовать инструменты СУБД для создания и управления базами данных, а также не хотят вручную настраивать классы модели EDM. Фактически это самый простой подход при работе с Entity Framework. Проектирование модели происходит в графическом дизайнере EDM среды Visual Studio. Вы могли наблюдать использование Model-First в предыдущей статье, где мы создали простое приложение ASP.NET.

Рабочий процесс создания модели при подходе Model-First начинается в тот момент, когда вы проектируете базу данных. При этом вам необходимы минимальные знания устройства баз данных, например, для настройки отношений между таблицами в графическом дизайнере или указания типов данных SQL полей таблицы.

Как и в случае подхода Code-First, вся работа строится вокруг класса контекста базы данных. Фактически, взаимодействие с базой данных в этих подходах одинаковое. Например, для вставки объекта, используется следующая последовательность действий:

Создать объект модели и наполнить его данными.

Создать класс контекста, унаследованный от DbContext (в подходе Code-First это делается вручную, в Model-First этот класс генерируется автоматически вместе с сущностными классами).

Добавить объект в базу данных, используя класс контекста.

Подход Database-First

При этом подходе, рабочий процесс создания модели начинается с создания и проектирования базы данных. После генерации сущностных классов модели из существующей базы данных, работа с Entity Framework аналогична подходам Code-First и Model-First. Это означает создание объекта класса контекста и использование этого объекта для выполнения необходимых задач.

Совместимые с Entity Framework поставщики данных

Для того, чтобы получить доступ к базе данных с помощью Entity Framework, нужно использовать поставщики данных, совместимые с Entity Framework. организуют взаимодействие между сущностными классами и системой управления базами данных (СУБД). Фактически они отвечают за то, например, какой код C# нужно сгенерировать из базы данных при использовании подхода Database-First, или какой код SQL нужно создать, при отображении графической модели EDMX на базу данных.

Visual Studio по умолчанию поставляется поставщиком данных SqlClient, что позволяет получить доступ к большинству версий СУБД SQL Server: 2005, 2008, 2010, 2012, 2014. Начиная с версии Visual Studio 2010, Microsoft отказалась от поддержки SQL Server 2000. Можно также создать приложение, обращающееся к SQL Server Compact. Тем не менее, этот провайдер имеет некоторые строгие ограничения, такие как неспособность поддерживать схемы с одинаковыми именами ограничений.

Вы также можете получить доступ к ряду сторонних поставщиков данных для других СУБД. В настоящее время поставщики данных Entity Framework поддерживаются следующими СУБД: MySQL, Oracle, Progress, VistaDB, Devart, OpenLink, SQL Anywhere, Sybase, SQLite, Synergex, Firebird и PostgreSQL (через поставщик Npgsql).

В списке провайдеров отсутствует поддержка базы данных Access Microsoft. Также Entity Framework не поддерживает старые технологии и методы доступа, такие как Open Database Connectivity (ODBC). Для того, чтобы получить поддержку Entity Framework для конкретной базы данных, вы можете создать EF-совместимый провайдер для нее. Более подробно об этом можно прочитать в статье «EF5 Sample Provider».

Как выбрать нужный подход?

Данный вопрос задает себе каждый разработчик, который планирует работать с Entity Framework. В данном случае можно посоветовать придерживаться целей каждого из подходов. Например, если вы запускаете приложение с нуля и у вас нет базы данных, то удобнее использовать подход Model-First. Если база данных есть, то можно использовать Database-First. Если нужно добавить поддержку Entity Framework в уже существующее приложение, где определена модель данных, логичнее всего использовать подход Code-First.

Однако, можно посоветовать использовать подход, удобный для разработчика. Очевидно, что подход Database-First удобен для разработчиков, которые хорошо разбираются в проектировании баз данных и знают основы T-SQL, т.к. этот подход подразумевает создание базы данных вручную. Model-First больше подходит для архитекторов приложений, т.к. использует удобную графическую среду и абстрагируется от реализации базы данных и создания классов модели. Code-First более удобен для программистов C#, т.к. позволяет настраивать детали базы данных из кода.

В следующей таблице показана сводка различных подходов для работы с Entity Framework:

Типы подходов для работы с Entity Framework

Если вам необходимо создать новую базу данных и вы хотите увидеть дизайн базы в графическом виде, подход Model-First работает лучше всего. Model-First использует следующий рабочий процесс:

Вы можете создать модель, используя графический конструктор EDMX.

Вы генерируете базу данных на основе этой модели.

Entity Framework автоматически генерирует классы, необходимые для взаимодействия с базой данных.

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

Вы генерируете модель EDMX из существующей базы данных.

Entity Framework автоматически генерирует классы, необходимые для взаимодействия с базой данных.

Если вам необходимо создать новую базу данных и вы предпочитаете работать с кодом, то лучшим подходом будет Code-First, использующий следующий рабочий процесс:

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

Вы определяете отношения между таблицами с помощью различных атрибутов и виртуальных методов.

При необходимости, вы также настраиваете детали подключения (например, строку подключения).

Entity Framework автоматически формирует базу данных во время выполнения.

Если для существующей базы данных вы хотите вручную создать модель в коде, то нужно использовать подход Code-First, который некоторые разработчики также называют Code-Second, т.к. он применяется к уже существующей базе данных. Рабочий процесс выглядит следующим образом:

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

Вы отображаете отношения между таблицами в базе данных на код модели.

Источник

What is the ORM

ORM(Object Relational Mapping) is a technology that convert models to our database tables, properties to columns, objects to a records in the database. ORM tools allows perform database operations for us so we can perform database operations on classes and objects.

As we can see in the picture, ORM makes mapping between OOP and database, It provides us with the convenience of application development in relational databases without dealing with database structures and queries.

What is the Entity Framework

Entity Framework contains 3 different methods:

In this post, we will do sample application with Code First Method.

The advantages of Entity Framework:

What is the Code First Approach

It is an approach that we perform database operations by writing code. It is created by coding all transactions related to the database. In this approach the power is on the developer 🙂

Now we can move to build a sample application.

We will realize our scenario through a “Basketball Application”. The application will have classes that will include different relationships (1:1), (1:m), (m:m)

First of all, we should add Entity Framework Core libraries which we need, from Nuget to our project. We will run these commands in Package Manager Console but be sure that Default project section must be “EfCoreRelations.Data”

And then we are adding these libraries for Api layer. Be sure that Default project section must be “EfCoreRelations.Api”

According to our scenario, we will have six classes which are “Team”, ”Coach”, ”Country”, ”League”, ”Player”, ”TeamLeague”.

We will creating them in “Data” layer in “Models” folder.

We will build a one to one relationship between “Team” and “Coach”. A team has only a coach and a coach works only in a team. We are setting our “Team” and “Coach” classes as follows:

After we configured our classes like this, I will pass to explanation.

In “Team” class, I added “Coach” property to refer to “Coach” class and I did same in “Coach” class too but I decided to keep Foreign Key in “Coach” class. Foreign Key is “TeamId” property in “Coach” class.

This is a one to one relation and I have to do some configurations for mapping in both classes

builder.Property(x => x.TeamName).HasColumnType(“nvarchar(50)”); → Defining column type as “nvarchar(50)”of “TeamName” because default is “nvarchar(MAX)”

builder.HasOne(x => x.Coach) → Choosing “Coach” property in “Team” class
.WithOne(x => x.Team) → Connecting “Coach” property with “Team” property in “Coach” class
.HasForeignKey (x => x.TeamId); → Defining a Foreign Key “TeamId” in “Coach” class

We will build a one to many and many to one relationships between “Team-Country” and “Team-Player”. A team has a country but a country may have many teams. A team may have many players but a player plays only in a team. We are setting our Team, Player and Country classes like this

For relationship between “Team” and “Country”, I added “Country” property and “CountryId” property for Foreign Key. I configured mapping in “one” side in relationship so I made a configuration in “Team class”. As we can see in 33.line, I marked as a one to many relationship with “WithMany” keyword.

And for relationship between “Team” and “Player”, I added “Team” property and “TeamId” property (for Foreign Key) in “Player” class and configured mapping in that class.

For this relationship, I have “Team” and “League” classes. A team may play in many leagues and a league may have many teams.

I built many to many relationship between “Team” and “League” classes through “TeamLeague” class.

And we are adding DbContext to our applications for creating a bridge between OOP and Database

Now we will make migration from package manager console to create related tables according to my classes. Before migration, we should create database on SQL Server and adding its connection string to appsetting.json file like this as follows:

and we will connect our database to our application in startup.cs as follows:

Now we are ready for migration. We should open Package Manager Console in project and adding first migration with this command but be sure that Default project is EfCoreRelations.Data

After adding migration, if we can see “Migrations” folder in Data layer, that means everything is okay 🙂 Now will update database with this command

Now we can check database for tables and diagram

You can access codes of project here.

Hope to see you in the next post, I wish you healthy days.

Источник

Code First Migrations

Code First Migrations is the recommended way to evolve your application’s database schema if you are using the Code First workflow. Migrations provide a set of tools that allow:

The following walkthrough will provide an overview of Code First Migrations in Entity Framework. You can either complete the entire walkthrough or skip to the topic you are interested in. The following topics are covered:

Building an Initial Model & Database

Before we start using migrations we need a project and a Code First model to work with. For this walkthrough we are going to use the canonical Blog and Post model.

Run your application and you will see that a MigrationsCodeDemo.BlogContext database is created for you.

Enabling Migrations

It’s time to make some more changes to our model.

If you were to run the application again you would get an InvalidOperationException stating The model backing the ‘BlogContext’ context has changed since the database was created. Consider using Code First Migrations to update the database ( http://go.microsoft.com/fwlink/?LinkId=238269).

As the exception suggests, it’s time to start using Code First Migrations. The first step is to enable migrations for our context.

Run the Enable-Migrations command in Package Manager Console

This command has added a Migrations folder to our project. This new folder contains two files:

The Configuration class. This class allows you to configure how Migrations behaves for your context. For this walkthrough we will just use the default configuration. Because there is just a single Code First context in your project, Enable-Migrations has automatically filled in the context type this configuration applies to.

An InitialCreate migration. This migration was generated because we already had Code First create a database for us, before we enabled migrations. The code in this scaffolded migration represents the objects that have already been created in the database. In our case that is the Blog table with a BlogId and Name columns. The filename includes a timestamp to help with ordering. If the database had not already been created this InitialCreate migration would not have been added to the project. Instead, the first time we call Add-Migration the code to create these tables would be scaffolded to a new migration.

Multiple Models Targeting the Same Database

When using versions prior to EF6, only one Code First model could be used to generate/manage the schema of a database. This is the result of a single __MigrationsHistory table per database with no way to identify which entries belong to which model.

Starting with EF6, the Configuration class includes a ContextKey property. This acts as a unique identifier for each Code First model. A corresponding column in the __MigrationsHistory table allows entries from multiple models to share the table. By default, this property is set to the fully qualified name of your context.

Generating & Running Migrations

Code First Migrations has two primary commands that you are going to become familiar with.

We need to scaffold a migration to take care of the new Url property we have added. The Add-Migration command allows us to give these migrations a name, let’s just call ours AddBlogUrl.

We could now edit or add to this migration but everything looks pretty good. Let’s use Update-Database to apply this migration to the database.

The MigrationsDemo.BlogContext database is now updated to include the Url column in the Blogs table.

Customizing Migrations

So far we’ve generated and run a migration without making any changes. Now let’s look at editing the code that gets generated by default.

We’ll use the Add-Migration command to let Code First Migrations scaffold its best guess at the migration for us. We’re going to call this migration AddPostClass.

Code First Migrations did a pretty good job of scaffolding these changes, but there are some things we might want to change:

Our edited migration is ready to go, so let’s use Update-Database to bring the database up-to-date. This time let’s specify the –Verbose flag so that you can see the SQL that Code First Migrations is running.

Data Motion / Custom SQL

So far we have looked at migration operations that don’t change or move any data, now let’s look at something that needs to move some data around. There is no native support for data motion yet, but we can run some arbitrary SQL commands at any point in our script.

We’ll use the Add-Migration command to let Code First Migrations scaffold its best guess at the migration for us.

Our edited migration is looking good, so let’s use Update-Database to bring the database up-to-date. We’ll specify the –Verbose flag so that we can see the SQL being run against the database.

Migrate to a Specific Version (Including Downgrade)

So far we have always upgraded to the latest migration, but there may be times when you want upgrade/downgrade to a specific migration.

Let’s say we want to migrate our database to the state it was in after running our AddBlogUrl migration. We can use the –TargetMigration switch to downgrade to this migration.

This command will run the Down script for our AddBlogAbstract and AddPostClass migrations.

Getting a SQL Script

If another developer wants these changes on their machine they can just sync once we check our changes into source control. Once they have our new migrations they can just run the Update-Database command to have the changes applied locally. However if we want to push these changes out to a test server, and eventually production, we probably want a SQL script we can hand off to our DBA.

Generating Idempotent Scripts

Automatically Upgrading on Application Startup (MigrateDatabaseToLatestVersion Initializer)

If you are deploying your application you may want it to automatically upgrade the database (by applying any pending migrations) when the application launches. You can do this by registering the MigrateDatabaseToLatestVersion database initializer. A database initializer simply contains some logic that is used to make sure the database is setup correctly. This logic is run the first time the context is used within the application process (AppDomain).

We can update the Program.cs file, as shown below, to set the MigrateDatabaseToLatestVersion initializer for BlogContext before we use the context (Line 14). Note that you also need to add a using statement for the System.Data.Entity namespace (Line 5).

Now whenever our application runs it will first check if the database it is targeting is up-to-date, and apply any pending migrations if it is not.

Источник

Взаимодействие с данными. Подходы

Code First к существующей базе данных

Данное руководство устарело. Актуальное руководство: Руководство по Entity Framework Core

Далее отобразится окно, в котором в качестве имени базы данных введем userstoredb:

После создания БД добавим в нее таблицу. Нажмем правой кнопкой мыши на узел Tables и в появившемся контекстном меню выберем Add New Table.

Затем в центральном поле в режиме дизайнера создадим следующее определение таблицы:

В поле T-SQL (или графически) определим структуру и имя таблицы, типы столбцов и после этого нажмем в верхнем левом углу на кнопку Update.

В новом окне нам будет выдана некоторая информация об изменениях, производимых в бд:

Нажмем на кнопку Update Database. И после этого будет создана таблица Users.

У нас откроется форма для работы с данными, в которую введем пару строк:

База данных готова. Теперь нам надо добавить подключение в файл конфигурации приложения. В Solution Explorer найдем файл App.config и откроем его. Перед закрывающим тегом добавим новую секцию connectionStrings :

Теперь определим классы модели данных и контекста. Добавим класс модели User:

И также добавим класс контекста данных:

В конструкторе контекста данных мы передаем в конструктор базового класса имя строки подключения из файла конфигурации App.config. Так как мы определили там строку подключения UserDB ( ), то именно это значение и используется в конструкторе.

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

И для получения данных определим следующий код в консольном приложении:

Источник

Code First Migrations

Code First Migrations — это рекомендуемый способ разработки структуры базы данных в приложении при использовании рабочего процесса Code First. Code First Migrations предоставляет набор средств со следующими функциями:

Следующее пошаговое руководство содержит обзор Code First Migrations в Entity Framework. Вы можете выполнить все пошаговое руководство или сразу перейти в нужный раздел. Рассматриваются следующие темы.

Создание начальной модели базы данных &

Прежде чем мы начнем использовать миграции, нам потребуется проект и модель Code First, с которой мы будем работать. В этом пошаговом руководстве мы собираемся использовать каноническую модель Blog и Post.

Запустите приложение, и вы увидите, что база данных MigrationsCodeDemo.BlogContext создается автоматически.

Включение миграций

Пора внести дополнительные изменения в нашу модель.

Если бы вы запустили приложение снова, оно выдало бы исключение InvalidOperationException с сообщением: Модель, поддерживающая контекст «BlogContext», изменилась с момента создания базы данных. Используйте Code First Migrations для ее обновления (http://go.microsoft.com/fwlink/?LinkId=238269).

Как видно из исключения, пора приступить к использованию Code First Migrations. Сначала нужно включить миграции для нашего контекста.

Запустите команду Enable-Migrations в консоли диспетчера пакетов.

В результате этой команды в проект будет добавлена папка Migrations. В новой папке два файла:

Класс конфигурации. Этот класс позволяет настраивать поведение миграций для контекста. В этом пошаговом руководстве мы будем просто использовать конфигурацию по умолчанию. Поскольку имеется только один контекст Code First в проекте, Enable-Migrations автоматически заполняет тип контекста, к которому относится эта конфигурация.

Миграция InitialCreate. Эта миграция создана, так как мы уже использовали Code First для создания базы данных, прежде чем включили миграции. Код в этой созданной по шаблону миграции представляет объекты, которые уже были созданы в базе данных. В нашем случае это таблица Blog со столбцами BlogId и Name. Имя файла содержит метку времени для удобства упорядочения. Если бы база данных еще не была создана, миграция InitialCreate не была бы добавлена в проект. Вместо этого, когда мы впервые вызвали бы Add-Migration, код для создания этих таблиц был бы перенесен в новую миграцию.

Несколько моделей для одной целевой базы данных

При использовании версий до EF6 можно было использовать только одну модель Code First для создания схемы базы данных и управления ей. Это было связано с наличием всего одной таблицы __MigrationsHistory на базу данных и невозможностью определить, какая запись какой модели принадлежит.

Начиная с EF6, класс Configuration включает свойство ContextKey. Это уникальный идентификатор для каждой модели Code First. В соответствующий столбец в таблице __MigrationsHistory вносятся записи из нескольких моделей, которые используют таблицу совместно. По умолчанию этому свойству присвоено полное имя контекста.

Создание & запуск миграций

Вам нужно знать о двух основных командах Code First Migrations.

Нам нужно сформировать шаблон миграции для нового свойства Url. Команда Add-Migration позволяет нам давать этим миграциям имя. Давайте назовем нашу AddBlogUrl.

Теперь мы могли бы изменить или дополнить эту миграцию, но все и так в порядке. Мы используем Update-Database, чтобы применить эту миграцию к базе данных.

База данных MigrationsDemo.BlogContext обновлена и включает столбец Url в таблице Blog.

Настройка миграции

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

Мы будем использовать команду Add-Migration, чтобы с помощью Code First Migrations автоматически создать миграцию. Мы назовем эту миграцию AddPostClass.

С помощью Code First Migrations прекрасно удалось создать эти изменения по шаблону, но мы хотим изменить кое-что еще.

Измененная миграция готова к запуску, так что давайте обновим ее с помощью команды Update-Database. Давайте укажем флаг –Verbose, чтобы вы могли видеть SQL, который выполняет Code First Migrations.

Перемещение данных или настраиваемый SQL

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

Мы будем использовать команду Add-Migration, чтобы с помощью Code First Migrations автоматически создать миграцию.

Измененная миграция выглядит прекрасно, так что давайте обновим ее с помощью команды Update-Database. Необходимо указать флаг –Verbose, чтобы видеть выполнение SQL в базе данных.

Перенос в определенную версию (в том числе более раннюю)

Пока мы всегда выполняли обновление до последней миграции, но иногда могут возникнуть ситуации, когда вы хотите перейти к более поздней или более ранней версии миграции.

Предположим, мы хотим перенести базу данных в состояние до запуска миграции AddBlogUrl. Мы можем использовать переключатель –TargetMigration, чтобы перейти на эту более раннюю версию миграции.

Эта команда запустит скрипт понижения версии для миграций AddBlogAbstract и AddPostClass.

Получение скрипта SQL

Если другой разработчик хочет использовать эти изменения на своем компьютере, он может просто синхронизироваться, когда мы вернем наши изменения в систему управления версиями. Когда он получит наши новые миграции, он может выполнить команду Update-Database, чтобы применить эти изменения локально. Но если мы хотим передать эти изменения на тестовый сервер, а затем и в рабочую среду, возможно, нам потребуется скрипт SQL, который мы сможем передать нашему администратору базы данных.

Code First Migrations будет выполнять конвейер миграций, но будет не применять изменения, а записывать их в SQL-файл. Созданный скрипт автоматически открывается в Visual Studio, готовый для просмотра или сохранения.

Создание идемпотентных скриптов

Автоматическое обновление при запуске приложения (инициализатор MigrateDatabaseToLatestVersion)

Когда вы развертываете приложение, вы можете настроить автоматическое обновление базы данных (путем применения ожидающих миграций) при запуске приложения. Это можно сделать с помощью регистрации инициализатора базы данных MigrateDatabaseToLatestVersion. Инициализатор базы данных просто содержит определенную логику, которая используется для контроля правильной настройки базы данных. Эта логика выполняется при первом использовании контекста в процессе приложения (AppDomain).

Мы можем обновить файл Program.cs, как показано ниже, чтобы настроить инициализатор MigrateDatabaseToLatestVersion для BlogContext, прежде чем мы используем контекст (строка 14). Обратите внимание, что необходимо также добавить оператор using для пространства имен System.Data.Entity (строка 5).

При создании экземпляра этого инициализатора нам нужно указать тип контекста (BlogContext) и конфигурацию миграций (Configuration). Конфигурация миграций — это класс, который был добавлен в нашу папку Migrations при включении Migrations.

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

Источник

Use Code First Migrations to Seed the Database

In this section, you will use Code First Migrations in EF to seed the database with test data.

From the Tools menu, select NuGet Package Manager, then select Package Manager Console. In the Package Manager Console window, enter the following command:

This command adds a folder named Migrations to your project, plus a code file named Configuration.cs in the Migrations folder.

Open the Configuration.cs file. Add the following using statement.

Then add the following code to the Configuration.Seed method:

In the Package Manager Console window, type the following commands:

The first command generates code that creates the database, and the second command executes that code. The database is created locally, using LocalDB.

Explore the API (Optional)

Press F5 to run the application in debug mode. Visual Studio starts IIS Express and runs your web app. Visual Studio then launches a browser and opens the app’s home page.

When Visual Studio runs a web project, it assigns a port number. In the image below, the port number is 50524. When you run the application, you’ll see a different port number.

The home page is implemented using ASP.NET MVC. At the top of the page, there is a link that says «API». This link brings you to an auto-generated help page for the web API. (To learn how this help page is generated, and how you can add your own documentation to the page, see Creating Help Pages for ASP.NET Web API.) You can click on the help page links to see details about the API, including the request and response format.

The API enables CRUD operations on the database. The following summarizes the API.

Использование БД	Ориентация подхода	Подход	Описание
Новая БД	На графическую модель	Model-First

Authors	Description
GET api/authors	Get all authors.
GET api/authors/	Get an author by ID.
POST /api/authors	Create a new author.
PUT /api/authors/	Update an existing author.
DELETE /api/authors/	Delete an author.

Books	Description
GET /api/books	Get all books.
GET /api/books/	Get a book by ID.
POST /api/books	Create a new book.
PUT /api/books/	Update an existing book.
DELETE /api/books/	Delete a book.

View the Database (Optional)

When you ran the Update-Database command, EF created the database and called the Seed method. When you run the application locally, EF uses LocalDB. You can view the database in Visual Studio. From the View menu, select SQL Server Object Explorer.

In the Connect to Server dialog, in the Server Name edit box, type «(localdb)\v11.0». Leave the Authentication option as «Windows Authentication». Click Connect.

Visual Studio connects to LocalDB and shows your existing databases in the SQL Server Object Explorer window. You can expand the nodes to see the tables that EF created.

To view the data, right-click a table and select View Data.

The following screenshot shows the results for the Books table. Notice that EF populated the database with the seed data, and the table contains the foreign key to the Authors table.

Источник

Entity Framework Code First в командной работе

От переводчика: Прекрасная статья на понимание механизма миграций в Entity Framework 6 и путей решения конфликтов миграций при работе в команде. Оригинал статьи: Code First Migrations in Team Environments.

Эта статья предполагает, что вы знакомы с Entity Framework и с основами работы с ним. Иначе сначала вам нужно прочитать Code First Migrations, прежде чем продолжить.

Налейте чашечку кофе, вам нужно прочитать всю статью

Некоторые общие принципы

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

Каждый член команды должен иметь локальную базу данных для разработки

Механизм миграций использует таблицу __MigrationsHistory, чтобы хранить список миграций, которые были применены к базе данных. Если у вас в команде несколько разработчиков генерируют миграции, то при попытке работы с одной и той же базой данных (и, следовательно, с одной таблицей __MigrationsHistory) механизм миграций может испытать затруднения.
Конечно, если у вас есть члены команды, которые не создают миграции, то проблем с работой с центральной базой данных для разработки не возникнет.

Избегайте автоматических миграций

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

Автоматические миграции позволяют обновляться схеме базы данных в соответствии с текущей моделью без необходимости создания файлов с кодом миграции (code-based миграции).

Автоматические миграции будут хорошо работать в командной работе только если вы когда-нибудь использовали их и никогда не создавали никаких code-based миграций. Проблема в том, что автоматические миграции ограничены и не могут справиться с рядом операций — переименование свойства / колонки, переноса данных из одной таблицы в другую и т.д. Чтобы обработать такие сценарии, вы в конце концов будете создавать code-based миграции (и редактировать генерируемый код) что приводит к смешиванию изменений, которые обрабатываются с помощью автоматических миграций. Это делает практически невозможным слияние изменений двух разработчиков.

От переводчика: в оригинальной статье размещены 2 скринкаста, рекомендую ознакомиться

Принципы работы механизма миграций

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

Первая миграция

При добавлении первой миграции к вашему проекту, вы запускаете что-то вроде Add-Migration First в Package Manager Console. Внизу изображены шаги, которые выполняет эта команда.

На основе кода рассчитывается текущая модель (1). Затем с помощью model differ рассчитываются необходимые объекты базы данных (2) — поскольку это первая миграция, model differ для сравнения использует пустую модель. Необходимые изменения передаются в генератор кода для создания необходимого кода миграции (3), который затем добавляется в решение Visual Studio (4).

В дополнение к коду миграции, который хранится в главном файле, механизм миграции также создает дополнительные code-behind файлы. Это файлы метаданных, которые используются механизмом миграций и вы не должны их изменять. Один из этих файлов — это файл ресурсов (.resx), который содержит снимок модели на момент создания миграции. В следующем разделе вы увидите, как он используется.

В этот момент можно выполнить Update-Database, чтобы применить изменения к базе данных, а затем начать реализовывать остальные части вашего приложения.

Последующие миграции

Внесем некоторые изменения в модель — в нашем примере мы добавим свойство Url в класс Blog. Затем необходимо выполнить команду Add-Migration AddUrl, чтобы создать миграцию для применения соответствующих изменений в базе данных. Внизу изображены шаги, которые выполняет эта команда.

Так же, как в прошлый раз, текущая модель рассчитывается из кода (1). Тем не менее, на этот раз есть существующие миграции, и предыдущая модель извлекается из последней миграции (2). Эти две модели сравниваются, чтобы найти необходимые изменения в базе данных (3), и затем процесс завершается, как и раньше.

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

Зачем запариваться со снимками модели?

Что вызывает вопросы при командной работе

Процесс, рассмотренный в предыдущем разделе, прекрасно работает, если вы единственный разработчик, который работает над приложением. Он также хорошо работает в команде, если вы единственный человек, который вносит изменения в модель. В этом случае вы можете вносить изменения в модель, генерировать миграции и отправлять их в систему контроля версий. Другие разработчики могут получать такие изменения и запускать Update-Database, чтобы обновлять схему.

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

Пример слияния конфликта

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

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

Разработчик #1 и разработчик #2 делают некоторые изменения в модели EF в локальной кодовой базе. Разработчик #1 добавляет свойство Rating в класс Blog, создает миграцию AddRating для применения изменений в базу данных. Разработчик #2 добавляет свойство Readers в класс Blog, создает миграцию AddReaders. Оба разработчика запускают Update-Database, чтобы применить изменения к их локальным базам данных, а затем продолжают разработку приложения.

Примечание: Миграции начинаются с метки времени, так что наш рисунок показывает, что миграция AddReaders от разработчика #2 приходит после миграции AddRating от разработчика #1. С точки зрения работы в команде, нам без разницы в каком порядке создавались эти изменения, процесс их объединения мы рассмотрим в следующем разделе.

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

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

На этом этапе разработчик #2 может запустить Update-Database, который позволяет обнаружить новую AddRating миграцию (который не был применен к базе данных разработчика #2), и применить его. Теперь столбец Rating добавлен к таблице Blogs, и база данных синхронизирована с моделью.

Есть несколько проблем, например:

Конечно, эта миграция потерпит неудачу при Update-Database, потому что столбец Rating уже существует.

Решение конфликтов слияния

Хорошей новостью является то, что не очень трудно сливать миграции вручную, если у вы понимаете, как работает миграция. Так что если вы пропустили начало этой статьи… извините, нужно вернуться назад и прочитать первую часть статьи сначала!

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

Вариант 1: Добавление пустой «merge» миграции

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

Эта возможность может быть использована независимо от того, кто создал последнюю миграцию. В примере мы наблюдали за разработчиком #2, который генерировал последнюю миграцию. Но эти же шаги могут быть использованы, если бы разработчик #1 сгенерировал последнюю миграцию. Шаги также применяться, если есть несколько миграций.

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

Вариант 2: Обновление снимка модели последней миграции

Этот вариант очень похож на вариант 1, но удаляет лишнюю пустую миграцию.

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

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

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

Итого

Есть некоторые проблемы при использовании миграций Code First в команде. Тем не менее, общее представление о том работают миграции, и некоторые простые подходы к решению конфликтов слияния позволяют легко преодолеть эти проблемы.

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

Источник

Использование Code First Migrations для заполнения базы данных

В этом разделе вы будете использовать Code First Migrations в EF для заполнения базы данных тестовых данных.

В меню «Сервис» выберите диспетчер пакетов NuGet, а затем консоль диспетчера пакетов. В окне «Консоль диспетчера пакетов» введите следующую команду:

Эта команда добавляет папку с именем Migrations в проект, а также файл кода с именем Configuration.cs в папке Migrations.

Затем добавьте следующий код в метод Configuration.Seed :

В окне консоли диспетчера пакетов введите следующие команды:

Первая команда создает код, который создает базу данных, а вторая команда выполняет этот код. База данных создается локально с помощью LocalDB.

Изучение API (необязательно)

Нажмите F5, чтобы выполнить приложение в режиме отладки. Visual Studio запускает IIS Express и запускает веб-приложение. Затем Visual Studio запускает браузер и открывает домашнюю страницу приложения.

Когда Visual Studio запускает веб-проект, он назначает номер порта. На рисунке ниже номер порта — 50524. При запуске приложения вы увидите другой номер порта.

Домашняя страница реализована с помощью ASP.NET MVC. В верхней части страницы есть ссылка с надписью «API». Эта ссылка позволяет перейти на страницу справки, созданную автоматически для веб-API. (Чтобы узнать, как создается эта страница справки и как добавить собственную документацию на страницу, см. статью «Создание страниц справки для веб-API ASP.NET.) Вы можете щелкнуть ссылки на страницу справки, чтобы просмотреть сведения об API, включая формат запроса и ответа.

API включает операции CRUD в базе данных. Ниже приведены сводные сведения об API.

Авторы	Описание
GET API/авторы	Получите всех авторов.
GET api/authors/	Получение автора по идентификатору.
POST /api/авторы	Создайте нового автора.
PUT /api/authors/	Обновление существующего автора.
DELETE /api/authors/	Удаление автора.

Книги	Описание
GET /api/books	Получите все книги.
GET /api/books/	Получите книгу по идентификатору.
POST /api/books	Создайте новую книгу.
PUT /api/books/	Обновите существующую книгу.
DELETE /api/books/	Удаление книги.

Просмотр базы данных (необязательно)

При выполнении команды Update-Database EF создал базу данных и вызвал Seed метод. При локальном запуске приложения EF использует LocalDB. Базу данных можно просмотреть в Visual Studio. В меню Представление выберите Обозреватель объектов SQL Server.

В диалоговом окне «Подключение к серверу » в поле » Имя сервера» введите «(localdb)\v11.0». Оставьте параметр проверки подлинности как «Проверка подлинности Windows». Нажмите кнопку Соединить.

Visual Studio подключается к LocalDB и отображает существующие базы данных в окне SQL Server обозреватель объектов. Вы можете развернуть узлы, чтобы просмотреть созданные EF таблицы.

Чтобы просмотреть данные, щелкните таблицу правой кнопкой мыши и выберите «Просмотреть данные«.

На следующем снимку экрана показаны результаты для таблицы «Книги». Обратите внимание, что EF заполнил базу данных начальными данными, а таблица содержит внешний ключ в таблице «Авторы».

Источник

Custom Code First Conventions

When using Code First your model is calculated from your classes using a set of conventions. The default Code First Conventions determine things like which property becomes the primary key of an entity, the name of the table an entity maps to, and what precision and scale a decimal column has by default.

Sometimes these default conventions are not ideal for your model, and you have to work around them by configuring many individual entities using Data Annotations or the Fluent API. Custom Code First Conventions let you define your own conventions that provide configuration defaults for your model. In this walkthrough, we will explore the different types of custom conventions and how to create each of them.

Model-Based Conventions

Our Model

Let’s start by defining a simple model that we can use with our conventions. Add the following classes to your project.

Introducing Custom Conventions

Let’s write a convention that configures any property named Key to be the primary key for its entity type.

Conventions are enabled on the model builder, which can be accessed by overriding OnModelCreating in the context. Update the ProductContext class as follows:

Now, any property in our model named Key will be configured as the primary key of whatever entity its part of.

We could also make our conventions more specific by filtering on the type of property that we are going to configure:

This will configure all properties called Key to be the primary key of their entity, but only if they are an integer.

An interesting feature of the IsKey method is that it is additive. Which means that if you call IsKey on multiple properties and they will all become part of a composite key. The one caveat for this is that when you specify multiple properties for a key you must also specify an order for those properties. You can do this by calling the HasColumnOrder method like below:

This code will configure the types in our model to have a composite key consisting of the int Key column and the string Name column. If we view the model in the designer it would look like this:

Another example of property conventions is to configure all DateTime properties in my model to map to the datetime2 type in SQL Server instead of datetime. You can achieve this with the following:

Convention Classes

Another way of defining conventions is to use a Convention Class to encapsulate your convention. When using a Convention Class then you create a type that inherits from the Convention class in the System.Data.Entity.ModelConfiguration.Conventions namespace.

We can create a Convention Class with the datetime2 convention that we showed earlier by doing the following:

To tell EF to use this convention you add it to the Conventions collection in OnModelCreating, which if you’ve been following along with the walkthrough will look like this:

As you can see we add an instance of our convention to the conventions collection. Inheriting from Convention provides a convenient way of grouping and sharing conventions across teams or projects. You could, for example, have a class library with a common set of conventions that all of your organizations projects use.

Custom Attributes

Another great use of conventions is to enable new attributes to be used when configuring a model. To illustrate this, let’s create an attribute that we can use to mark String properties as non-Unicode.

Now, let’s create a convention to apply this attribute to our model:

With this convention we can add the NonUnicode attribute to any of our string properties, which means the column in the database will be stored as varchar instead of nvarchar.

One thing to note about this convention is that if you put the NonUnicode attribute on anything other than a string property then it will throw an exception. It does this because you cannot configure IsUnicode on any type other than a string. If this happens, then you can make your convention more specific, so that it filters out anything that isn’t a string.

While the above convention works for defining custom attributes there is another API that can be much easier to use, especially when you want to use properties from the attribute class.

For this example we are going to update our attribute and change it to an IsUnicode attribute, so it looks like this:

Once we have this, we can set a bool on our attribute to tell the convention whether or not a property should be Unicode. We could do this in the convention we have already by accessing the ClrProperty of the configuration class like this:

This is easy enough, but there is a more succinct way of achieving this by using the Having method of the conventions API. The Having method has a parameter of type Func

which accepts the PropertyInfo the same as the Where method, but is expected to return an object. If the returned object is null then the property will not be configured, which means you can filter out properties with it just like Where, but it is different in that it will also capture the returned object and pass it to the Configure method. This works like the following:

Custom attributes are not the only reason to use the Having method, it is useful anywhere that you need to reason about something that you are filtering on when configuring your types or properties.

Configuring Types

So far all of our conventions have been for properties, but there is another area of the conventions API for configuring the types in your model. The experience is similar to the conventions we have seen so far, but the options inside configure will be at the entity instead of property level.

One of the things that Type level conventions can be really useful for is changing the table naming convention, either to map to an existing schema that differs from the EF default or to create a new database with a different naming convention. To do this we first need a method that can accept the TypeInfo for a type in our model and return what the table name for that type should be:

This method takes a type and returns a string that uses lower case with underscores instead of CamelCase. In our model this means that the ProductCategory class will be mapped to a table called product_category instead of ProductCategories.

Once we have that method we can call it in a convention like this:

This convention configures every type in our model to map to the table name that is returned from our GetTableName method. This convention is the equivalent to calling the ToTable method for each entity in the model using the Fluent API.

One thing to note about this is that when you call ToTable EF will take the string that you provide as the exact table name, without any of the pluralization that it would normally do when determining table names. This is why the table name from our convention is product_category instead of product_categories. We can resolve that in our convention by making a call to the pluralization service ourselves.

In the following code we will use the Dependency Resolution feature added in EF6 to retrieve the pluralization service that EF would have used and pluralize our table name.

The generic version of GetService is an extension method in the System.Data.Entity.Infrastructure.DependencyResolution namespace, you will need to add a using statement to your context in order to use it.

ToTable and Inheritance

Another important aspect of ToTable is that if you explicitly map a type to a given table, then you can alter the mapping strategy that EF will use. If you call ToTable for every type in an inheritance hierarchy, passing the type name as the name of the table like we did above, then you will change the default Table-Per-Hierarchy (TPH) mapping strategy to Table-Per-Type (TPT). The best way to describe this is whith a concrete example:

By default both employee and manager are mapped to the same table (Employees) in the database. The table will contain both employees and managers with a discriminator column that will tell you what type of instance is stored in each row. This is TPH mapping as there is a single table for the hierarchy. However, if you call ToTable on both classe then each type will instead be mapped to its own table, also known as TPT since each type has its own table.

The code above will map to a table structure that looks like the following:

You can avoid this, and maintain the default TPH mapping, in a couple ways:

Execution Order

Conventions operate in a last wins manner, the same as the Fluent API. What this means is that if you write two conventions that configure the same option of the same property, then the last one to execute wins. As an example, in the code below the max length of all strings is set to 500 but we then configure all properties called Name in the model to have a max length of 250.

Because the convention to set max length to 250 is after the one that sets all strings to 500, all the properties called Name in our model will have a MaxLength of 250 while any other strings, such as descriptions, would be 500. Using conventions in this way means that you can provide a general convention for types or properties in your model and then overide them for subsets that are different.

The Fluent API and Data Annotations can also be used to override a convention in specific cases. In our example above if we had used the Fluent API to set the max length of a property then we could have put it before or after the convention, because the more specific Fluent API will win over the more general Configuration Convention.

Built-in Conventions

Because custom conventions could be affected by the default Code First conventions, it can be useful to add conventions to run before or after another convention. To do this you can use the AddBefore and AddAfter methods of the Conventions collection on your derived DbContext. The following code would add the convention class we created earlier so that it will run before the built in key discovery convention.

This is going to be of the most use when adding conventions that need to run before or after the built in conventions, a list of the built in conventions can be found here: System.Data.Entity.ModelConfiguration.Conventions Namespace.

You can also remove conventions that you do not want applied to your model. To remove a convention, use the Remove method. Here is an example of removing the PluralizingTableNameConvention.

Источник