C framework entity создание базы данных

Обновлено: 25.11.2022

Ранее мы уже видели, как Entity Framework создает базу данных из сущностной модели с помощью Code-First, но при этом не описывали этот момент более подробно. С помощью Code-First можно настроить инициализацию базы данных. Например, в статье “Использование Code-First” мы использовали следующие настройку:

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

Процесс инициализации базы данных состоит из двух этапов:

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

Во-вторых, база данных, которая будет использоваться для хранения данных, создается с использованием инициализатора базы данных, который был установлен (как показано в примере выше).

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

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

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

  • Давайте добавим в нашу модель класс User.
  • Также необходимо добавить набор в производный контекст
  • Если мы попытались добавить миграцию, возникнет ошибка, говорящая, чтоключ EntityType "User" не определен. Определите ключ для этого типа EntityType ". Поскольку EF не имеет возможности знать, что имя пользователя должно быть первичным ключом для пользователя.
  • Теперь мы будем использовать заметки к данным, поэтому нам нужно добавить инструкцию using в начало программы. CS
  • Теперь добавьте аннотацию для свойства UserName, чтобы обозначить, что это первичный ключ
  • Используйте команду adduser для добавления и миграции , чтобы сформировать шаблон миграции, чтобы применить эти изменения к базе данных.
  • Выполните команду обновления базы данных , чтобы применить новую миграцию к базе данных.

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

Schema With Users

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

7. Fluent API

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

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

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

  • Переопределите метод OnModelCreating в BloggingContext с помощью следующего кода
  • Используйте команду Add-Migration чанжедисплайнаме , чтобы сформировать шаблон миграции, чтобы применить эти изменения к базе данных.
  • Выполните команду обновления базы данных , чтобы применить новую миграцию к базе данных.

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

Schema With Display Name Renamed

Создание базы данных с некоторыми данными по умолчанию

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

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

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

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

Добавление настроек базы данных при ее инициализации

Помимо добавления данных по умолчанию, в базе данных можно определить и другие настройки, которые будут применены при инициализации. Например, вы можете создать индекс для столбца FirstName таблицы Customers, чтобы ускорить поиск по имени покупателя в этой таблице. Чтобы определить различные настройки, вы можете использовать метод DbContext.Database.ExecuteSqlCommand(), в который передается произвольная SQL-команда для настройки различных аспектов базы данных. Этот метод вызывается также, в переопределенном методе Seed() объекта инициализации. В следующем примере показано, как задать индекс для столбца CustomerId:

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

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

С помощью метода Database.SetInitializer() можно управлять поведением Code-First для создания базы данных при изменении модели. Этот метод принимает экземпляр интерфейса IDatabaseInitializer . В Entity Framework есть три класса, реализующих этот интерфейс и обеспечивающих возможность выбора поведения Code-First при инициализации базы данных:

CreateDatabaseIfNotExists

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

DropCreateDatabaseIfModelChanges

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

DropCreateDatabaseAlways

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

Помимо этих стандартных типов инициализации вы можете создать произвольный тип инициализации, реализовав интерфейс IDatabaseInitializer. В этом интерфейсе определен один обобщенный метод InitializeDatabase() принимающий объект контекста. Примером пользовательского механизма инициализации может послужить класс DontDropDbJustCreateTablesIfModelChanged, который находится в расширении EF CodeFirst пакета NuGet. С помощью этого инициализатора вы можете не беспокоится об удалении базы данных, т.к. он затрагивает только таблицы, которые изменились в модели.

Установить инициализатор, используемый по умолчанию, можно также в конфигурационном файле приложения, как показано в примере ниже:

Для этого используется раздел contexts настроек Entity Framework. При структуре этого приложения эти настройки нужно указывать в файле Web.config веб-приложения, а не в проекте, где мы создавали модель. Обратите внимание, что в этом примере показано использование атрибута disableDatabaseInitialization. Если вы установите его в true, то сможете отключить автоматическую инициализацию базы данных в приложении, как мы делали это с использованием метода Initialize(null). В атрибуте type узла context указывается полное имя класса контекста, а также имя сборки, где содержится этот класс. В атрибуте type узла databaseInitializer указывается полный тип инициализатора, обратите внимание на синтаксис этой инструкции.

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.

Tools -> Library Package Manager -> Package Manager Console

Run the Enable-Migrations command in Package Manager Console

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

  • Configuration.cs – This file contains the settings that Migrations will use for migrating BloggingContext. We don’t need to change anything for this walkthrough, but here is where you can specify seed data, register providers for other databases, changes the namespace that migrations are generated in etc.
  • _InitialCreate.cs – This is your first migration, it represents the changes that have already been applied to the database to take it from being an empty database to one that includes the Blogs and Posts tables. Although we let Code First automatically create these tables for us, now that we have opted in to Migrations they have been converted into a Migration. Code First has also recorded in our local database that this Migration has already been applied. The timestamp on the filename is used for ordering purposes.

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

  • Run the Add-Migration AddUrl command in Package Manager Console. The Add-Migration command checks for changes since your last migration and scaffolds a new migration with any changes that are found. We can give migrations a name; in this case we are calling the migration ‘AddUrl’. The scaffolded code is saying that we need to add a Url column, that can hold string data, to the dbo.Blogs table. If needed, we could edit the scaffolded code but that’s not required in this case.
  • Run the Update-Database command in Package Manager Console. This command will apply any pending migrations to the database. Our InitialCreate migration has already been applied so migrations will just apply our new AddUrl migration. Tip: You can use the –Verbose switch when calling Update-Database to see the SQL that is being executed against the database.

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

Schema With Url

Подключение и создание базы данных в Entity Framework Core

Entity Framework Core в ASP.NET Core

Для взаимодействия с MS SQL Server через Entity Framework необходим пакет Microsoft.EntityFrameworkCore.SqlServer . По умолчанию он отсутствует в проекте, поэтому его надо добавить, например, через пакетный менеджер Nuget:

Entity Framework Core в ASP.NET Core

Далее добавим в проект класс модели, с которой мы будем работать. По умолчанию в проекте уже есть предназначенная для моделей папка Models. Определим в этой папке определим новый класс User:

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

Чтобы взаимодействовать с базой данных через Entity Framework нам нужен контекст данных - класс, унаследованный от класса Microsoft.EntityFrameworkCore.DbContext . Поэтому добавим в папку Models новый класс, который назовем ApplicationContext (название класса контекста произвольное):

Свойство DbSet представляет собой коллекцию объектов, которая сопоставляется с определенной таблицей в базе данных. При этом по умолчанию название свойства должно соответствовать множественному числу названию модели в соответствии с правилами английского языка. То есть User - название класса модели представляет единственное число, а Users - множественное число.

Через параметр options в конструктор контекста данных будут передаваться настройки контекста.

В конструкторе с помощью вызова Database.EnsureCreated() по определению моделей будет создаваться база данных (если она отсутствует).

Чтобы подключаться к базе данных, нам надо задать параметры подключения. Для этого изменим файл appsettings.json , добавив в него определение строки подключения:

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

И последним шагом в настройке проекта является изменение файла Startup.cs . В нем нам надо изменить метод ConfigureServices() :

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

Watch the video

Presented By: Rowan Miller

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

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

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

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

инструменты- > библиотека диспетчер пакетов — > консоль диспетчер пакетов

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

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

  • Configuration. CS — этот файл содержит параметры, которые будут использоваться миграцией для миграции BloggingContext. Нам не нужно ничего менять в этом пошаговом руководстве, но здесь можно указать начальные данные, зарегистрировать поставщики для других баз данных, изменить пространство имен, в котором создаются миграции, и т. д.
  • < timestamp >_InitialCreate. CS — это первая миграция, которая представляет изменения, уже примененные к базе данных для того, чтобы сделать ее пустой базой данных, которая включает таблицы блогов и записей. хотя мы позволяем Code First автоматически создавать эти таблицы для нас, теперь, когда мы участвуем в миграции, они были преобразованы в миграцию. Code First также записана в локальную базу данных, к которой уже применена эта миграция. Метка времени для имени файла используется для упорядочения.

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

  • выполните команду Add-Migration аддурл в консоли диспетчер пакетов. Команда Add-Migration проверяет наличие изменений с момента последней миграции и формирует новую миграцию с любыми найденными изменениями. Мы можем присвоить имя миграции. в этом случае вызывается миграция "Аддурл". Шаблонный код говорит, что нам нужно добавить столбец URL-адреса, который может содержать строковые данные, в dbo. Таблица блогов. При необходимости можно изменить шаблонный код, но это не является обязательным в этом случае.
  • выполните команду обновления базы данных в консоли диспетчер пакетов. Эта команда применит все незавершенные миграции к базе данных. Наша InitialCreate миграция уже применена, поэтому миграция будет просто применена к нашей новой Аддурл миграции. совет. параметр – verbose можно использовать при вызове Update-Database для просмотра SQL, выполняемой в базе данных.

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

Schema With Url

Where’s My Data?

By convention DbContext has created a database for you.

  • If a local SQL Express instance is available (installed by default with Visual Studio 2010) then Code First has created the database on that instance
  • If SQL Express isn’t available then Code First will try and use LocalDB (installed by default with Visual Studio 2012)
  • The database is named after the fully qualified name of the derived context, in our case that is CodeFirstNewDatabaseSample.BloggingContext

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

View -> Server Explorer

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

Select 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.

Schema Initial

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.

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

Запуск инициализации базы данных вручную

Есть ситуации, когда вы, возможно, захотите контролировать момент создания базы данных, а не использовать автоматическую инициализацию Code-First. Для явного вызова процесса создания базы данных используется метод DbContext.Database.Initialize(), которому передается логический параметр. Если этот логический параметр равен false, то инициализация запустится только в том случае, если она уже не была вызвана ранее. Если этот логический параметр равен true, инициализация запустится в любом случае. Стоит запомнить, что этот метод следует вызвать до создания объекта контекста, его, например, можно указать в конструкторе класса контекста.

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

Давайте теперь создадим ошибку в нашей модели. Для этого первичному ключу CustomerId класса Customer явно зададим тип NVARCHAR в базе данных с помощью атрибута Column. Это вызовет ошибку инициализации модели, т.к. поле имеет тип int:

Обработка ошибок при инициализации базы данных

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

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.

  • Override the OnModelCreating method on BloggingContext with the following code
  • Use the Add-Migration ChangeDisplayName command to scaffold a migration to apply these changes to the database.
  • Run the Update-Database command to apply the new migration to the database.

The DisplayName column is now renamed to display_name:

Schema With Display Name Renamed

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.

  • Let’s add a User class to our model
  • We also need to add a set to our derived context
  • If we tried to add a migration we’d get an error saying “EntityType ‘User’ has no key defined. Define the key for this EntityType.” because EF has no way of knowing that Username should be the primary key for User.
  • We’re going to use Data Annotations now so we need to add a using statement at the top of Program.cs
  • Now annotate the Username property to identify that it is the primary key
  • Use the Add-Migration AddUser command to scaffold a migration to apply these changes to the database
  • Run the Update-Database command to apply the new migration to the database

The new table is now added to the database:

Schema With Users

The full list of annotations supported by EF is:

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.

  • Open Visual Studio
  • File -> New -> Project…
  • Select Windows from the left menu and Console Application
  • Enter CodeFirstNewDatabaseSample as the name
  • Select OK

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.

  • Project –> Manage NuGet Packages… Note: If you don’t have the Manage NuGet Packages… option you should install the latest version of NuGet
  • Select the Online tab
  • Select the EntityFramework package
  • Click Install

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.

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ную разработку с помощью новой базы данных. Мы определили модель, используя классы, которые затем использовали эту модель для создания базы данных, хранения и извлечения данных. после создания базы данных мы использовали Code First Migrations, чтобы изменить схему по мере развития нашей модели. мы также рассмотрели настройку модели с помощью заметок к данным и Fluent API.

Первое приложение на Entity Framework Core
Создание первого приложения на Entity Framework Core 5

Итак, Visual Studio создает проект с базовой примитивной структурой, где можно выделить собственно файл логики приложения - файл Program.cs . И чтобы начать работать с EntityFramework Core, нам необходимо вначале добавить в проект пакет EntityFramework Core. Для этого перейдем в проекте к пакетному менеджеру NuGet.

Однако здесь мы ищем не общий пакет для Entity Framework Core, а пакет для конкретной СУБД. Так, в данном случае мы будем использовать MS SQL Server в качестве СУБД, поэтому нам надо искать пакет Microsoft.EntityFrameworkCore.SqlServer :

Microsoft.EntityFrameworkCore.SqlServer и начало работы с EntityFramework Core 5

В качестве альтернативы для добавления пакетов можно использовать Package Manager Console . Для этого в меню Visual Studio перейдем к пункту Tools -> NuGet Package Manager -> Package Manager Console

В открывшемся внизу в Visual Studio окне Package Manager Console введем команду:

После выполнения этой команды выполним вторую команду:

Итак, необходимые пакеты добавлены. Теперь мы можем их использовать.

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

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

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

Взаимодействие с базой данных в Entity Framework Core происходит посредством специального класса - контекста данных. Поэтому добавим в наш проект новый класс, который назовем ApplicationContext и который будет иметь следующий код:

Основу функциональности Entity Framework Core для работы с MS SQL Server составляют классы, которые располагаются в пространстве имен Microsoft.EntityFrameworkCore . Среди всего набора классов этого пространства имен следует выделить следующие:

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

DbSet/DbSet : представляет набор объектов, которые хранятся в базе данных

DbContextOptionsBuilder : устанавливает параметры подключения

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

И также в классе определено одно свойство Users, которое будет хранить набор объектов User. В классе контекста данных набор объектов представляет класс DbSet . Через это свойство будет осуществляться связь с таблицей объектов User в бд.

Кроме того, для настройки подключения нам надо переопределить метод OnConfiguring . Передаваемый в него параметр класса DbContextOptionsBuilder с помощью метода UseSqlServer позволяет настроить строку подключения для соединения с MS SQL Server. В данном случае мы определяем, что в качестве сервера будет использоваться движок localdb, который предназначен специально для разработки, ( "Server=(localdb)\\mssqllocaldb" ), а файл базы данных будет называться helloappdb ( "Database=helloappdb" ).

И также стоит отметить, что по умолчанию у нас нет базы данных. Поэтому в конструкторе класса контекста определен вызов метода Database.EnsureCreated() , который при создании контекста автоматически проверит наличие базы данных и, если она отсуствует, создаст ее.

Теперь определим сам код программы, который будет взаимодействовать с созданной БД. Для этого изменим класс Program следующим образом:

Так как класс ApplicationContext через базовый класс DbContext реализует интерфейс IDisposable , то для работы с ApplicationContext с автоматическим закрытием данного объекта мы можем использовать конструкцию using .

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

И после добавления мы можем найти базу данных в окне SQL Server Object Explorer (открыть данное окно можно через меню View->SQL Server Object Explorer ). Там мы можем раскрыть и посмотреть содержимое ее таблиц:

Создание базы данных в EF Core

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

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. Создание контекста

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

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

  • Project — > управление пакетами NuGet. примечание. если у вас нет параметра " управление пакетами NuGet. ", следует установить последнюю версию NuGet
  • Выбор вкладки "в сети "
  • Выберите пакет EntityFramework
  • Щелкните Установить.

Добавьте инструкцию using для System. Data. Entity в начало программы. cs.

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

Ниже приведен полный список сведений о программе. cs, которая теперь должна содержаться в.

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

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.

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

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

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

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.

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

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

если вы используете Visual Studio 2010, также необходимо установить NuGet .

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

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

  • если локальный экземпляр экспресс-SQL доступен (устанавливается по умолчанию с Visual Studio 2010), Code First создает базу данных на этом экземпляре.
  • если SQL Express недоступна, Code First попытается использовать LocalDB (устанавливается по умолчанию с Visual Studio 2012).
  • База данных именуется после полного имени производного контекста, в нашем случае это кодефирстневдатабасесампле. BloggingContext

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

Просмотр — > Обозреватель сервера

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

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

Select Data Source

Подключение либо LocalDB, либо SQL Express в зависимости от того, какой из них был установлен.

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

Schema Initial

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

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

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

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

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

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

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

Читайте также: