Как подключить entity framework к проекту с

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

EF Core поставляется как пакеты NuGet. Чтобы добавить EF Core в приложение, установите пакет NuGet для поставщика базы данных, который вы хотите использовать. Список доступных поставщиков баз данных см. в разделе «Поставщики баз данных».

Установить или обновить пакеты NuGet можно в интерфейсе командной строки (CLI) .NET Core, а также в диалоговом окне или консоли диспетчера пакетов Visual Studio.

Интерфейс командной строки .NET Core

• Чтобы установить или обновить поставщик EF Core SQL Server, выполните следующую команду интерфейса командной строки .NET Core в командной строке операционной системы:

dotnet add package Microsoft.EntityFrameworkCore.SqlServer 

Диалоговое окно диспетчера пакетов NuGet в Visual Studio

• В меню Visual Studio выберите «Проект» > «Управление пакетами NuGet»
• Нажмите кнопку Обзор или откройте вкладку Обновления.
• Чтобы установить или обновить поставщик SQL Server, выберите пакет Microsoft.EntityFrameworkCore.SqlServer и подтвердите свой выбор.

Консоль диспетчера пакетов NuGet в Visual Studio

• В меню Visual Studio выберите «Сервис» > «Диспетчер пакетов NuGet» > «Консоль диспетчера пакетов»
• Чтобы установить поставщик SQL Server, в консоли диспетчера пакетов выполните следующую команду:

Install-Package Microsoft.EntityFrameworkCore.SqlServer 

Получение инструментов Entity Framework Core

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

Доступно два набора инструментов:

• Инструменты интерфейса командной строки (CLI) .NET Core можно использовать в Windows, Linux и macOS. Эти команды начинаются с dotnet ef .
• Инструменты консоли диспетчера пакетов работают в Visual Studio в Windows. Эти команды начинаются с глагола, например Add-Migration , Update-Database .

Получение инструментов CLI для .NET Core

Для инструментов CLI .NET Core требуется пакет SDK для .NET Core, указанный ранее в разделе Необходимые компоненты.

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

dotnet tool install --global dotnet-ef 

dotnet add package Microsoft.EntityFrameworkCore.Design 

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

Получение инструментов консоли диспетчера пакетов

Чтобы получить инструменты консоли диспетчера пакетов для EF Core, установите пакет Microsoft.EntityFrameworkCore.Tools . Например, в Visual Studio:

Install-Package Microsoft.EntityFrameworkCore.Tools 

Обновление до последней версии EF Core

• Каждый раз, когда мы выпускаем новую версию EF Core, мы также выпускаем новую версию поставщиков, которые являются частью проекта EF Core, например Microsoft.EntityFrameworkCore.SqlServer, Microsoft.EntityFrameworkCore.Sqlite, Microsoft.EntityFrameworkCore.Cosmos и Microsoft.EntityFrameworkCore.InMemory. Кроме того, можно просто обновить поставщик до новой версии, чтобы получить все улучшения.
• Если требуется обновить приложение, использующее сторонний поставщик базы данных, всегда ищите обновление поставщика, совместимое с нужной вам версией EF Core. Например, поставщики баз данных для версии 1.0 несовместимы с версией 2.0 среды выполнения EF Core и т. д.
• Сторонние поставщики EF Core обычно не выпускают исправления вместе со средой выполнения EF Core. Чтобы обновить приложение, которое использует стороннего поставщика до версии исправления EF Core, может потребоваться добавить прямую ссылку на отдельные компоненты среды выполнения EF Core, в частности Microsoft.EntityFrameworkCore и Microsoft.EntityFrameworkCore.Relational.

Как подключить entity framework к проекту с

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

Последнее обновление: 24.10.2018

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

В окне создания проекта в левой части выберем секцию Visual C#->Windows Desktop и в центральной части окна в качестве типа проекта выберем Console App (.NET Framework) .

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

public class User < public int Id < get; set; >public string Name < get; set; >public int Age < get; set; >>

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

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

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

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

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

using System; using System.Collections.Generic; using System.Data.Entity; namespace FirstEF6App < class UserContext : DbContext < public UserContext() :base("DbConnection") < >public DbSet Users < get; set; >> >

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

• DbContext : определяет контекст данных, используемый для взаимодействия с базой данных.
• DbModelBuilder : сопоставляет классы на языке C# с сущностями в базе данных.
• DbSet/DbSet : представляет набор сущностей, хранящихся в базе данных

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

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

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

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

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

Все подключения к источникам данных устанавливаются в секции connectionStrings , а каждое отдельное подключение представляет элемент add . В конструкторе класса контекста UserContext мы передаем в качестве названия подключения строку «DbConnection», поэтому данное название указывается в атрибуте name=»DBConnection» .

Настройку строки подключения задает атрибут connectionString . В данном случае мы устанавливаем название базы данных, с которой будем взаимодействовать — userstore.

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

using System; namespace FirstEF6App < class Program < static void Main(string[] args) < using(UserContext db = new UserContext()) < // создаем два объекта User User user1 = new User < Name = "Tom", Age = 33 >; User user2 = new User < Name = "Sam", Age = 26 >; // добавляем их в бд db.Users.Add(user1); db.Users.Add(user2); db.SaveChanges(); Console.WriteLine("Объекты успешно сохранены"); // получаем объекты из бд и выводим на консоль var users = db.Users; Console.WriteLine("Список объектов:"); foreach(User u in users) < Console.WriteLine(". - ", u.Id, u.Name, u.Age); > > Console.Read(); > > >

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

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

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

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

Объекты успешно сохранены Список объектов: 1.Tom - 33 2.Sam - 26

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

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

Возникает вопрос, а где же находится БД? Чтобы физически увидеть базу данных, мы можем подключиться к ней из Visual Studio через окно View->SQL Server Object Explorer . После этого мы можем увидеть в SQL Server Object Explorer созданную базу данных, посмотреть ее строение, таблицы, открыть и даже изменить данные в таблицах:

Физически база данных по умолчанию будет располагаться в папке пользователя, в частности, у меня она размещена в каталоге C:\Users\Eugene\ , только к ее названию буде добавляться стандартное расширение mdf — userstore.mdf.

Создание запросов

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

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

В качестве примера проекта, на котором мы будем тестировать наши запросы, мы будем использовать проект консольного приложения C#. Ранее, мы использовали для демонстрации примеров веб-приложение ASP.NET, которое было создано в статье “Использование Code-First”. Очевидно, что при рассмотрении примеров работы с данными проект веб-приложения будет громоздким, т.к. для каждого примера нужно будет редактировать разметку веб формы. Поэтому создайте новый проект, используя шаблон Console Application, как показано на рисунке ниже:

После этого нужно будет установить библиотеку Entity Framework в этот проект. Стоит отметить, что DbContext API является частью сборки EntityFramework.dll, поэтому он автоматически добавляется при установке Entity Framework в ваш проект. Для установки Entity Framework используется диспетчер пакетов NuGet, как говорилось ранее. Этот диспетчер позволяет быстро загружать нужные сборки из интернета в проект Visual Studio. Для вызова этого диспетчера можно использовать команду меню Tools —> Library Package Manager —> Manage Nuget Packages. В открывшемся диалоговом окне вы можете найти расширение Entity Framework и установить его в свой проект:

Теперь добавьте в проект папку Model, в которую добавьте новый класс Model.cs, содержащий модель данных. Модель сущностных классов должна выглядеть следующим образом:

using System; using System.Collections.Generic; using System.ComponentModel.DataAnnotations; using System.ComponentModel.DataAnnotations.Schema; namespace ExamplesEF < public class Customer < public int CustomerId < get; set; >public string FirstName < get; set; >public string LastName < get; set; >public string Email < get; set; >public int Age < get; set; >[Column(TypeName = "Image")] public byte[] Photo < get; set; >// Ссылка на заказы public List Orders < get; set; >> public class Order < public int OrderId < get; set; >public string ProductName < get; set; >public string Description < get; set; >public int Quantity < get; set; >public DateTime PurchaseDate < get; set; >// Ссылка на покупателя public Customer Customer < get; set; >> >

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

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

Далее необходимо будет добавить класс контекста, связывающий сущностные классы с базой данных. Для этого добавьте новый файл SampleContext.cs в папку Model, имеющий следующее содержимое:

using System.Data.Entity; namespace ExamplesEF < public class SampleContext : DbContext < public SampleContext() : base("MyShop") < // Указывает EF, что если модель изменилась, // нужно воссоздать базу данных с новой структурой Database.SetInitializer( new DropCreateDatabaseIfModelChanges()); > public DbSet Customers < get; set; >public DbSet Orders < get; set; >> >

После этого вы можете добавить следующий код в программу:

static void Main() < SampleContext context = new SampleContext(); context.Customers.Add(new Customer() < FirstName = "Вася", Age = 20 >); context.SaveChanges(); >

В этом примере добавляется новый покупатель в таблицу Customers. Теперь, если вы запустите программу Entity Framework создаст базу данных MyShop на локальном сервере SQLEXPRESS (если эта база данных еще не была создана). В последующих статьях мы будем показывать примеры, которые используются в этом консольном приложении. Далее мы опишем некоторые особенности запросов, которые используются в Entity Framework.

Использование запросов Entity SQL

Запросы Entity SQL используют SQL-подобный синтаксис, при этом взаимодействие с базой данных происходит с помощью вызова SQL-команд. Фактически такой подход к созданию запросов в Entity Framework идентичен использованию ADO.NET, поэтому в последующих примерах мы не будем никогда его использовать. Но давайте рассмотрим простой пример использования такого запроса в Entity Framework:

using System; using System.Linq; using System.Data.Common; using System.Data.SqlClient; using System.Data.Entity.Infrastructure; using System.Data.Entity.Core.Objects; namespace ExamplesEF < class Program < static void Main() < // Получить объект ObjectContext из DbContext ObjectContext context = (new SampleContext() as IObjectContextAdapter).ObjectContext; // Создать объект подключения и команду SqlConnection connection = new SqlConnection( @"Data Source=.\SQLEXPRESS;Initial Catalog=MyShop"); // Создать запрос ObjectQueryCustomers = context.CreateQuery("SELECT c.FirstName FROM Customers AS c"); // Отобразить имя первого покупателя в таблице Cusomers Console.WriteLine(Customers != null ? Customers.First()["FirstName"].ToString() : "Таблица пустая"); > > >

Как видите, Entity SQL напрямую не поддерживается в современных версиях Entity Framework, т.к. нам нужно использовать старый класс контекста ObjectContext. Мы получили экземпляр этого класса из объекта SampleContext, путем приведения его к интерфейсу IObjectContextAdapter. Затем мы использовали SQL-команды для загрузки данных из таблицы базы данных. Очевидно, что данный подход не использует одно из главных преимуществ Entity Framework – использование объектной модели базы данных, поэтому мы не будем его использовать далее.

Стоит отметить, что в DbContext API есть способ выполнять произвольные SQL-инструкции. Для этого служит метод ExecuteSqlCommand() класса Database, объект которого доступен через одноименное свойство класса контекста. Но при этом, этот метод был создан для того, чтобы вы могли выполнить произвольную SQL-инструкцию для обращения к базе данных (например, вы можете изменить кодировку таблицы или добавить триггер), но этот метод не стоит использовать для извлечения или работы с данными.

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

Базовым подходом к написанию запросов в Entity Framework является использование расширения языка C# — , которое предоставляет набор методов для работы с коллекциями. Подход с использованием LINQ в Entity Framework мы рассматривали в разделе LINQ to Entities, при этом этот раздел был написан еще до появления версии EF 4.1, поэтому там мы использовали класс контекста ObjectContext. Далее мы будем рассматривать запросы LINQ to Entities при использовании класса контекста, унаследованного от DbContext.

LINQ тесно интегрирован с различными шаблонами программирования .NET и обеспечивает строго типизированный язык запросов для обращения к объектам модели. Запрос определяется с помощью классов и их свойств, которые составляют модель (в отличие от Entity SQL, где мы использовали запросы SQL). Это обеспечивает ряд преимуществ:

• уменьшается время компиляции, т.к. не нужно создавать кучу дополнительных объектов, как при использовании Entity SQL;
• снижается риск допустить ошибку в запросе, который довольно высок при использовании запросов SQL;
• удобные подсказки IntelliSense IDE-среды Visual Studio позволяют довольно быстро набирать нужные запросы;
• строго-типизированные методы LINQ позволяют легко находить нужный объект сущностной модели в запросе.

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

using System; using System.Linq; namespace ExamplesEF < class Program < static void Main() < // Создаем экземпляр класса контекста SampleContext context = new SampleContext(); // Используем LINQ-запрос для извлечения первого заказчика var name = context.Customers .Select(c =>c.FirstName) .FirstOrDefault(); Console.WriteLine(name); > > >

Этот пример гораздо проще и понятней, чем тот, что мы использовали при демонстрации Entity SQL. Здесь мы использовали метод расширения LINQ – FirstOrDefault(), который выбирает первую запись из коллекции (она же таблица, в понимании EF) Customers. Стоит отметить, что базовые методы расширения LINQ находятся в пространстве имен System.Linq, при этом Entity Framework также предлагает некоторые методы расширения, которые находятся в пространстве имен System.Data.Entity.

Стоит отметить также, что LINQ поддерживает использования синтаксиса SQL в запросах (синтаксис с вызовом цепочки методов, как в предыдущем примере, называется синтаксисом точечной нотации). Эта возможность удобна для программистов, тесно работающих с базами данных и хорошо знающих языки запросов, например T-SQL. Ниже показан пример использования синтаксиса SQL, которые работает также, как и показанные выше примеры:

string name = (from customer in context.Customers select customer.FirstName) .FirstOrDefault(); Console.WriteLine(name);

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

После рассмотрения примеров использования LINQ у вас наверняка возникнет вопрос, как Entity Framework интерпретирует эти запросы на связанные запросы SQL? Ответ на этот вопрос довольно простой в контексте нашего примера. Вызов коллекции Customers объекта контекста говорит EF, что нужно сгенерировать запрос SELECT для выборки всех записей из таблицы. После этого EF видит вызов метода Select(c => c.FirstName), который указывает, что нас интересует только имя пользователя, хранящееся в столбце FirstName. Затем следует вызов метода FirstOrDefault(), что говорит EF, что нам не нужны все записи из таблицы Customers, а нужна только первая запись. В результате Entity Framework сгенерирует следующий SQL-код для обращения к базе данных:

SELECT TOP (1) [c].[FirstName] AS [FirstName] FROM [dbo].[Customers] AS [c]

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

static void Main() < // Создаем экземпляр класса контекста SampleContext context = new SampleContext(); context.Database.Log = (s =>Console.WriteLine(s)); // Используем LINQ-запрос для извлечения первого заказчика var name = context.Customers .Select(c => c.FirstName) .FirstOrDefault(); Console.WriteLine(name); >

После запуска этого примера, в консоль будет выведена SQL-команда для этого запроса. Также, SQL-запрос можно вывести, например, в окно отладчика среды Visual Studio:

// . context.Database.Log = (s => System.Diagnostics.Debug.WriteLine(s)); // . 

Класс System.Diagnostics.Debug как раз является средством взаимодействия между кодом и отладчиком Visual Studio. Сгенерированный код отображается на панели Output:

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

Отложенная компиляция LINQ-запросов

Как описывалось только что, LINQ компилирует запросы из управляемого кода в SQL-инструкции. При этом, если мы удалим вызов метода FirstOrDefault() в примере выше, сам запрос к базе данных будет выполняется не при инициализации переменной name, а при ее вызове в методе Console.WriteLine (в этом случае будет возвращаться коллекция имен пользователей из таблицы). Такой подход называется отложенным выполнением LINQ-запросов, т.е. запрос компилируется не при его объявлении, а при непосредственном вызове переменной, содержащей этот запрос, в коде.

Это обеспечивается благодаря тому, что класс DbSet, экземпляр которого мы получаем через свойство context.Customers, реализует интерфейс IQueryable. Этот интерфейс специфичен для LINQ и находится в пространстве имен System.Linq. Он является производным от интерфейса коллекций IEnumerable и обеспечивает отложенное выполнение запросов. В разделе LINQ to Objects вы можете увидеть, какие методы LINQ выполняют отложенные запросы, а какие методы вызывают запрос сразу при его объявлении. Метод FirstOrDefault() относится к неотложенным запросам, поэтому, в предыдущем примере запрос будет выполняться при инициализации переменной name.

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

В первом примере запрос выполняется при первой итерации цикла foreach, что является стандартным поведением отложенных запросов LINQ. Во втором примере мы использовали не отложенный метод ToList(), для выполнения запроса при объявлении переменной names. Понимание отложенной природы запросов в LINQ является важным при работе с Entity Framework, т.к. выполнение запроса в коде в Entity Framework означает, что мы выполняем запрос к базе данных.

Основы Entity Framework Core. Часть [0]

В этой части будет кратко рассказано о технологии Entity Framework Core, а также её установки в свой проект.

Кратко о технологии

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

Entity Framework Core (также известная как EF Core) пред­ставляет собой пакет объектно-реляционного отображения (object-relational mapping — ОRМ) производства Microsoft, который позволяет приложениям .NET Core хранить данные в реляционных базах данных. Entity Framework Core решает одну основную задачу: сохранение объектов .NET в базе данных (БД) и извлечение их в более позднее время.

Более подробно можете почитать на здесь и здесь.

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

Для начала создадим консольное приложение в Visual Studio 2022. Как вариант, это можно сделать сразу через консоль:

dotnet new sln -n EntityFrameworkBase #создаем проект dotnet new console -lang c# -n ChapterZero -o .\ChapterZero -f net6.0 #создаем решение dotnet sln .\EntityFrameworkBase.sln add .\ChapterZero #прикрепляем к проекту решение

Или запускайте Visual Studio и выполняйте пошагово действия, которые показаны ниже:

1. Создаем новый проект.

1. Создаем консольное приложение.

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

После выполненных действий в обозревателе решений (Solution Explorer) должно быть отображено следующее:

Установка EF Core в свой проект

Установить все нужные библиотеки можно как и выше через консоль:

dotnet add ChapterZero package Microsoft.EntityFrameworkCore.Design dotnet add ChapterZero package Microsoft.EntityFrameworkCore.SqlServer dotnet add ChapterZero package Microsoft.EntityFrameworkCore

Или в Visual Studio через NuGet Package Manager. Процесс показан ниже:

1. Переходим в Tools / NuGet Package Manager / Manage NuGet Packages for Solution.

1. Переходим в Browse и ищем Microsoft.EntityFrameworkCore.

1. Устанавливаем в проект.

Для Microsoft.EntityFrameworkCore.SqlServer и Microsoft.EntityFrameworkCore.Design повторить тоже самое. После установки всех нужных компонентов при переходе во вкладку Installed должно отобразиться следующее:

На этом пока что закончим. Код проекта тут.

Спасибо вам за прочтение.