我可以有/使用一个字段/属性与列表>T可以是任意值

internal class Request<TRequest, TResponse>
    where TRequest : class
    where TResponse : class
{
    public Uri RequestUri;
    public TRequest RequestItem;
    public TResponse ResponseItem;
    ...
}

private List<Request<object, object>> requests;

var a = new Request<FooRequest, BarResponse>();
requests.Add(a);

switch (@req.RequestType)
{
    case RequestType.FirstKindOfRequest:
        await Deserialize<FirstKindOfRequest, FirstKindOfResponse>(req);
        break;
    case RequestType.SecondKindOfRequest:
        ...
}

这是一个典型的情况。我之前也问过很多次。我看到两种方法

->明显的选择是有一个非泛型基类/接口，它可以解释所有的请求类型，然后携带List<NonGenericRequest>。

第二种方法是利用协方差。我看到你面对一些问题。我将尝试解决它，一个接一个:

接口不能有字段。因此，我必须将列表的项强制转换为Request<>的实例才能访问我想要的内容。

不要使用字段。想都别想。切换到属性。我必须重申这一点。接口——实际上是所有的公共api——处理属性。

或者我可以在接口中设置属性。但是它告诉我不能使用关键字out

问题是属性的设置。它破坏了类型安全。更多信息请看这个帖子。

这意味着<TRequest,TResponse>部分将是无用的。这意味着我将只使用列表，我的Stackoverflow问题的答案是:不，你不能使用/受益于在c#中存储List<Class<T>>。

到目前为止，您可以编写类似var requests = new List<IRequest<object, object>>()的内容。但是这意味着你不会得到强类型的TRequest和TResponse。解决方案是摆脱泛型类型参数TRequest和TResponse(即您的约束where T : class)，并包括一个更可用的约束。对你有用的东西。

---

将它们组合起来，开始:

interface IMessage //I will call it IMessage for now
{
    //implement whatever that make deserializing possible
}
class FooRequest : IMessage
{
}
class BarResponse : IMessage
{
}
interface IRequest<out TRequest, out TResponse>
    where TRequest : IMessage 
    where TResponse : IMessage 
{
    TRequest RequestItem { get; }
    TResponse ResponseItem { get; }
    //whatever fits, but only getters for out parameter types
}
class Request<TRequest, TResponse> : IRequest<TRequest, TResponse>
    where TRequest : IMessage 
    where TResponse : IMessage 
{
    //you can extend interface properties with setters here
}

现在你可以写:

var requests = new List<IRequest<IMessage, IMessage>>();
var a = new Request<FooRequest, BarResponse>();
requests.Add(a);
foreach (var request in requests)
{
    Deserialize(request);
}
void Deserialize<TRequest, TResponse>(IRequest<TRequest, TResponse> request)
    where TRequest : IMessage
    where TResponse : IMessage
{
    //have access to request.RequestItem, request.ResponseItem etc
}

注意:为了简单起见，我假设TRequst和TResponse是相似的类型，因此它们都是从IMessage进化而来的。您可以为它们提供单独的IRequest和IResponse类型接口。

您可以通过提取一个可变的IRequest接口来利用接口差异:

interface IRequest<out T, out T1>
{
}

并在你的Request类中实现它:

class Request<TRequest, TResponse> : IRequest<TRequest, TResponse>
    where TRequest : class
    where TResponse : class

这将允许您创建一个可以存储任意IRequest实例的List<IRequest< object, object>>:

var s = new List<IRequest< object, object>>();
s.Add(new Request<c1, c2>());

如果您想要一些特定类型的行为，您仍然需要将列表的内容强制转换为更特定的类。在高流量情况下，这可能会也可能不会影响性能。

另一个选项是存储请求的字符串内容，或者将它们提取到抽象基类中。对于缓存和日志记录来说，这个抽象类的列表绰绰有余。你可以这样写:

abstract class BaseRequest
{
    public string RequestContent { get; protected set; }
    public string ResponseContent { get; set; }
}
class Request<TRequest, TResponse> : BaseRequest
    where TRequest : class
    where TResponse : class

你还可以写:

var s = new List<BaseRequest>();
s.Add(new Request<c1, c2>());

我认为泛型通配符可以帮助你:http://visualstudio.uservoice.com/forums/121579-visual-studio/suggestions/2633766-wildcard-generic

由于这至少在不久的将来不会发生，我看到三个选项:

• 你可以投票，等待，并希望微软在泛型中采用通配符…
• 正如Mrida所评论的，你可以将你的代码转换为使用接口，然后使用c#协方差。
• 如果协方差不是一个可接受的解决方案，你可以定义一个非泛型基类RequestBase，只有非泛型的功能，并使RequestBase列表(编辑:我认为这是HenkHolterman的评论)。或者，如果您不想更改Request类，您可以使用非泛型功能定义非泛型包装器。