C# 我可以创建一个列表吗<；类<；T>>；？

我有一节课

public class Setting<T>
{
    public string name { get; set; }

    public T value { get; set; }
}

公共类设置
{
公共字符串名称{get；set；}
公共T值{get；set；}
}

现在我想创建一个

IList

，但是在它里面有不同类型的

设置

，我想

List<Setting<T>> settingsList;
settingsList.Add(new Setting<int>());
settingsList.Add(new Setting<string>()); 

列表设置列表；
settingsList.Add（新设置（））；
settingsList.Add（新设置（））；

我尝试了

IList

，但这似乎不可能，因为编译器找不到类型

t

---

我知道我可以使用object，但我希望它是强类型的。因此，我的问题是，是否有可能实现这一点。

对于放入列表中的所有类类型，必须使用一个公共祖先类。如果它应该是任意类型，您必须为

T

使用

object

，默认情况下，泛型类型在具体定义中没有公共类型或接口

让您的

设置

类实现一个接口（或从公共类派生），并创建该接口（或类）的列表

公共接口正在设置{}
公共课堂设置：ISetting
{
// ...
}
//用法示例：
IList list=新列表
{
新设置{name=“foo”，value=2}，
新设置{name=“bar”，值“baz”}，
};

您只能在课堂上使用

T

：

class Setting<T>
{
    // T is defined here
}

类设置
{
//这里定义了T
}

不在外面。在外部，您需要指定混凝土类型：

Settings<string> stringSettings = new Settings<string>();

Settings stringSettings=新设置（）；

或

List List=新列表（）；
列表。添加（字符串设置）；

您可以通过使用反射来实现 我为另一个问题编写了这样的代码，但您可以使用它

public abstract class GenericAccess
{
    public static IList<T> GetObjectListFromArray<T>(T item)
    {
        var r = new List<T>();
        var obj = typeof(T).Assembly.CreateInstance(typeof(T).FullName);
        var p = obj.GetType().GetProperty("Id", System.Reflection.BindingFlags.IgnoreCase | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
        if (p != null)
        {
            p.SetValue(obj, item, null);
            var m = r.GetType().GetMethod("Add");
            m.Invoke(r, new object[] { obj });
        }
        return r;
    }
}

公共抽象类通用访问
{
公共静态IList GetObjectListFromArray（T项）
{
var r=新列表（）；
var obj=typeof（T）.Assembly.CreateInstance（typeof（T）.FullName）；
var p=obj.GetType（）.GetProperty（“Id”，System.Reflection.BindingFlags.IgnoreCase | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance）；
如果（p！=null）
{
p、 设置值（对象，项，空）；
var m=r.GetType（）.GetMethod（“添加”）；
m、 调用（r，新对象[]{obj}）；
}
返回r；
}
}

这样称呼它

    IList<int> r = GenericAccess.GetObjectListFromArray<int>(1);

IList r=genericacess.GetObjectListFromArray（1）；

//
/// 消息回调委托
/// 
///TClass
/// 返回实体
/// 内容包
公共委托void CallbackHandler（T result，BasicDeliverEventArgs args args）；
/// 
/// 注册监听程序接口
/// 
公共接口IRegistration
{
/// 
/// 路由名称
/// 
字符串ExchangeName{get；}
/// 
/// 路由钥匙
/// 
字符串RouteKey{get；}
/// 
/// 回调操作
/// 
/// 
无效调用（BasicDeliverEventArgs args args）；
}
/// 
/// 注册监听程序
/// 
/// 
公共类注册：i注册，其中T:class
{
/// 
/// 路由名称
/// 
公共字符串ExchangeName{get；set；}
/// 
/// 路由钥匙
/// 
公共字符串RouteKey{get；set；}
/// 
/// 消息处理器委托
/// 
公共回调处理程序{get；set；}
/// 
/// 接口回调操作
/// 
/// 
公共无效调用（BasicDeliverEventArgs args args）
{
var message=Encoding.UTF8.GetString（args.Body.ToArray（））；
Handler？.Invoke（JsonConvertHandler.DeserializeObject（message），args）；
}
}
/// 
/// 消息监听处理器
/// 
公共静态类ListenerHandler
{
/// 
/// 单任务锁
/// 
私有静态只读对象锁定器=新对象（）；
/// 
/// 所有注册列表
/// 
公共静态列表注册{get；private set；}
/// 
/// 单例化
/// 
静态ListenerHandler（）
{
List listeners=MqNoticeHandler.Setting.GetListeners（）；
MqNoticeHandler.Listener（OnMessage，listeners）；
}
/// 
/// 注册监听
/// 
/// 
公共静态无效登记簿（IRegistration登记）
{
锁（储物柜）
注册。添加（注册）；
}
/// 
/// 解除注册
/// 
/// 
公共静态无效注销（IRegistration注册）
{
锁（储物柜）
注册。删除（注册）；
}
/// 
/// 获取监听列表
/// 
/// 
/// 
/// 
公共静态IEnumerable GetRegistrations（字符串exchangeName、字符串routeKey）
{
返回注册。其中（x=>x.ExchangeName==ExchangeName&&x.RouteKey==RouteKey）；
}
/// 
/// 消息回调处理
/// 
/// 消费者
/// 消息包
/// 
私有静态MqAckResult OnMessage（EventingBasicConsumer使用者，BasicDeliverEventArgs参数）
{
//查询和调用示例
Registrations.First（）调用（args）；
//返回
返回新的MqAckResult{Accept=true，ReQueue=false}；
}
}

你的意思是，例如，你有

设置

和

设置

，你想有一个包含这两个的列表吗？相关答案@BoltClock编辑了我的问题，使其更清楚+1你可以添加

公共字符串名称{get；set；}

to

ISetting

，以明确公共接口实际上只能包含所有继承类中具有公共签名的操作。很难理解这是如何回答问题的，特别是因为您没有解释任何内容。对不起，我的英语很蹩脚。在正常情况下，您将使用传入类型，因此需要实现接口的Call方法来回调请求者。因此，您需要首先定义一个要传递给请求者的委托，并定义一个接口来标准化回调操作。实现类以继承接口并实现回调方法。以上内容由谷歌翻译生成

public abstract class GenericAccess
{
    public static IList<T> GetObjectListFromArray<T>(T item)
    {
        var r = new List<T>();
        var obj = typeof(T).Assembly.CreateInstance(typeof(T).FullName);
        var p = obj.GetType().GetProperty("Id", System.Reflection.BindingFlags.IgnoreCase | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
        if (p != null)
        {
            p.SetValue(obj, item, null);
            var m = r.GetType().GetMethod("Add");
            m.Invoke(r, new object[] { obj });
        }
        return r;
    }
}

    IList<int> r = GenericAccess.GetObjectListFromArray<int>(1);

/// <summary>
/// 消息回调委托
/// </summary>
/// <typeparam name="T">TClass</typeparam>
/// <param name="result">返回实体</param>
/// <param name="args">内容包</param>
public delegate void CallbackHandler<in T>(T result, BasicDeliverEventArgs args);

/// <summary>
/// 注册监听程序接口
/// </summary>
public interface IRegistration
{
    /// <summary>
    /// 路由名称
    /// </summary>
    string ExchangeName { get; }

    /// <summary>
    /// 路由Key
    /// </summary>
    string RouteKey { get; }

    /// <summary>
    /// 回调操作
    /// </summary>
    /// <param name="args"></param>
    void Call(BasicDeliverEventArgs args);
}

/// <summary>
/// 注册监听程序
/// </summary>
/// <typeparam name="T"></typeparam>
public class Registration<T> : IRegistration where T : class
{
    /// <summary>
    /// 路由名称
    /// </summary>
    public string ExchangeName { get; set; }

    /// <summary>
    /// 路由Key
    /// </summary>
    public string RouteKey { get; set; }

    /// <summary>
    /// 消息处理器委托
    /// </summary>
    public CallbackHandler<T> Handler { get; set; }

    /// <summary>
    /// 接口回调操作
    /// </summary>
    /// <param name="args"></param>
    public void Call(BasicDeliverEventArgs args)
    {
        var message = Encoding.UTF8.GetString(args.Body.ToArray());
        Handler?.Invoke(JsonConvertHandler.DeserializeObject<T>(message), args);
    }
}

/// <summary>
/// 消息监听处理器
/// </summary>
public static class ListenerHandler
{
    /// <summary>
    /// 单任务锁
    /// </summary>
    private static readonly object Locker = new object();

    /// <summary>
    /// 所有注册列表
    /// </summary>
    public static List<IRegistration> Registrations { get; private set; }

    /// <summary>
    /// 单例化
    /// </summary>
    static ListenerHandler()
    {
        List<ListenerSetting> listeners = MqNoticeHandler.Setting.GetListeners();
        MqNoticeHandler.Listener(OnMessage, listeners);
    }

    /// <summary>
    /// 注册监听
    /// </summary>
    /// <param name="registration"></param>
    public static void Register(IRegistration registration)
    {
        lock (Locker)
            Registrations.Add(registration);
    }

    /// <summary>
    /// 解除注册
    /// </summary>
    /// <param name="registration"></param>
    public static void UnRegister(IRegistration registration)
    {
        lock (Locker)
            Registrations.Remove(registration);
    }

    /// <summary>
    /// 获取监听列表
    /// </summary>
    /// <param name="exchangeName"></param>
    /// <param name="routeKey"></param>
    /// <returns></returns>
    public static IEnumerable<IRegistration> GetRegistrations(string exchangeName, string routeKey)
    {
        return Registrations.Where(x => x.ExchangeName == exchangeName && x.RouteKey == routeKey);
    }

    /// <summary>
    /// 消息回调处理
    /// </summary>
    /// <param name="consumer">消费者</param>
    /// <param name="args">消息包</param>
    /// <returns></returns>
    private static MqAckResult OnMessage(EventingBasicConsumer consumer, BasicDeliverEventArgs args)
    {
        //Example Query and Call 
        Registrations.First().Call(args);

        //Return
        return new MqAckResult { Accept = true, ReQueue = false };
    }
}