在集合中使用通用類型，而不使用C＃中的通用類

Question

我有一種情況，我有一個不是通用類的類，但它需要存儲集合中通用對象的實例。在下面的例子中，我不能使Foo是通用的，但我需要將請求對象存儲在pendingRequests字典中。下面的代碼將在pendingRequests聲明中給出一個錯誤：「使用泛型類型的Request需要'1'類型參數」，但如果我將<Response>添加到Request中，那麼當我嘗試添加到addRequest中的字典時，我收到了一個投射錯誤。

我需要使字典聲明通用，但沒有使通用Foo。可以這樣做，還是應該以另一種方式做這件事？爲此添加一個皺紋，我堅持使用.NET 2.0，因爲它需要與Unity 3d協同工作。

class Foo 
{ 
    private Dictionary<int, Request> pendingRequests; 

    void addRequest<T>(int sequence, Request<T> request) where T : Response 
    { 
     pendingRequests[sequence] = request; 
    } 
} 

class Request<T> where T : Response 
{ 
} 

class Response 
{ 
} 

Answer 1

我在回答不同的問題時發現了答案。我可以爲不通用的請求創建基類或接口。通用請求然後從基本的非通用請求中繼承。非泛型請求用於addRequest和Foo中的集合。從我的Java角度來看，這是手動完成我習慣的類型擦除。

class Foo 
{ 
    private Dictionary<int, IRequest> pendingRequests; 

    void addRequest(int sequence, IRequest request) 
    { 
     pendingRequests[sequence] = request; 
    } 
} 

class Request<T> : IRequest where T : Response 
{ 
} 

class Response 
{ 
} 

interface IRequest 
{ 
} 

Answer 2

富不能因爲除了保持通用要求的集合通用的，它是獨立完整的請求。有一個Foo實例（將其稱爲會話），但有幾十種不同類型的請求。它並不關心一個請求是一個LoginRequest還是一個BuyMeRequest。但是，Request是通用的，因爲我使用提供的Response類型來構造當前類型的Response對象，並將它從通過線路傳入的數據反序列化。

那麼你的收藏不應該是通用要麼。您可能需要考慮放棄泛型定義並簡單地使用繼承。這應該讓你在路上，雖然不是100％，但你的問題在用法上是模糊的。當然，這使用LINQ（我認爲是3.5+或更高版本），它應該很容易遷移到2.0。

public class Foo 
{ 
    // initialize: best practice 
    private List<CacheRequest> _pendingRequests = 
    new List<CacheRequest>(); 

    // upper case: best practice 
    public void AddRequest(int sequence, Request request) 
    { 
    if (request.Response == null) 
    { 
     throw new ArgumentException("Request Response cannot be null."); 
    } 

    _pendingRequests.Add(new CacheRequest() 
    { 
     Sequence = sequence, 
     Request = request, 
     ResponseType = request.Response.GetType() 
    }); 
    } 

    public bool TryGetRequest<T>(int seq, out Request request, out T response) 
    where T : Request 
    { 
    response = null; 
    request = null; 

    var pendingRequest = _pendingRequests 
     .Where(cr => cr.ResponseType == typeof(T)) 
     .FirstOrDefault(r => r.Sequence == seq); 

    var result = pendingRequest != null; 

    if (result) 
    { 
     request = pendingRequest.Request; 
     response = request.Response as T; 
    } 

    return result; 
    } 

    private class CacheRequest 
    { 
    public int Sequence { get; set; } 
    public Request Request { get; set; } 
    public Type ResponseType { get; set; } 
    } 
} 

public class Request 
{ 
public Response Response { get; set; } 
} 

public abstract class Response { } 

public class HttpResponse : Response { } 

public class UdpResponse : Response { } 

實施例：

var foo = new Foo(); 

    foo.AddRequest(1, new Request() { Response = new HttpResponse() }); 

    Request request; 
    HttpResponse httpResponse; 
    UdpResponse udpResponse; 


    if (foo.TryGetRequest<HttpResponse>(1, out request, out httpResponse)) 
    { 
     Console.WriteLine("1 is an HttpResponse"); 
    } 

    if (!foo.TryGetRequest<UdpResponse>(1, out request, out udpResponse)) 
    { 
     Console.WriteLine("1 is not a UdpResponse"); 
    }  

輸出：

1是一個HttpResponse

1不是UdpResponse

DotNetFiddle Example