Build Persisting Layer With ASP.NET Core 2.0 And EF Core 2.0 Using Code First Approach

Rebai Hamida

8y20.6k7100Article

ASP.NET Core Code First ApproachEF Core 2.0Build Persisting Layer With ASP.NET Core 2.0

7 Comments

Join the conversation! Your thoughts help the community grow.

Michael Markos7y ago
When add-migration display this error Your target project 'CRUDTask' doesn't match your migrations assembly 'DAL'. Either change your target project or change your migrations assembly.Change your migrations assembly by using DbContextOptionsBuilder. E.g. options.UseSqlServer(connection, b => b.MigrationsAssembly("CRUDTask")). By default, the migrations assembly is the assembly containing the DbContext. Change your target project to the migrations project by using the Package Manager Console's Default project drop-down list, or by executing "dotnet ef" from the directory containing the migrations project.
Faisal Chaudhary8y ago
Can we do dependency injection in a class library ? e.g private TaskSystemDbContext _taskContext; public MyClassLib(TaskSystemDbContext taskContext) { _taskContext = taskContext; }
Imed Killeni8y ago
Nice article! Thank you for sharing!
Tridip Bhattacharjee8y ago
Yes this one public void ConfigureServices(IServiceCollection services){ services.AddDbContext<SchoolContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"))); services.AddMvc(); } which you did..........thanks
Tridip Bhattacharjee8y ago
You inject dbcontext in controller PersonController(TaskSystemDbContext taskContext) but where is there code where you said to inject it, i mean DI mapping is missing in code.
- Rebai Hamida8y ago
  Thank you for your comment, do you mean this services.AddDbContext<TaskSystemDbContext>(dbcontextoption => dbcontextoption.UseSqlServer(sqlconnection));
- Rebai Hamida8y ago
  I inject the DBContext using AddDBContext

Introduction

I wrote this article when the .NET Core 1.0 was introduced as a stable version. But now, we have a lot of changes in the current version, Core 2.1.

We will focus on the Code First approach in .NET Core 2.0.

So, let’s start with the prerequisites.

Visual Studio 2017 v 15.5.x
.NET Core 2.0. https://www.microsoft.com/net/download/all
SQL Server 2014 / 2016 Server Management Studio with a default localdb.
PostgreSQL

Contents

Create an ASP.NET Core Web Application: Samples.AspCoreEF
Add Class Library Core to the solution: Samples.AspCoreEF.DAL.EF
Create model classes: Task and Person.
Add Context : TaskSystemDbContext
Register the context class with Dependency Injection.
Auto-Create the database.
Add Web API controller and test using Postman.

Create an ASP.NET Core Web Application

Suppose that we have created our Database as in the previous article.

Open Visual Studio > File > New Project> Select “ASP.NET Core Web Application” > Enter Name “Samples.AspCoreEF” & Location > OK.

ASP.NET Core

Afterward, we will select the template “Web Application” and we will confirm the choice by clicking OK. This project will be the presentation layer of this sample that includes the Razor pages and individual classes (.cs) as code behind, and in the next part, we will add the new project that will contain the EF Core 2.0 and will be added as a reference to the presentation Layer, in this way we will ensure a separation of Concern.

Add Class Library Core to the solution - Samples.AspCoreEF.DAL.EF

Open Visual Studio > File > New Project> Select “Class Library (.NET Core)” > Enter Name “Samples.AspCoreEF. DAL.EF” & Location > OK.

The project Samples.AspCoreEF.DAL.EF will contain our Entity Framework models, migrations, and context.

In the previous article, we had two models: Person and Task, we will use the same.

public class Person {
public int Id {
get;
set;
}
public string Name {
get;
set;
}
public DateTime CreationDate {
get;
set;
}
public DateTime UpdatedDate {
get;
set;
}
}
public class Task {
public string Id {
get;
set;
}
public string Title {
get;
set;
}
public string Description {
get;
set;
}
public DateTime CreationTime {
get;
set;
}
public TaskState State {
get;
set;
}
public virtual Person AssignedTo {
get;
set;
}
public DateTime CreationDate {
get;
set;
}
public DateTime UpdatedDate {
get;
set;
}
public Task() {
CreationTime = DateTime.UtcNow;
State = TaskState.Open;
}
}
public enum TaskState: byte {
/// <summary>
/// The task is Open.
/// </summary>
Open = 0,
/// <summary>
/// The task is active.
/// </summary>
Active = 1,
/// <summary>
/// The task is completed.
/// </summary>
Completed = 2,
/// <summary>
/// The task is closed.
/// </summary>
Closed = 3
}

We install the Entity Framework Core package for the database provider (EF Core DB Provider) from NuGet Package Manager Console in Visual Studio 2017

Install-Package Microsoft.EntityFrameworkCore.SqlServer -Version 2.0.1

Or we just open the Search with Microsoft.EntityFrameworkCore.SqlServer in Nuget Package Manager and we click on Install:

We do the same for PostgreSQL; we will add Npgsql.EntityFrameworkCore.PostgreSQL, Npgsql.EntityFrameworkCore.PostgreSQL.Design reference to the project from NuGet Package Manager Console in Visual Studio 2017

Install-Package Npgsql.EntityFrameworkCore.PostgreSQL -Version 2.0.1
Install-Package Npgsql.EntityFrameworkCore.PostgreSQL.Design -Version 1.1.1

We need to install the Entity Framework Tool to run EF Core Commands like migrations, scaffolding, etc. So, we will add Microsoft.EntityFrameworkCore.Tools package

Or: Install-Package Microsoft.EntityFrameworkCore.Tools -Version 2.0.1

We will finish by installing this design package: Microsoft.VisualStudio.Web.CodeGeneration.Design

Add Context: TaskSystemDbContext

We have to add a new folder called EntityFramework, where we will add our context, as given below.

public class TaskSystemDbContext: DbContext {
public TaskSystemDbContext(DbContextOptions < TaskSystemDbContext > dbcontextoption): base(dbcontextoption) {}
public DbSet < Person > Persons {
get;
set;
}
public DbSet < Task > Tasks {
get;
set;
}
}

So, we will have this structure,

ASP.NET Core

Register the context class with Dependency Injection

We will work now in ASP.NET Web Application to be able to register our context.

We will start by adding Samples.AspCoreEF.DAL.EF as a reference to Samples.AspCoreEF.

Afterwards, we will add the needed references to generate our database as before.

In the Startup.cs, we will add two blocks to show you how we can register context class in two different ways. Thus, this method looks like,

publicvoid ConfigureServices(IServiceCollection services)
AddMvc();

We will add this block related to the connection to SQL Server database.

//Using SQL Server
varsqlconnection = @"Server=(localdb)\v11.0;Database=samplecoreEF;Trusted_Connection=True;";
AddDbContext<TaskSystemDbContext>(dbcontextoption => dbcontextoption.UseSqlServer(sqlconnection));

SQLconnection is a hardcoded string and we use UseSQLServer to connect to the database.

In ASP.NET Core, we use store configuration string in a Json file: appsettings.json.

Thus, we will call it in Startup.cs in the given way.

//Using Postgresql
varconnectionString = Configuration["DbContextSettings:ConnectionString"];
AddDbContext < TaskSystemDbContext > (opts => opts.UseNpgsql(connectionString));

Tools

NuGet Package Manager and then we click on Package Manager Console menu.

Type Add-Migration CoreMigration and enter this is used to scaffold a migration by creating the initial tables for every model. If we get an error like this message “The term 'add-migration' is not recognized as the name of a cmdlet”, please close and reopen Visual Studio.

If we check the databases, we will find the tables are added automatically.

If the database exists, we use Update-database to apply the new migration to the database.

Add Web API controller and test, using Postman.

Now, we will add new API Controller called PersonController.

[Route("api/persons")]
public class PersonController: Controller {
private TaskSystemDbContext _taskContext;
public PersonController(TaskSystemDbContext taskContext) {
_taskContext = taskContext;
}
// GET: api/values
[HttpGet]
public IEnumerable < string > Get() {
//List<Person> list1 = new List<Person>();
//foreach (var person in _taskContext.Persons)
// list1.Add(person);
//var list = list1.Select(p => p.Name);
//return list;
var list = _taskContext.Persons.ToList().Select(p => p.Name);
return list;
}

Code on github.