Can I create a List<Class<T>>?

I have a class

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

    public T value { get; set; }
}

now I want to create an IList<Setting<T>> but with different types of Setting<T>'s T in it, I want e.G.

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

I've tried IList<Setting<T>> but this seems not possible since the compiler doesn't find Type T.

I know that I could use object开发者_StackOverflow中文版 but I want it to be strongly typed. So my question is if there is a possibility of getting this working.

---

Generic types do not have a common type or interface amongst concrete definitions by default.

Have your Setting<T> class implement an interface (or derive from a common class) and create a list of that interface (or class).

public interface ISetting { }

public class Setting<T> : ISetting
{
    // ...
}

// example usage:
IList<ISetting> list = new List<ISetting>
{
    new Setting<int> { name = "foo", value = 2 },
    new Setting<string> { name = "bar", value "baz" },
};

---

You have to use a common ancestor class for all the class types that you put into the list. If it should be arbitrary types you have to use object for T

---

You can use T only inside your class:

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

not outside. Outside you need to specify the concrete type:

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

or

List<Settings<string>> list = new List<Settings<string>>();
list.Add(stringSettings);

---

ye you can do it by using reflection i wrote such code for another question but you can use this

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;
    }
}

and call it like this

    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 };
    }
}