La fonction A (Exception ex) est-elle identique à la fonction B <T> (T ex) où T: Exception?

Question

Deux questions simples sur les génériques.

Les définitions de deux fonctions suivantes sont-elles identiques?

FunctionA(Exception ex); 

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

L'implémentation générique (FunctionB) a-t-elle des avantages par rapport à l'implémentation normale (FunctionA)?

Answer 1

Voir cette question:
Difference between generic argument constrained to an interface and just using the interface

Answer 2

Les éléments suivants sont effectivement les mêmes (dans les résultats):

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

Mais ce n'est pas la même chose si vous faites ceci:

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

C'est parce que FunctionB se tapée à ApplicationException au moment de la compilation , où l'appel à FunctionA va toujours réduire le paramètre à Exception. Selon votre implémentation de FunctionB, cela peut ne pas importer, mais il y a des cas où cela peut faire la différence. Je dirais qu'en règle générale, si votre implémentation de méthode n'a pas besoin de l'implémentation générique, ne l'utilisez pas.

Voici quelques exemples de cas où il serait question:

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

L'exemple suivant a besoin d'un code supplémentaire pour le contexte, donc voir le code dessous:

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

A l'intérieur des fonctions, il serait pas de différence. La différence vient de l'extérieur. Si vous utilisez la fonction générique, vous pouvez renvoyer le même type d'exception au code appelant au lieu de la base Exception. Dans la plupart des cas, c'est un point discutable.

Answer 4

Il n'y a pas beaucoup d'un avantage que FunctionB a plus fonctionn. Cependant, il existe une différence nette entre les deux. Avec FunctionA, vous pouvez transmettre tout type dérivé d'une (ou d'une) exception dans la fonction. Avec FunctionB, vous pouvez transmettre tout type dérivé de T (qui doit provenir de ou être une exception) dans la fonction. Cela signifie qu'en fonction du type de T, vous aurez un paramètre plus spécialisé qui limitera les types que vous pouvez lui passer, car le paramètre sera tapé T, pas Exception. Maintenant, si T est une exception, alors ce n'est pas grave, les fonctions sont les mêmes. Cependant, si T est une exception InvalidOperationException, seules les instances de InvalidOperationException (et les classes qui en dérivent) sont autorisées.

Ceci est généralement ce que vous voulez quand vous voulez assurer la spécialisation d'un type sans avoir à recourir à des classes de base qui ne fournissent pas le niveau de spécialisation dont vous avez besoin.