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

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

1. Create an ASP.NET Core Web Application: Samples.AspCoreEF
2. Add Class Library Core to the solution: Samples.AspCoreEF.DAL.EF
3. Create model classes: Task and Person.
4. Add Context : TaskSystemDbContext
5. Register the context class with Dependency Injection.
6. Auto-Create the database.
7. 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.

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,

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.