Où enregistrer le contexte avec l'injection de dépendances

La version de démarrage affichée et le didacticiel sont en conflit l'un avec l'autre.

S'il s'agit d'une application Asp.Net Core MVC, vous pouvez ajouter la méthode vous-même. La classe Startup fait partie de la convention.

protected void Application_Start() {
    var services = new ServiceCollection();
    ConfigureServices(services);
    //build service provider
    IServiceProvider provider = services.BuildServiceProvider();
    //Get the current resolver used by MVC
    var current = DependencyResolver.Current;
    //use that and the provider to create your custom resolver
    var resolver = new CoreDependencyResolver(provider, current);
    //now set the MVC framework to use the resolver that wraps the service provider
    //that was created from .Net Core Dependency Injection framework.
    DependencyResolver.SetResolver(resolver);
    //...

    AreaRegistration.RegisterAllAreas();
    FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
    RouteConfig.RegisterRoutes(RouteTable.Routes);
    BundleConfig.RegisterBundles(BundleTable.Bundles);
}

private void ConfigureServices(IServiceCollection services) {
    //... omitted for brevity (register dependencies as normal)
}

Référence Démarrage de l'application dans ASP.NET Core

La méthode ConfigureServices

La méthode ConfigureServices est:

• Facultatif.
• Appelé par l'hôte avant la méthode Configure pour configurer les services de l'application.
• Où les options de configuration sont définies par convention.

Si toutefois vous essayez d'utiliser les technologies .Net Core dans un Asp.Net MVC 5+ (c'est ce que le projet GitHub cible) alors vous devrez modifiez votre approche pour vous adapter à l'utilisation de l'injection de dépendances .Net Core avec une plate-forme non principale.

Tout d'abord, vous aurez besoin d'un IDependencyResolver qui est le framework DI utilisé par cette version d'Asp. Net MVC et un moyen de remplacer le résolveur par défaut par le vôtre.

public sealed class CoreDependencyResolver : System.Web.Mvc.IDependencyResolver {
    private readonly System.Web.Mvc.IDependencyResolver mvcInnerResolver;
    private readonly IServiceProvider serviceProvider;

    public CoreDependencyResolver(IServiceProvider serviceProvider, System.Web.Mvc.IDependencyResolver dependencyResolver) {
        this.serviceProvider = serviceProvider;
        mvcInnerResolver = dependencyResolver;
    }

    public object GetService(Type serviceType) {
        object result = this.serviceProvider.GetService(serviceType);
        if (result == null && mvcInnerResolver != null)
            result = mvcInnerResolver.GetService(serviceType);
        return result;
    }

    public IEnumerable<object> GetServices(Type serviceType) {
        IEnumerable<object> result = this.serviceProvider.GetServices(serviceType);
        if (result == null && mvcInnerResolver != null)
            result = mvcInnerResolver.GetServices(serviceType);
        return result ?? new object[0];
    }
}

Avec le résolveur personnalisé en place, vous pouvez désormais configurer l'application pour l'utiliser. P >

En utilisant votre exemple actuel comme point de départ (commentaires de révision)

public partial class Startup {
    //...

    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
         //...
    }
}

Ici, j'utilise Oracle, mais vous pourriez faire la même chose avec SQL Server ...

"Data": {
"OracleDbContext": "your connection string" },
"AppsDbContext": "your connection string" }
 }

Ensuite, dans mon appsettings.json, j'inclus les chaînes de connexion ... p >

 public void ConfigureServices(IServiceCollection services)
 {

        services.AddEntityFrameworkOracle()
            .AddDbContext<OracleDbContext>(builder => builder.UseOracle(Configuration["Data:OracleDbContext"]),ServiceLifetime.Scoped)
            .AddDbContext<AppsDbContext>(option => option.UseOracle(Configuration["Data:AppsDbConnection:ConnectionString"]), ServiceLifetime.Scoped);

Bien que l'utilisation des outils .NET Core avec un framework complet fonctionne assez bien, si vous devez utiliser MVC5 et un framework complet, je n'essaierais pas de le faire de cette façon.

Il existe de nombreux frameworks d'injection de dépendances .NET 4.6.1 , dans cet exemple, j'utiliserai Autofac.

• Installez les packages NuGet Autofac et Autofac.Mvc5 .
• Ajouter une classe AutofacRegistration.cs au dossier App_Start
• Dans la méthode Application_Start () de Global.asax , ajoutez la ligne AutofacRegistration.BuildContainer();

Votre classe AutofacRegistration est l'endroit où vous connectez toutes vos dépendances pour l'injection de dépendances. La documentation complète est ici https://autofaccn.readthedocs.io/en/latest /integration/mvc.html

public class BloggingContext : DbContext
{
    public BloggingContext(string connectionString) : base(connectionString)
    {
    }
}

Cela suppose que votre BloggingContext a un constructeur qui prend la chaîne de connexion comme paramètre et passe à la classe de base. Quelque chose comme

public class AutofacRegistration
{
    public static void BuildContainer()
    {
        var builder = new ContainerBuilder();

        // Register your MVC controllers
        builder.RegisterControllers(typeof(MvcApplication).Assembly);

        // Now grab your connection string and wire up your db context
        var conn = ConfigurationManager.ConnectionStrings["BloggingContext"];
        builder.Register(c => new BloggingContext(conn));

        // You can register any other dependencies here

        // Set the dependency resolver to be Autofac.
        var container = builder.Build();
        DependencyResolver.SetResolver(new AutofacDependencyResolver(container));
    }
}

Il y a beaucoup plus dans la documentation sur la portée, etc. qui vaut la peine d'être lu, mais cela devrait en être les noix et les boulons.

Il semble que vous utilisez .Net Framework, plutôt que .Net Core.

2 idées simples ici:

• Injection de DbContext dans la couche service: cette couche sera la bibliothèque de classes pour .Net Framework ou (utilisez la bibliothèque de classes standard .Net si votre plate-forme est .Net Core). Ce fil vous montre comment l'exécuter: Injection de DbContext dans la couche de service
• utilisez Ninject comme injecteur de dépendances si vous êtes sur la plate-forme .Net Framework. Ce fil montre un bon exemple: Comment gérer DBContext lors de l'utilisation de Ninject