函數A（異常ex）與函數B <T>（T ex）相同，其中T：異常？

Question

關於泛型的兩個簡單問題。

以下兩個函數定義是否相同？

FunctionA(Exception ex); 

FunctionB<T>(T ex) where T : Exception; 

通用實現（FunctionB）對正常實現（FunctionA）有優勢嗎？

Answer 1

看到這個問題：
Difference between generic argument constrained to an interface and just using the interface

Answer 2

以下是有效的相同（結果）：

catch (Exception e) 
{ 
    FunctionA(e); 
    FunctionB(e); 
} 

但是，如果你做到這一點是不一樣的：

catch (ApplicationException e) 
{ 
    FunctionB(e); 
} 
catch (Exception e) 
{ 
    FunctionA(e); 
} 

這是因爲FunctionB得到在編譯時輸入到ApplicationException的，那麼對FunctionA的調用將始終將該參數向下轉換爲Exception。根據你對FunctionB的實現，這可能並不重要，但有些情況下它可以有所作爲。我會說，作爲一個經驗法則，如果你的方法實現不需要泛型實現，那就不要使用它。

下面是它何時會的一些實例：

public T AddSomeContextToThisException<T>(T ex) where T : Exception 
{ 
    ex.Data.Add("Some key", "Some context message"); 
    return ex; 
} 

public T ThisIsABadIdeaForExceptionsButMaybeAGoodIdeaForOtherTypes<T>(T ex) where T : Exception, new() 
{ 
    // do something with ex 

    return new T(); 
} 

下面的示例需要上下文一些額外的代碼，所以看到它下面的代碼：

private readonly Bar bar = new Bar(); 

public void HandExceptionOffToSomethingThatNeedsToBeStronglyTyped<T>(T ex) where T : Exception 
{ 
    ICollection<T> exceptions = bar.GetCollectionOfExceptions<T>(); 
    exceptions.Add(ex); 

    // do other stuff 
} 

public class Bar 
{ 
    // value is object, because .net doesn't have covariance yet 
    private Dictionary<Type, object> listsOfExceptions = new Dictionary<Type, object>(); 

    public ICollection<T> GetCollectionOfExceptions<T>() 
    { 
     if (!listsOfExceptions.ContainsKey(typeof(T))) 
     { 
      listsOfExceptions.Add(typeof(T), new List<T>()); 
     } 
     return listsOfExceptions[typeof(T)] as List<T>; 
    } 
} 

Answer 3

裏面的功能外，還有沒有區別。差異來自外部。如果使用通用函數，則可以將相同類型的例外返回給調用代碼而不是基地址Exception。大多數情況下，這是一個有爭議的問題。

Answer 4

沒有太多的是FunctionB擁有泛函的優勢。但是，兩者之間有明顯的區別。

使用FunctionA，您可以將從（或是）Exception派生的任何類型傳遞給該函數。

使用FunctionB，您可以將從T派生的任何類型（必須派生自或作爲Exception）傳遞給該函數。

這意味着根據T的類型，您將擁有一個更專用的參數，它將限制可以傳遞給它的類型，因爲該參數將被輸入爲T，而不是Exception。

現在如果T是一個異常，那麼它沒關係，功能是一樣的。但是，如果T是InvalidOperationException，那麼只允許InvalidOperationException（以及從它派生的類）的實例。

這通常是你想要的，當你想確保一個類型的專業化而不必訴諸不提供你需要的專業化水平的基類。