Net CoreによるAutoFacの利用

// Create the builder for the registered component
var builder = new ContainerBuilder();

// Register components by type ConsoleLogger Storming Service: ILogger
builder.RegisterType<ConsoleLogger>().As<ILogger>();

//Register the component ConsoleLogger by type, exposing all the services (interfaces) it implements
builder.RegisterType<ConsoleLogger>().AsImplementedInterfaces();

// register the component output according to the instance Storm service: TextWriter
var output = new StringWriter();
builder.RegisterInstance(output).As<TextWriter>();

//expression register component, here we are in the constructor when passing the reference - >"musection" storm service: IConfigReader
builder.Register(c =new ConfigReader("mysection")).As<IConfigReader>();

//expression to register the component, pass the reference when parsing
var service = scope.Resolve<IConfigReader>(
           new NamedParameter("section", "mysection"));     

//reflective registration of components, directly registered ConsoleLogger class (must be a specific class), if the ConsoleLogger has more than one constructor, will take the constructor with the most parameters to instantiate
builder.RegisterType<ConsoleLogger>();

//reflective registration of components, manually specify the constructor, here specify the constructor to call MyComponent (ILogger log, IConfigReader config) to register
builder.RegisterType<MyComponent>()
 .UsingConstructor(typeof(ILogger), typeof(IConfigReader));  

 // Register the static variable "Instance" in the MySingleton class, the ExternallyOwned() function specifies that it controls the life cycle of the instance, rather than automatically released by autofac
 builder.RegisterInstance(MySingleton.Instance).ExternallyOwned();

//One component exposes two services  
builder.RegisterType<CallLogger>().As<ILogger>().As<ICallInterceptor>(); 

//Register the class ending with "Service" in the current assembly
Builder.RegisterAssemblyTypes(System.Reflection.Assembly.GetExecutingAssembly()).Where(t => t.Name.EndsWith("Service")) .AsImplementedInterfaces();
//Register all classes in "MyApp.Repository" assembly
builder.RegisterAssemblyTypes(GetAssembly("MyApp.Repository")).AsImplementedInterfaces();
  
// Build a container to complete the registration
var rootcontainer = builder.Build();

//You can get the IConfigReader implementation class manually in the following way
//This manual parsing method needs to get the component from the lifecycle scope to ensure that the component is eventually released
//Do not parse the component directly from the root container rootcontainer, it will probably lead to a memory leak
BeginLifetimeScope())
{
  var reader = scope.Resolve<IConfigReader>();
}

  public static IContainer AutofacContainer;
    // This method gets called by the runtime. Use this method to add services to the container.
    public IServiceProvider ConfigureServices(IServiceCollection services)
    public IServiceProvider ConfigureServices(IServiceCollection services) {
        // Register the services into the IServiceCollection
        services.AddMvc();
        ContainerBuilder builder = new ContainerBuilder();
        //Populate Autofac with the services in services.
        builder.Populate(services);
        //register the new module component
        builder.RegisterModule<DefaultModuleRegister>();
        //create container.
        AutofacContainer = builder.Build();
        //use container to create AutofacServiceProvider 
        return new AutofacServiceProvider(AutofacContainer);
    }

public class DefaultModuleRegister : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        //register the classes ending with "Ser" in the current assembly, and leak all the interfaces implemented by the class, the life cycle of PerLifetimeScope
        builder.RegisterAssemblyTypes(System.Reflection.Assembly.GetExecutingAssembly()).Where(t => t.Name.EndsWith("Ser")). AsImplementedInterfaces().InstancePerLifetimeScope();
        builder.RegisterAssemblyTypes(System.Reflection.Assembly.GetExecutingAssembly()).Where(t => t.Name.EndsWith("Repository" ;)).AsImplementedInterfaces().InstancePerLifetimeScope();
        //register all the classes in the "MyApp.
        //builder.RegisterAssemblyTypes(GetAssembly("MyApp.Repository")).AsImplementedInterfaces();
    }

	public static Assembly GetAssembly(string assemblyName)
    {
        AssemblyLoadContext.Default.LoadFromAssemblyPath(AppContext.BaseDirectory + $"{assemblyName}.dll");
        return assembly;
    }
}

  public void Configure(IApplicationBuilder app, IHostingEnvironment env, IApplicationLifetime appLifetime)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
            app.UseBrowserLink();
        }
        else
        {
            app.UseExceptionHandler("/Home/Error");
        }

        app.UseStaticFiles();

        app.UseMvc(routes =>
        {
            routes.MapRoute(
                name: "default",
                template: "{controller=Home}/{action=Index}/{id?}");
        });
        //The program stops calling the function
        appLifetime.ApplicationStopped.Register(() => { AutofacContainer.Dispose(); });
    }

  private IUserSer _user;
    private IUserSer _user2;
    public HomeController(IUserSer user, IUserSer user2)
    {
        _user = user;
        _user2 = user2;
    }
    public IActionResult Index()
    {
        using (var scope = Startup.AutofacContainer.BeginLifetimeScope())
        {
            IConfiguration config = scope.Resolve<IConfiguration>();
            IHostingEnvironment env = scope.Resolve<IHostingEnvironment>();
        }
        string name = _user.GetName();
        string name2 = _user2.GetName();
        return View();
    }