关于如何在asp .net core 中注册泛型接口

1. 关于泛型的介绍
   泛型（Generic） 允许您延迟编写类或方法中的编程元素的数据类型的规范，直到实际在程序中使用它的时候。换句话说，泛型允许您编写一个可以与任何数据类型一起工作的类或方法。

您可以通过数据类型的替代参数编写类或方法的规范。当编译器遇到类的构造函数或方法的函数调用时，它会生成代码来处理指定的数据类型。下面这个简单的实例将有助于您理解这个概念：

using System;
using System.Collections.Generic;

namespace GenericApplication
{
    public class MyGenericArray<T>
    {
        private T[] array;
        public MyGenericArray(int size)
        {
            array = new T[size + 1];
        }
        public T getItem(int index)
        {
            return array[index];
        }
        public void setItem(int index, T value)
        {
            array[index] = value;
        }
    }
           
    class Tester
    {
        static void Main(string[] args)
        {
            // 声明一个整型数组
            MyGenericArray<int> intArray = new MyGenericArray<int>(5);
            // 设置值
            for (int c = 0; c < 5; c++)
            {
                intArray.setItem(c, c*5);
            }
            // 获取值
            for (int c = 0; c < 5; c++)
            {
                Console.Write(intArray.getItem(c) + " ");
            }
            Console.WriteLine();
            // 声明一个字符数组
            MyGenericArray<char> charArray = new MyGenericArray<char>(5);
            // 设置值
            for (int c = 0; c < 5; c++)
            {
                charArray.setItem(c, (char)(c+97));
            }
            // 获取值
            for (int c = 0; c < 5; c++)
            {
                Console.Write(charArray.getItem(c) + " ");
            }
            Console.WriteLine();
            Console.ReadKey();
        }
    }
}

使用泛型是一种增强程序功能的技术，具体表现在以下几个方面：

它有助于您最大限度地重用代码、保护类型的安全以及提高性能。
您可以创建泛型集合类。.NET 框架类库在 System.Collections.Generic 命名空间中包含了一些新的泛型集合类。您可以使用这些泛型集合类来替代 System.Collections 中的集合类。
您可以创建自己的泛型接口、泛型类、泛型方法、泛型事件和泛型委托。
您可以对泛型类进行约束以访问特定数据类型的方法。
关于泛型数据类型中使用的类型的信息可在运行时通过使用反射获取。

现在我们定义如下接口以及泛型类

using StackExchange.Redis;
using CoreRedis.Models;
using Microsoft.Extensions.Options;
using CoreRedis.Config;

namespace CoreRedis.RedisDataType
{

    public interface IRedisList<T> where T : class
    {
        //lpush 左侧插入元素
         Task<Task<long>> LPUSH(string key, string value);


        //右侧插入元素
        Task<Task<long>> RPUSH(string key, string value);


        //从左侧弹出元素
          Task<Task<RedisValue>> LPOP(string key);



        //从左侧弹出多个元素
          Task<Task<RedisValue[]>> LPOPMUL(string key, long count);


        //len 获取列表长度
          Task<Task<long>> LLen(string key);


        //lindex 获取指定索引上的数据
          Task<Task<RedisValue>> LIndex(string key, long index);

        //lrange 获取一个索引范围的数据
          Task<Task<RedisValue[]>> LRange(string key, long start, long end);


        //lset 为指定索引设置新值
          Task LSet(string key, string value, long index);


        //ltrim 裁剪
        Task<Task> LTrim(string key, long start, long stop);



        //lrem 删除元素，0表示全部删除，-1 表示从左侧开始删除等于value的count个，1表示右侧
        Task<Task<long>> LRem(string key, long count, string value);




    }



    public class RedisList<T>:IRedisList<T> where T: class
    {
        private static readonly object Locker = new object();

        private ConnectionMultiplexer connectionMultiplexer;


        IDatabase db = null;

        public RedisList(IOptionsMonitor<RedisConfig> optionsMonitor)
        {
            connectionMultiplexer = ConnectionMultiplexer.Connect(optionsMonitor.CurrentValue.Value);

            db = connectionMultiplexer.GetDatabase();
        }

        //lpush 左侧插入元素
        public async Task<Task<long>> LPUSH(string key,string value)
        {
            return db.ListLeftPushAsync(key, value,When.Always);
        }

        //右侧插入元素
        public async Task<Task<long>> RPUSH(string key,string value)
        {
            return db.ListRightPushAsync(key, value,When.NotExists);
        }

        //从左侧弹出元素
        public async Task<Task<RedisValue>> LPOP(string key)
        {
            return db.ListLeftPopAsync(key);
        }


        //从左侧弹出多个元素
        public async Task<Task<RedisValue[]>> LPOPMUL(string key,long count)
        {
            return db.ListLeftPopAsync(key,count);
        }

        //len 获取列表长度
        public async Task<Task<long>> LLen(string key)
        {
            return db.ListLengthAsync(key);
        }

        //lindex 获取指定索引上的数据
        public async Task<Task<RedisValue>> LIndex(string key,long index)
        {
            return  db.ListGetByIndexAsync(key,index);
        }

        //lrange 获取一个索引范围的数据
        public async Task<Task<RedisValue[]>> LRange(string key,long start,long end)
        {
            return db.ListRangeAsync(key,start,end);
        }

        //lset 为指定索引设置新值
        public async Task LSet(string key,string value,long index)
        {
            await db.ListSetByIndexAsync(key,index,value);
        }

        //ltrim 裁剪
        public async Task<Task> LTrim(string key,long start,long stop)
        {
            return db.ListTrimAsync(key, start, stop);
        }


        //lrem 删除元素，0表示全部删除，-1 表示从左侧开始删除等于value的count个，1表示右侧
        public async Task<Task<long>> LRem(string key,long count,string value)
        {
            return db.ListRemoveAsync(key,value,count);
        }
    }
}

在 programe.cs 中这样注册即可

builder.Services.AddSingleton(typeof(IRedisList<>), typeof(RedisList<>));

使用时候这样使用即可

using CoreRedis.Models;
using CoreRedis.RedisDataType;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

namespace CoreRedis.Controllers
{
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class RedisListController : ControllerBase
    {
        private readonly IRedisList<stringPost> _redisList;

        public RedisListController(IRedisList<stringPost> redisList)
        {
            _redisList = redisList;
        }

        [HttpGet]
        public async Task<long> GetTask([FromQuery] string key)
        {
            return await _redisList.LPUSH(key,"222").Result;
        }
    }
}