Руководство по созданию вашего первого приложения с использованием Entity Framework Core

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

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

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

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

Настройка проекта в Visual Studio

Прежде всего, необходимо создать новый проект в Visual Studio, используя шаблон консольного приложения. В меню выберите «Создать новый проект» и среди доступных шаблонов найдите консольное приложение. Задайте имя проекту и укажите путь для его сохранения.

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

Install-Package Microsoft.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.Sqlite

Эти пакеты предоставят основные функции для работы с базой данных и поддержкой SQLite. Также следует установить дополнительные пакеты для работы с миграциями и конфигурацией:

Install-Package Microsoft.EntityFrameworkCore.Tools

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

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
namespace YourNamespace
{
class Program
{
static void Main(string[] args)
{
var serviceProvider = new ServiceCollection()
.AddDbContext(options =>
options.UseSqlite("Data Source=app.db"))
.BuildServiceProvider();
using (var context = serviceProvider.GetRequiredService())
{
context.Database.Migrate();
}
}
}
}

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

Создайте новый файл AppDbContext.cs и добавьте в него следующий код:

using Microsoft.EntityFrameworkCore;
namespace YourNamespace
{
public class AppDbContext : DbContext
{
public DbSet<MockCar> MockCars { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlite("Data Source=app.db");
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<MockCar>().HasKey(c => c.Id);
}
}
}

Класс AppDbContext является центральным для взаимодействия с базой данных. В нём определены DbSet-свойства, которые будут использоваться для работы с таблицами в базе данных. Например, свойство MockCars будет представлять таблицу автомобилей.

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

namespace YourNamespace
{
public class MockCar
{
public int Id { get; set; }
public string Make { get; set; }
public string Model { get; set; }
public int Year { get; set; }
}
}

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

Шаг	Описание
1	Создание нового проекта консольного приложения в Visual Studio
2	Установка необходимых пакетов NuGet для работы с базой данных
3	Настройка подключения к базе данных в файле Program.cs
4	Создание класса контекста базы данных AppDbContext
5	Создание модели данных MockCar

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

Обычно для разработки современных приложений используются среды разработки, такие как Visual Studio или JetBrains Rider. Чтобы начать работу, нужно создать новый проект, выбрав соответствующий шаблон. Для работы с базами данных может понадобиться шаблон «ASP.NET Core Web Application» или «Console App», в зависимости от ваших задач.

После создания проекта необходимо настроить подключение к базе данных. Для этого в файле конфигурации укажите строку подключения к СУБД. Например, для MySQL это может выглядеть так:

"ConnectionStrings": {
"DefaultConnection": "Server=localhost;Database=repairservice;User=root;Password=password;"
}

Также, в процессе создания проекта добавим необходимые библиотеки. Эти библиотеки включают средства для работы с базами данных и ORM (Object-Relational Mapping). Для установки пакетов можно использовать команду dotnet add package или инструменты управления пакетами в Visual Studio.

На следующем этапе добавления моделей, которые будут представлять данные в приложении. Модели – это классы, соответствующие таблицам в базе данных. Например, создадим класс Car с такими свойствами, как Id, Make, Model, Year:

public class Car
{
public int Id { get; set; }
public string Make { get; set; }
public string Model { get; set; }
public int Year { get; set; }
}

После создания моделей, добавим контекст данных. Контекст – это класс, который наследует от DbContext и содержит DbSet свойства для каждой модели. Например, для модели Car добавим следующий контекст:

public class RepairServiceContext : DbContext
{
public DbSet<Car> Cars { get; set; }
public RepairServiceContext(DbContextOptions<RepairServiceContext> options)
: base(options)
{
}
}

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

services.AddDbContext<RepairServiceContext>(options =>
options.UseMySQL(Configuration.GetConnectionString("DefaultConnection")));

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

Установка и добавление необходимых пакетов NuGet

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

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

Основные пакеты, которые необходимо добавить:

Пакет	Описание
Microsoft.EntityFrameworkCore	Базовая библиотека для работы с ORM, включающая основные функции и классы.
Microsoft.EntityFrameworkCore.Tools	Набор инструментов, который поможет выполнять миграции и другие задачи.
Microsoft.EntityFrameworkCore.SqlServer	Пакет, позволяющий использовать SQL Server в качестве базы данных.

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

Install-Package Microsoft.EntityFrameworkCore
Install-Package Microsoft.EntityFrameworkCore.Tools
Install-Package Microsoft.EntityFrameworkCore.SqlServer

После установки пакетов нужно настроить контекст базы данных. Создадим новый класс, который будет представлять наш контекст. Этот класс наследуется от DbContext и будет содержать DbSet’ы для каждого типа объектов, с которыми мы будем работать.

Пример кода для создания класса контекста:

using Microsoft.EntityFrameworkCore;
namespace MyApplication
{
public class ApplicationContext : DbContext
{
public ApplicationContext(DbContextOptions options) : base(options)
{
}
// DbSet для каждой модели
public DbSet MyModels { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Настройки для моделей
modelBuilder.Entity()
.Property(m => m.Name)
.HasColumnType("varchar(100)")
.IsRequired();
base.OnModelCreating(modelBuilder);
}
}
}

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

{
"ConnectionStrings": {
"DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=MyDatabase;Trusted_Connection=True;"
}
}

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

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

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

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

Шаги по созданию контекста данных

Для начала создадим новый класс контекста данных, который будем использовать для взаимодействия с базой данных. Назовём его ApplicationContext. Этот класс будет наследовать DbContext и включать свойства для каждой модели, с которой будем работать.

Обычно контекст данных выглядит следующим образом:

using Microsoft.EntityFrameworkCore;
public class ApplicationContext : DbContext
{
public ApplicationContext(DbContextOptions options) : base(options) { }
public DbSet MyModels { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
// Дополнительная конфигурация моделей
}
}

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

Настройка соединения с базой данных

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

{
"ConnectionStrings": {
"DefaultConnection": "server=localhost;database=mydatabase;user=myuser;password=mypassword;"
}
}

Далее настроим контекст данных в классе Startup или в файле Program.cs в методе CreateHostBuilder:

using Microsoft.Extensions.DependencyInjection;
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext(options =>
options.UseMySql(Configuration.GetConnectionString("DefaultConnection"),
ServerVersion.AutoDetect(Configuration.GetConnectionString("DefaultConnection"))));
// Другие сервисы
}
// Остальные методы
}

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

Пример использования контекста данных

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

using Microsoft.AspNetCore.Mvc;
public class MyController : ControllerBase
{
private readonly ApplicationContext _context;
public MyController(ApplicationContext context)
{
_context = context;
}
[HttpGet]
public async Task GetAll()
{
var data = await _context.MyModels.ToListAsync();
return Ok(data);
}
[HttpPost]
public async Task Create(MyModel model)
{
_context.MyModels.Add(model);
await _context.SaveChangesAsync();
return CreatedAtAction(nameof(GetAll), new { id = model.Id }, model);
}
[HttpDelete("{id}")]
public async Task Delete(int id)
{
var model = await _context.MyModels.FindAsync(id);
if (model == null)
{
return NotFound();
}
_context.MyModels.Remove(model);
await _context.SaveChangesAsync();
return NoContent();
}
}

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

Определение моделей данных и их связей

Для начала создадим модель данных, которая будет представлять сущность в нашем приложении. Допустим, у нас имеется сервис по ремонту автомобилей – RepairService. Мы начнем с определения модели Car, которая будет включать в себя основные характеристики автомобиля, такие как Make, Model, Year, UserId и другие.

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

public class Car
{
public int Id { get; set; }
public string Make { get; set; }
public string Model { get; set; }
public int Year { get; set; }
public string UserId { get; set; }
}

Теперь, когда у нас есть модель Car, добавим еще одну модель – User, которая будет представлять владельцев автомобилей:

public class User
{
public string Id { get; set; }
public string Name { get; set; }
public string Email { get; set; }
public ICollection<Car> Cars { get; set; }
}

С помощью свойства Cars мы определяем связь «один ко многим» между User и Car. Это означает, что один пользователь может владеть несколькими автомобилями.

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

public class RepairServiceContext : DbContext
{
public DbSet<Car> Cars { get; set; }
public DbSet<User> Users { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseMySql("your_connection_string", ServerVersion.AutoDetect("your_connection_string"));
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<User>()
.HasMany(u => u.Cars)
.WithOne()
.HasForeignKey(c => c.UserId);
}
}

В этом классе RepairServiceContext мы добавляем DbSet для каждой модели, чтобы они стали доступными через контекст. Метод OnConfiguring настраивает подключение к базе данных с использованием ServerVersion.AutoDetect, а метод OnModelCreating задает правила создания связей между объектами моделей.

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

Реализация класса контекста данных на основе DbContext

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

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

Шаги для создания класса контекста данных

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

   • Добавьте новый класс в ваш проект, который будет наследовать DbContext. Назовите его, например, ApplicationContext.
   • Для этого можно использовать команду в консоли диспетчера пакетов или вручную создать файл.

2. Добавление конструктора и конфигурация параметров

   • Определите конструктор, который принимает DbContextOptions и передает их в базовый класс. Это необходимо для конфигурации контекста.
   • Конструктор будет выглядеть следующим образом:

     public ApplicationContext(DbContextOptions<ApplicationContext> options) : base(options) { }

3. Определение наборов данных

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

     public DbSet<Worker> Workers { get; set; }

4. Конфигурация моделей

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

     protected override void OnModelCreating(ModelBuilder modelBuilder) {
     modelBuilder.Entity<Worker>().HasKey(w => w.WorkerId);
     }

5. Регистрация контекста в приложении

   • В файле Program.cs необходимо зарегистрировать контекст как сервис в методе ConfigureServices. Это позволит использовать его через механизм внедрения зависимостей (DI).

     services.AddDbContext<ApplicationContext>(options =>
     options.UseSqlite(Configuration.GetConnectionString("DefaultConnection")) );

Преимущества использования DbContext

• Автоматическое управление подключениями к базе данных.
• Удобный API для выполнения CRUD операций.
• Возможность использования мощных инструментов для конфигурации и миграций.
• Поддержка различных баз данных, включая SQLite, SQL Server и MySQL.

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

Работа с базой данных

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

После установки пакетов, создадим модель данных. Для примера, создадим класс Car с такими свойствами, как WorkerId и Name:

public class Car
{
public int WorkerId { get; set; }
public string Name { get; set; }
}

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

public class ApplicationContext : DbContext
{
public DbSet<Car> Cars { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseSqlite("Data Source=cars.db");
}
}

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

"ConnectionStrings": {
"DefaultConnection": "Data Source=cars.db"
}

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

dotnet ef migrations add InitialCreate
dotnet ef database update

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

using (var context = new ApplicationContext())
{
var car1 = new Car { WorkerId = 1, Name = "Toyota" };
var car2 = new Car { WorkerId = 2, Name = "Honda" };
context.Cars.Add(car1);
context.Cars.Add(car2);
context.SaveChanges();
}

В случае необходимости, мы можем настроить дополнительные параметры контекста данных, такие как кодировка (например, collate utf8mb4) и версию сервера (например, ServerVersion.AutoDetect(connection)).

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

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

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

Класс	Свойство	Тип данных	Описание
Car	WorkerId	int	Идентификатор работника
Car	Name	string	Название автомобиля

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

Создание и применение миграций для базы данных

Для начала необходимо убедиться, что ваш проект правильно настроен и все необходимые пакеты установлены. Вам потребуется пакет Microsoft.EntityFrameworkCore.Tools, который можно добавить через NuGet. Откройте Package Manager Console в Visual Studio и выполните следующую команду:

Install-Package Microsoft.EntityFrameworkCore.Tools

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

using Microsoft.EntityFrameworkCore;
namespace MyApplication.Data
{
public class ApplicationContext : DbContext
{
public ApplicationContext(DbContextOptions options)
: base(options)
{
}
public DbSet<Worker> Workers { get; set; }
public DbSet<Document> Documents { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Настройка сущностей
}
}
}

Для настройки подключения можно использовать DbContextOptionsBuilder в Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext<ApplicationContext>(options =>
options.UseMySql(Configuration.GetConnectionString("DefaultConnection"),
new MySqlServerVersion(new Version(8, 0, 21))));
}

Создайте первую миграцию с помощью команды в Package Manager Console:

Add-Migration InitialCreate

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

Update-Database

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

public class Worker
{
public int WorkerId { get; set; }
public string Name { get; set; }
public string Position { get; set; }
public DateTime HireDate { get; set; }
public string PhoneNumber { get; set; }  // Новое свойство
}

Add-Migration AddPhoneNumberToWorker

Update-Database

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

В завершение, миграции позволяют не только создавать и изменять структуру базы данных, но и откатывать изменения, если это необходимо. Для этого можно использовать команду Remove-Migration, чтобы отменить последнюю миграцию, или Update-Database -Migration <MigrationName>, чтобы откатиться к конкретной миграции.

Видео:

СОЗДАЛ FULLSTACK ПРИЛОЖЕНИЕ НА ASP.NET CORE MVC ЗА 10 МИНУТ