The command-line interface (CLI) tools for Entity Framework Core perform design-time development tasks. For example, they create migrations, apply migrations, and generate code for a model based on an existing database. The commands are an extension to the cross-platform dotnet command, which is part of the .NET Core SDK. These tools work with .NET Core projects.
When using Visual Studio, consider using the Package Manager Console tools instead of the CLI tools. Package Manager Console tools automatically:
Works with the current project selected in the Package Manager Console without requiring that you manually switch directories.
Opens files generated by a command after the command is completed.
Provides tab completion of commands, parameters, project names, context types, and migration names.
Installing the tools
dotnet ef can be installed as either a global or local tool. Most developers prefer installing dotnet ef as a global tool using the following command:
dotnet tool install --global dotnet-ef
To use it as a local tool, restore the dependencies of a project that declares it as a tooling dependency using a tool manifest file.
Update the tool using the following command:
dotnet tool update --global dotnet-ef
Before you can use the tools on a specific project, you'll need to add the Microsoft.EntityFrameworkCore.Design package to it.
Use dotnet tool update --global dotnet-ef to update the global tools to the latest available version. If you have the tools installed locally in your project use dotnet tool update dotnet-ef. Install a specific version by appending --version <VERSION> to your command. See the Update section of the dotnet tool documentation for more details.
Using the tools
Before using the tools, you might have to create a startup project or set the environment.
Target project and startup project
The commands refer to a project and a startup project.
The project is also known as the target project because it's where the commands add or remove files. By default, the project in the current directory is the target project. You can specify a different project as target project by using the --project option.
The startup project is the one that the tools build and run. The tools have to execute application code at design time to get information about the project, such as the database connection string and the configuration of the model. By default, the project in the current directory is the startup project. You can specify a different project as startup project by using the --startup-project option.
The startup project and target project are often the same project. A typical scenario where they are separate projects is when:
The EF Core context and entity classes are in a .NET Core class library.
A .NET Core console app or web app references the class library.
The CLI tools work with .NET Core projects and .NET Framework projects. Apps that have the EF Core model in a .NET Standard class library might not have a .NET Core or .NET Framework project. For example, this is true of Xamarin and Universal Windows Platform apps. In such cases, you can create a .NET Core console app project whose only purpose is to act as startup project for the tools. The project can be a dummy project with no real code — it is only needed to provide a target for the tooling.
Important
Xamarin.Android, Xamarin.iOS, Xamarin.Mac are now integrated directly into .NET (starting with .NET 6) as .NET for Android, .NET for iOS, and .NET for macOS. If you're building with these project types today, they should be upgraded to .NET SDK-style projects for continued support. For more information about upgrading Xamarin projects to .NET, see the Upgrade from Xamarin to .NET & .NET MAUI documentation.
Why is a dummy project required? As mentioned earlier, the tools have to execute application code at design time. To do that, they need to use the .NET Core runtime. When the EF Core model is in a project that targets .NET Core or .NET Framework, the EF Core tools borrow the runtime from the project. They can't do that if the EF Core model is in a .NET Standard class library. The .NET Standard is not an actual .NET implementation; it's a specification of a set of APIs that .NET implementations must support. Therefore .NET Standard is not sufficient for the EF Core tools to execute application code. The dummy project you create to use as startup project provides a concrete target platform into which the tools can load the .NET Standard class library.
ASP.NET Core environment
You can specify the environment for ASP.NET Core projects on the command-line. This and any additional arguments are passed into Program.CreateHostBuilder.
dotnet ef database update -- --environment Production
Tip
The -- token directs dotnet ef to treat everything that follows as an argument and not try to parse them as options. Any extra arguments not used by dotnet ef are forwarded to the app.
Common options
Option
Short
Description
--json
Show JSON output.
--context <DBCONTEXT>
-c
The DbContext class to use. Class name only or fully qualified with namespaces. If this option is omitted, EF Core will find the context class. If there are multiple context classes, this option is required.
--project <PROJECT>
-p
Relative path to the project folder of the target project. Default value is the current folder.
--startup-project <PROJECT>
-s
Relative path to the project folder of the startup project. Default value is the current folder.
Updates the database to the last migration or to a specified migration.
Arguments:
Argument
Description
<MIGRATION>
The target migration. Migrations may be identified by name or by ID. The number 0 is a special case that means before the first migration and causes all migrations to be reverted. If no migration is specified, the command defaults to the last migration.
Options:
Option
Description
--connection <CONNECTION>
The connection string to the database. Defaults to the one specified in AddDbContext or OnConfiguring.
The following examples update the database to a specified migration. The first uses the migration name and the second uses the migration ID and a specified connection:
dotnet ef database update InitialCreate
dotnet ef database update 20180904195021_InitialCreate --connection your_connection_string
The following example uses the default settings and works if there is only one DbContext in the project:
dotnet ef dbcontext optimize
The following example optimizes the model for the context with the specified name and places it in a separate folder and namespace:
dotnet ef dbcontext optimize -o Models -n BlogModels -c BlogContext
dotnet ef dbcontext scaffold
Generates code for a DbContext and entity types for a database. In order for this command to generate an entity type, the database table must have a primary key.
Arguments:
Argument
Description
<CONNECTION>
The connection string to the database. For ASP.NET Core 2.x projects, the value can be name=<name of connection string>. In that case the name comes from the configuration sources that are set up for the project.
<PROVIDER>
The provider to use. Typically this is the name of the NuGet package, for example: Microsoft.EntityFrameworkCore.SqlServer.
Options:
Option
Short
Description
--data-annotations
-d
Use attributes to configure the model (where possible). If this option is omitted, only the fluent API is used.
--context <NAME>
-c
The name of the DbContext class to generate.
--context-dir <PATH>
The directory to put the DbContext class file in. Paths are relative to the project directory. Namespaces are derived from the folder names.
--context-namespace <NAMESPACE>
The namespace to use for the generated DbContext class. Note: overrides --namespace.
--force
-f
Overwrite existing files.
--output-dir <PATH>
-o
The directory to put entity class files in. Paths are relative to the project directory.
--namespace <NAMESPACE>
-n
The namespace to use for all generated classes. Defaults to generated from the root namespace and the output directory.
--schema <SCHEMA_NAME>...
The schemas of tables and views to generate entity types for. To specify multiple schemas, repeat --schema for each one. If this option is omitted, all schemas are included. If this option is used, then all tables and views in the schemas will be included in the model, even if they are not explicitly included using --table.
--table <TABLE_NAME>...
-t
The tables and views to generate entity types for. To specify multiple tables, repeat -t or --table for each one. Tables or views in a specific schema can be included using the 'schema.table' or 'schema.view' format. If this option is omitted, all tables and views are included.
--use-database-names
Use table, view, sequence, and column names exactly as they appear in the database. If this option is omitted, database names are changed to more closely conform to C# name style conventions.
--no-onconfiguring
Suppresses generation of the OnConfiguring method in the generated DbContext class.
The following example scaffolds all schemas and tables and puts the new files in the Models folder.
dotnet ef dbcontext scaffold "Server=(localdb)\mssqllocaldb;Database=Blogging;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -o Models
The following example scaffolds only selected tables and creates the context in a separate folder with a specified name and namespace:
dotnet ef dbcontext scaffold "Server=(localdb)\mssqllocaldb;Database=Blogging;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -o Models -t Blog -t Post --context-dir Context -c BlogContext --context-namespace New.Namespace
The following example reads the connection string from the project's configuration set using the Secret Manager tool.
dotnet user-secrets set ConnectionStrings:Blogging "Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=Blogging"
dotnet ef dbcontext scaffold Name=ConnectionStrings:Blogging Microsoft.EntityFrameworkCore.SqlServer
The following example skips scaffolding an OnConfiguring method. This can be useful when you want to configure the DbContext outside of the class. For example, ASP.NET Core apps typically configure it in Startup.ConfigureServices.
dotnet ef dbcontext scaffold "Server=(localdb)\mssqllocaldb;Database=Blogging;User Id=myUsername;Password=myPassword;" Microsoft.EntityFrameworkCore.SqlServer --no-onconfiguring
dotnet ef dbcontext script
Generates a SQL script from the DbContext. Bypasses any migrations.
Removes the last migration, rolling back the code changes that were done for the latest migration.
Options:
Option
Short
Description
--force
-f
Revert the latest migration, rolling back both code and database changes that were done for the latest migration. Continues to roll back only the code changes if an error occurs while connecting to the database.
The starting migration. Migrations may be identified by name or by ID. The number 0 is a special case that means before the first migration. Defaults to 0.
<TO>
The ending migration. Defaults to the last migration.
Options:
Option
Short
Description
--output <FILE>
-o
The file to write the script to.
--idempotent
-i
Generate a script that can be used on a database at any migration.
The source for this content can be found on GitHub, where you can also create and review issues and pull requests. For more information, see our contributor guide.
.NET
feedback
.NET
is an open source project. Select a link to provide feedback:
This module guides you through the steps to create a data access project. You connect to a relational database and construct create, read, update, and delete (CRUD) queries by using Entity Framework Core (EF Core).