using Microsoft.Extensions.DependencyInjection;
using System;
using System.Runtime.CompilerServices;
using static System.Net.Mime.MediaTypeNames;

namespace WebApplication3
{
    public interface IBase<T>
    { 
        T GetSelf();
    }
    public interface ITool: IBase<ITool>
    {
        string MethorName();
        
    }
    public class Base<T> : IBase<T>
    {
        private readonly IServiceScopeFactory _serviceScopeFactory;
        public Base(IServiceProvider serviceProvider) {
            _serviceScopeFactory = serviceProvider.GetRequiredService<IServiceScopeFactory>();
        }
        public T GetSelf()
        {
            using (var scope = _serviceScopeFactory.CreateScope())
            {
                var enumerable = scope.ServiceProvider.GetRequiredService<IEnumerable<T>>();
                string name = RedisHelper.Get("TypeName");
                var iTool = enumerable.Where(m => m.GetType().Name == name).FirstOrDefault() ?? enumerable.First();
                return iTool;
            }
        }
    }
    public class  Stool: Base<ITool>, ITool
    {
        public Stool(IServiceProvider serviceProvider) : base(serviceProvider)
        {
        }
        public string MethorName()
        {
           
            return "Stool";
        }
     
    }
    public class Rtool : Base<ITool>,ITool
    {
        public Rtool(IServiceProvider serviceProvider) : base(serviceProvider)
        {
        }
        public string MethorName()
        {
            return "Rtool";
        }

       
    }
}

using Microsoft.AspNetCore.Mvc;

namespace WebApplication3.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private static readonly string[] Summaries = new[]
        {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

        private readonly ILogger<WeatherForecastController> _logger;
       
        private readonly ITool _tool;
        public WeatherForecastController(ILogger<WeatherForecastController> logger, ITool tool)
        {
            _logger = logger;
            _tool= tool.GetSelf();
        }

        [HttpGet]
        public IEnumerable<WeatherForecast> Get()
        {
            _logger.LogWarning("MethorName=" + _tool.MethorName());
        
            return Enumerable.Range(1, 5).Select(index => new WeatherForecast
            {
                Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
                TemperatureC = Random.Shared.Next(-20, 55),
                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
            })
            .ToArray();
        }
    }
}

namespace WebApplication3
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            // Add services to the container.

            builder.Services.AddControllers();

            builder.Services.AddScoped<ITool, Stool>();
            builder.Services.AddScoped<ITool, Rtool>();
            var csredis = new CSRedis.CSRedisClient($"127.0.0.1:6379,defaultDatabase=1,prefix=test:");
            RedisHelper.Initialization(csredis);
            var app = builder.Build();

            // Configure the HTTP request pipeline.

            app.UseAuthorization();


            app.MapControllers();

            app.Run();
        }
    }
}