Зависимость между службами внедрения зависимостей Net Core

public interface IOperation
{
    Guid OperationId { get; }
}

public interface IOperationTransient : IOperation
{
}

public interface IOperationScoped : IOperation
{
}

public interface IOperationSingleton : IOperation
{
}

public interface IOperationSingletonInstance : IOperation
{
}

public class Operation : IOperationTransient, 
    IOperationScoped, 
    IOperationSingleton, 
    IOperationSingletonInstance
{
    public Operation() : this(Guid.NewGuid())
    {
    }

    public Operation(Guid id)
    {
        OperationId = id;
    }

    public Guid OperationId { get; private set; }
}

public class OperationService
{
    public OperationService(
        IOperationTransient transientOperation,
        IOperationScoped scopedOperation,
        IOperationSingleton singletonOperation,
        IOperationSingletonInstance instanceOperation)
    {
        TransientOperation = transientOperation;
        ScopedOperation = scopedOperation;
        SingletonOperation = singletonOperation;
        SingletonInstanceOperation = instanceOperation;
    }

    public IOperationTransient TransientOperation { get; }
    public IOperationScoped ScopedOperation { get; }
    public IOperationSingleton SingletonOperation { get; }
    public IOperationSingletonInstance SingletonInstanceOperation { get; }
}

stay Startup.ConfigureServices , add each type to the container based on its specified lifetime:
C#

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

    services.AddScoped();
    services.AddTransient();
    services.AddScoped();
    services.AddSingleton();
    services.AddSingleton(new Operation(Guid.Empty));

    // OperationService depends on each of the other Operation types.
    services.AddTransient();
}

public class IndexModel : PageModel
{
    private readonly IMyDependency _myDependency;

    public IndexModel(
        IMyDependency myDependency, 
        OperationService operationService,
        IOperationTransient transientOperation,
        IOperationScoped scopedOperation,
        IOperationSingleton singletonOperation,
        IOperationSingletonInstance singletonInstanceOperation)
    {
        _myDependency = myDependency;
        OperationService = operationService;
        TransientOperation = transientOperation;
        ScopedOperation = scopedOperation;
        SingletonOperation = singletonOperation;
        SingletonInstanceOperation = singletonInstanceOperation;
    }

    public OperationService OperationService { get; }
    public IOperationTransient TransientOperation { get; }
    public IOperationScoped ScopedOperation { get; }
    public IOperationSingleton SingletonOperation { get; }
    public IOperationSingletonInstance SingletonInstanceOperation { get; }

    public async Task OnGetAsync()
    {
        await _myDependency.WriteMessage(
            "IndexModel.OnGetAsync created this message.");
    }
}

public void ConfigureServices(IServiceCollection services)
{

            services.AddSingleton();

            services.AddTransient();

            services.AddScoped();
}

public class SingletonService
    {
        public string Id = Guid.NewGuid().ToString();
        
    }

    public class ScopedService
    {
        public string Id = Guid.NewGuid().ToString();
        
    }

    public class TransientService
    {
        public string Id = Guid.NewGuid().ToString();

        private ScopedService _transient;
        private SingletonService _singleton;

        public TransientService(ScopedService transient, SingletonService singleton)
        {
            _transient = transient;
            _singleton = singleton;
        }


    }

It's ok,transient Can rely on singleton and scoped

about Transient service,It can be relied on by any service,But the life cycle of a service created in a dependent service follows the dependent service
about Scoped service,It can only be Transient and Scoped Service dependency,Life cycle will not change,If you want to Singleton Used in services,have access to IServiceProvider Of CreateScope Method ,Then? GetService, But generated scoped The service life cycle is Singleton

about Singleton service,It can be relied on by any service,Life cycle will not change

public class SingletonService
    {
        public string Id = Guid.NewGuid().ToString();
        private ScopedService _scoped;

        public SingletonService(IServiceProvider serviceProvider)
        {
            using (var scope = serviceProvider.CreateScope())
            {
                _scoped = scope.ServiceProvider.GetService();
            }
        }
    }

    public class ScopedService
    {
        public string Id = Guid.NewGuid().ToString();
        
    }

    public class TransientService
    {
        public string Id = Guid.NewGuid().ToString();


    }