public interface ITodoRepository
{
 IEnumerable<TodoItem> AllItems { get; }
 void Add(TodoItem item);
 TodoItem GetById(int id);
 bool TryDelete(int id);
}

public class TodoItem
{
 public int Id { get; set; }
 public string Name { get; set; }
}

public class TodoRepository : ITodoRepository
{
 readonly List<TodoItem> _items = new List<TodoItem>();

 public IEnumerable<TodoItem> AllItems
 {
 get { return _items; }
 }

 public TodoItem GetById(int id)
 {
 return _items.FirstOrDefault(x => x.Id == id);
 }

 public void Add(TodoItem item)
 {
 item.Id = 1 + _items.Max(x => (int?)x.Id) ?? 0;
 _items.Add(item);
 }

 public bool TryDelete(int id)
 {
 var item = GetById(id);

 if (item == null) { return false; }

 _items.Remove(item);

 return true;
 }
}

//注册单例模式，整个应用程序周期内ITodoRepository接口的示例都是TodoRepository1的一个单例实例
services.AddSingleton<ITodoRepository, TodoRepository1>();
services.AddSingleton(typeof(ITodoRepository), typeof(TodoRepository1)); // 等价形式

//注册特定实例模型，整个应用程序周期内ITodoRepository接口的示例都是固定初始化好的一个单例实例

TodoRepository2
services.AddInstance<ITodoRepository>(new TodoRepository2());
services.AddInstance(typeof(ITodoRepository), new TodoRepository2()); // 等价形式

//注册作用域型的类型，在特定作用域内ITodoRepository的示例是TodoRepository3
services.AddScoped<ITodoRepository, TodoRepository3>();
services.AddScoped(typeof(ITodoRepository), typeof(TodoRepository3));// 等价形式

//获取该ITodoRepository实例时，每次都要实例化一次TodoRepository4类
services.AddTransient<ITodoRepository, TodoRepository4>();
services.AddTransient(typeof(ITodoRepository), typeof(TodoRepository));// 等价形式

//如果要注入的类没有接口，那你可以直接注入自身类型，比如：
services.AddTransient<LoggingHelper>();

public class TodoController : Controller
{
 private readonly ITodoRepository _repository;

 /// 依赖注入框架会自动找到ITodoRepository实现类的示例，赋值给该构造函数
 public TodoController(ITodoRepository repository)
 {
 _repository = repository;
 }

 [HttpGet]
 public IEnumerable<TodoItem> GetAll()
 {
 return _repository.AllItems; //这里就可以使用该对象了
 }
}

public class TodoController : Controller
{
 // 依赖注入框架会自动找到ITodoRepository实现类的示例，赋值给该属性
 [FromServices]
 public ITodoRepository Repository { get; set; }

 [HttpGet]
 public IEnumerable<TodoItem> GetAll()
 {
 return Repository.AllItems;
 }
}

@using WebApplication1
@inject ITodoRepository repository
<div>
 @repository.AllItems.Count()
</div>

var provider1 = this.Request.HttpContext.ApplicationServices; 当前应用程序里注册的Service
var provider2 = Context.RequestServices; // Controller中，当前请求作用域内注册的Service
var provider3 = Resolver; //Controller中

var _repository1 = provider1.GetService(typeof(ITodoRepository));
var _repository2 = provider1.GetService<LoggingHelper>();//等价形式
//上述2个对象可能为空

var _repository3 = provider1.GetRequiredService(typeof(ITodoRepository));
var _repository4 = provider1.GetRequiredService<LoggingHelper>();//等价形式
//上述2个对象肯定不为空，因为如果为空的话，会自动抛异常出来

public class AppSettings
{
 public string SiteTitle { get; set; }
}

services.Configure<AppSettings>(app =>
{
 app.SiteTitle = "111";
});

var appSettings = app.ApplicationServices.GetRequiredService<IOptions<AppSettings>>().Options;

@inject IOptions<AppSettings> AppSettings

<title>@AppSettings.Options.SiteTitle</title>

services.AddScoped<ITodoRepository, TodoRepository>();

var serviceProvider = Resolver;

var scopeFactory = serviceProvider.GetService<IServiceScopeFactory>(); //获取Scope工厂类
using (var scope = scopeFactory.CreateScope()) // 创建一个Scope作用域
{
 var containerScopedService = serviceProvider.GetService<ITodoRepository>(); //获取普通的实例
 var scopedService1 = scope.ServiceProvider.GetService<ITodoRepository>(); //获取当前Scope的实例
 Thread.Sleep(200);
 var scopedService2 = scope.ServiceProvider.GetService<ITodoRepository>(); //获取当前Scope的实例

 Console.WriteLine(containerScopedService == scopedService1); // 输出：False
 Console.WriteLine(scopedService1 == scopedService2); //输出：True
}

var serviceProvider = Resolver;

var outerScopeFactory = serviceProvider.GetService<IServiceScopeFactory>();
using (var outerScope = outerScopeFactory.CreateScope()) //外部Scope作用域
{
 var innerScopeFactory = outerScope.ServiceProvider.GetService<IServiceScopeFactory>();
 using (var innerScope = innerScopeFactory.CreateScope()) //内部Scope作用域
 {
 var outerScopedService = outerScope.ServiceProvider.GetService<ITodoRepository>();
 var innerScopedService = innerScope.ServiceProvider.GetService<ITodoRepository>();

 Console.WriteLine(outerScopedService == innerScopedService); // 输出：False
 }
}

app.Use(new Func<RequestDelegate, RequestDelegate>(nextApp => new ContainerMiddleware(nextApp, app.ApplicationServices).Invoke));

public class TestService
{
 private ITodoRepository _repository;
 public TestService(ITodoRepository r)
 {
 _repository = r;
 }

 public void Show()
 {
 Console.WriteLine(_repository.AllItems);
 }
}

services.AddScoped<ITodoRepository, TodoRepository>();
services.AddSingleton<TestService>();

var service = serviceProvider.GetRequiredService<TestService>();

public class TestService2
{
 [FromServices]
 public ITodoRepository Repository { get; set; }
 public void Show()
 {
 Console.WriteLine(Repository.AllItems);
 }
}

public class TestService3
{
 private IHttpContextAccessor _httpContextAccessor;
 public TestService3(IHttpContextAccessor httpContextAccessor)
 {
 _httpContextAccessor = httpContextAccessor;
 }

 public void Show()
 {
 var httpContext = _httpContextAccessor.HttpContext;//获取上下文对象实例
 Console.WriteLine(httpContext.Request.Host.Value);
 }
}

var service = serviceProvider.GetRequiredService<TestService3>();
service.Show();

app.UseServices(services =>
{
 services.AddMvc();// AddMvc要在这里注册
 var builder = new ContainerBuilder();// 构造容器构建类
 builder.Populate(services);//将现有的Services路由到Autofac的管理集合中
 IContainer container = builder.Build();
 return container.Resolve<IServiceProvider>();//返回AutoFac实现的IServiceProvider
});

// 需要先删除void类型的ConfigureServices方法
public IServiceProvider ConfigureServices(IServiceCollection services)
{
 var builder = new ContainerBuilder(); // 构造容器构建类
 builder.Populate(services); //将现有的Services路由到Autofac的管理集合中
 IContainer container = builder.Build();
 return container.Resolve<IServiceProvider>(); //返回AutoFac实现的IServiceProvider
}

public class AutofacModule : Module
{
 protected override void Load(ContainerBuilder builder)
 {
 builder.Register(c => new Logger())
  .As<ILogger>()
  .InstancePerLifetimeScope();

 builder.Register(c => new ValuesService(c.Resolve<ILogger>()))
  .As<IValuesService>()
  .InstancePerLifetimeScope();
 }
}