Getting Started with ASP.NET Core and Entity Framework 6¶
By Paweł Grudzień and Damien Pontifex
This article will show you how to use Entity Framework 6 inside an ASP.NET Core application.
Sections:
Prerequisites¶
Before you start, make sure that you compile against full .NET Framework in your project.json as Entity Framework 6 does not support .NET Core. If you need cross platform features you will need to upgrade to Entity Framework Core.
In your project.json file specify a single target for the full .NET Framework:
"frameworks": {
"net46": {}
}
Setup connection strings and dependency injection¶
The simplest change is to explicitly get your connection string and setup dependency injection of your DbContext
instance.
In your DbContext
subclass, ensure you have a constructor which takes the connection string as so:
1 2 3 4 5 6 | public class ApplicationDbContext : DbContext
{
public ApplicationDbContext(string nameOrConnectionString) : base(nameOrConnectionString)
{
}
}
|
In the Startup
class within ConfigureServices
add factory method of your context with it’s connection string. Context should be resolved once per scope to ensure performance and ensure reliable operation of Entity Framework.
1 2 3 4 5 6 | public void ConfigureServices(IServiceCollection services)
{
services.AddScoped(() => new ApplicationDbContext(Configuration["Data:DefaultConnection:ConnectionString"]));
// Configure remaining services
}
|
Migrate configuration from config to code¶
Entity Framework 6 allows configuration to be specified in xml (in web.config or app.config) or through code. As of ASP.NET Core, all configuration is code-based.
Code-based configuration is achieved by creating a subclass of System.Data.Entity.Config.DbConfiguration
and applying System.Data.Entity.DbConfigurationTypeAttribute
to your DbContext
subclass.
Our config file typically looked like this:
1 2 3 4 5 6 7 8 9 10 | <entityFramework>
<defaultConnectionFactory type="System.Data.Entity.Infrastructure.LocalDbConnectionFactory, EntityFramework">
<parameters>
<parameter value="mssqllocaldb" />
</parameters>
</defaultConnectionFactory>
<providers>
<provider invariantName="System.Data.SqlClient" type="System.Data.Entity.SqlServer.SqlProviderServices, EntityFramework.SqlServer" />
</providers>
</entityFramework>
|
The defaultConnectionFactory
element sets the factory for connections. If this attribute is not set then the default value is SqlConnectionProvider
. If, on the other hand, value is provided, the given class will be used to create DbConnection
with its CreateConnection
method. If the given factory has no default constructor then you must add parameters that are used to construct the object.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | [DbConfigurationType(typeof(CodeConfig))] // point to the class that inherit from DbConfiguration
public class ApplicationDbContext : DbContext
{
[...]
}
public class CodeConfig : DbConfiguration
{
public CodeConfig()
{
SetProviderServices("System.Data.SqlClient",
System.Data.Entity.SqlServer.SqlProviderServices.Instance);
}
}
|
Summary¶
Entity Framework 6 is an object relational mapping (ORM) library, that is capable of mapping your classes to database entities with little effort. These features made it very popular so migrating large portions of code may be undesirable for many projects. This article shows how to avoid migration to focus on other new features of ASP.NET.