Entity Framework Core supports Database-First approach via the Scaffold-DbContext command of Package Manager Console. This command scaffolds a DbContext and entity type classes for a specified database.

This tutorial shows how to create a simple console application, powered by Entity Framework Core and using Database-First approach. In less than 10 minutes you will have a ready-to-use data access layer for your business objects.

This tutorial is for .NET Core. For Full .NET Framework see Entity Framework Core Database-First Tutorial for Full .NET Framework.

Requirements

This tutorial requires the following:

• Visual Studio 2017 or higher (for Entity Framework Core 3.1 - Visual Studio 2019)
• If you want to use Entity Framework Core 2.2 - .NET Core SDK 2.2. For Entity Framework Core 3.1 - .NET Core SDK 3.0
• Latest version of NuGet Package Manager
• Latest version of Windows PowerShell

We will use the tables, we have created in the Creating Database Objects tutorial. In this tutorial it is assumed that you already have the database objects created. If you haven't created them yet, please do it before starting this tutorial.

Additionally let's create one more table to demonstrate the code generated for relation between entities.

CREATE TABLE EMP(
  EmpNo INT NOT NULL,
  EName VARCHAR(10),
  Job VARCHAR(9),
  Mgr INT,
  HireDate DATE,
  Sal FLOAT,
  Comm FLOAT,
  deptno REFERENCES DEPT,
  PRIMARY KEY (EmpNo)
);

Creating New Project

1. Open Visual Studio
2. On the File menu point to New and then click Project. The New Project dialog box will open.
3. On the left side of the dialog box select Installed -> Visual C# -> .NET Core.
4. On the right side of the dialog box select Console App.
5. Enter the project name and location if necessary.
6. Click OK. A new project will be created.

Installing NuGet Packages

After we created a new project, we need to add the necessary NuGet packages to it.

Now let's install the necessary packages:

1. On the Tools menu point to NuGet Package Manager and then click Package Manager Console.
2. For Entity Framework Core 5, run the following command in the Package Manager Console:
   Install-Package Microsoft.EntityFrameworkCore.Tools
   
   
3. For Entity Framework Core 3.1, run the following command in the Package Manager Console:
   Install-Package Microsoft.EntityFrameworkCore.Tools -Version 3.1.10
   
   For Entity Framework Core 2.2, run the following command in the Package Manager Console:
   Install-Package Microsoft.EntityFrameworkCore.Tools -Version 2.2.6
   
   For Entity Framework Core 1.1, the command will be the following:
   Install-Package Microsoft.EntityFrameworkCore.Tools -Version 1.1.5
4. For Entity Framework Core 3.1 or 5.0 run the following command in the Package Manager Console:
   Install-Package Devart.Data.SQLite.EFCore
   
   For Entity Framework Core 1.1, the command will be the following:
   Install-Package Devart.Data.SQLite.EFCore.Design

Note that the dotConnect for SQLite assembly for Entity Framework Core 2.2 is not available via NuGet packages anymore. It is installed by the dotConnect for SQLite installer to the \Entity\EFCore2\netstandard2.0\ subfolder of the dotConnect for SQLite installation folder.

Creating a Model From the Database

For Entity Framework Core, creating a model from the database is as easy as entering the Scaffold-DbContext command with a connection string and a provider as parameters. For example, you can run the following command in the Package Manager Console:

Scaffold-DbContext "DataSource=mydatabase.db;" Devart.Data.SQLite.Entity.EFCore

If you have other tables in your database, you may use additional parameters - -Schemas and -Tables - to filter the list of schemas and/or tables that are added to the model. For example, you can use the following command:

Scaffold-DbContext "DataSource=mydatabase.db;" Devart.Data.SQLite.Entity.EFCore -Tables DEPT,EMP

As the result, a context class and entity classes are generated, based on the Dept and Emp tables.

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
   public partial class Dept
   {
       public Dept()
       {
           Emp = new HashSet<Emp>();
       }

       public int Deptno { get; set; }
       public string Dname { get; set; }
       public string Loc { get; set; }

       public virtual ICollection<Emp> Emp { get; set; }
   }
}

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
   public partial class Emp
   {
       public int Empno { get; set; }
       public string Ename { get; set; }
       public string Job { get; set; }
       public int Mgr { get; set; }
       public DateTime Hiredate { get; set; }
       public double Sal { get; set; }
       public double Comm { get; set; }
       public int Deptno { get; set; }

       public virtual Dept DeptnoNavigation { get; set; }
   }
}

Entity classes are just simple classes, representing the data, stored in the database. The context represents a session with the database and allows you to query and save instances of the entity classes.

using System;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;

namespace ConsoleApplication1
{
    public partial class ModelContext : DbContext
    {
        public virtual DbSet Dept { get; set; }
        public virtual DbSet Emp { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            #warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.
            optionsBuilder.UseSQLite(@"DataSource=mydatabase.db;");
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Dept>(entity =>
            {
                entity.HasKey(e => e.Deptno)
                    .HasName("PK_DEPT");

                entity.ToTable("DEPT", "DEMOBASE");

                entity.Property(e => e.Deptno).HasColumnName("DEPTNO");

                entity.Property(e => e.Dname)
                    .HasColumnName("DNAME")
                    .HasColumnType("varchar")
                    .HasMaxLength(14);

                entity.Property(e => e.Loc)
                    .HasColumnName("LOC")
                    .HasColumnType("varchar")
                    .HasMaxLength(13);
            });

            modelBuilder.Entity<Emp>(entity =>
            {
                entity.HasKey(e => e.Empno)
                    .HasName("PK_EMP");

                entity.ToTable("EMP", "DEMOBASE");

                               entity.Property(e => e.Deptno).HasColumnName("DEPTNO");

                entity.Property(e => e.Ename)
                    .HasColumnName("ENAME")
                    .HasColumnType("varchar")
                    .HasMaxLength(10);

                entity.Property(e => e.Hiredate)
                    .HasColumnType("date");

                entity.Property(e => e.Job)
                    .HasColumnType("varchar")
                    .HasMaxLength(9);

               entity.HasOne(d => d.DeptnoNavigation)
                    .WithMany(p => p.Emp)
                    .HasForeignKey(d => d.Deptno)
            });
        }
    }
}

Here we may comment or delete the warning about the connection string. After this we can start using our model to retrieve and modify data.

Using Model

Open your Program.cs file and paste the following code instead of the Main function:

        static void Main(string[] args)
        {
            using (var db = new ModelContext())
            {
                // Creating a new department and saving it to the database
                var newDept = new Dept();
                newDept.Deptno = 60;
                newDept.Dname = "Development";
                newDept.Loc = "Houston";
                db.Dept.Add(newDept);
                var count=db.SaveChanges();
                Console.WriteLine("{0} records saved to database", count);

                // Retrieving and displaying data
                Console.WriteLine();
                Console.WriteLine("All departments in the database:");
                foreach (var dept in db.Dept)
                {
                    Console.WriteLine("{0} | {1}", dept.Dname, dept.Loc);
                }
            }
        }

After this, on the Debug menu, click Run without debugging.

See Also

Compatibility