Meilleure exception pour un argument de type générique non valide

J'écris actuellement du code pour UnconstrainedMelody qui a des méthodes génériques à voir avec les enums.

Maintenant, j'ai une classe statique avec un tas de méthodes qui sont ne destinées qu'à être utilisées avec des énumérations "flags". Je ne peux pas ajouter cela comme contrainte ... il est donc possible qu'ils soient également appelés avec d'autres types d'énumérations. Dans ce cas, j'aimerais lancer une exception, mais je ne sais pas laquelle lancer.

Juste pour rendre cela concret, si j'ai quelque chose comme ça:

// Returns a value with all bits set by any values
public static T GetBitMask<T>() where T : struct, IEnumConstraint
{
    if (!IsFlags<T>()) // This method doesn't throw
    {
        throw new ???
    }
    // Normal work here
}

Quelle est la meilleure exception à lancer? ArgumentExceptionCela semble logique, mais c'est un argument de type plutôt qu'un argument normal, ce qui pourrait facilement semer la confusion. Dois-je présenter ma propre TypeArgumentExceptionclasse? Utiliser InvalidOperationException? NotSupportedException? Rien d'autre?

Je plutôt pas créer ma propre exception pour ce à moins qu'il soit clairement la bonne chose à faire.

NotSupportedException semble tout à fait convenable, mais la documentation indique clairement qu'il devrait être utilisé à des fins différentes. D'après les remarques de la classe MSDN:

Il existe des méthodes qui ne sont pas prises en charge dans la classe de base, avec l'espoir que ces méthodes seront implémentées dans les classes dérivées à la place. La classe dérivée peut implémenter uniquement un sous-ensemble des méthodes de la classe de base et lancer NotSupportedException pour les méthodes non prises en charge.

Bien sûr, il y a un moyen par lequel NotSupportedException est évidemment assez bon, surtout compte tenu de son sens commun. Cela dit, je ne sais pas si c'est juste.

Étant donné le but de la mélodie sans contrainte ...

Il y a diverses choses utiles qui peuvent être faites avec des méthodes / classes génériques où il y a une contrainte de type «T: enum» ou «T: delegate» - mais malheureusement, celles-ci sont interdites en C #.

Cette bibliothèque utilitaire contourne les interdictions en utilisant ildasm / ilasm ...

... il semble qu'un nouveau Exceptionsoit en ordre malgré le lourd fardeau de la preuve que nous devons à juste titre satisfaire avant de créer une personnalisation Exceptions. Quelque chose comme ça InvalidTypeParameterExceptionpourrait être utile dans toute la bibliothèque (ou peut-être pas - c'est sûrement un cas de pointe, non?).

Les clients devront-ils être en mesure de distinguer cela des exceptions BCL? Quand un client pourrait-il accidentellement appeler cela en utilisant une vanille enum? Comment répondriez-vous aux questions posées par la réponse acceptée à Quels facteurs doivent être pris en compte lors de l'écriture d'une classe d'exceptions personnalisée?

J'éviterais NotSupportedException. Cette exception est utilisée dans le cadre où une méthode n'est pas implémentée et il existe une propriété indiquant que ce type d'opération n'est pas pris en charge. Ça ne rentre pas ici

• Référence de soi sans vergogne: http://blogs.msdn.com/jaredpar/archive/2008/12/12/notimplementedexception-vs-notsupportedexception.aspx

Je pense qu'InvalidOperationException est l'exception la plus appropriée que vous puissiez lancer ici.

La programmation générique ne doit pas lancer lors de l'exécution pour les paramètres de type non valides. Il ne devrait pas compiler, vous devriez avoir une application de temps de compilation. Je ne sais pas quoiIsFlag<T>() contient, mais vous pouvez peut-être transformer cela en une application au moment de la compilation, comme essayer de créer un type qu'il n'est possible de créer qu'avec des «indicateurs». Peut-être qu'une traitsclasse peut vous aider.

Mettre à jour

Si vous devez lancer, je voterais pour InvalidOperationException. Le raisonnement est que les types génériques ont des paramètres et que les erreurs liées aux paramètres (méthode) sont centrées autour de la hiérarchie ArgumentException. Cependant, la recommandation sur ArgumentException indique que

si l'échec n'implique pas les arguments eux-mêmes, alors InvalidOperationException doit être utilisé.

Il y a au moins un acte de foi là-dedans, que les recommandations de paramètres de méthode doivent également être appliquées aux paramètres génériques , mais il n'y a rien de mieux dans la hiérarchie SystemException à mon humble avis.

J'utiliserais NotSupportedException car c'est ce que vous dites. D'autres énumérations que celles spécifiques ne sont pas prises en charge . Cela serait bien entendu indiqué plus clairement dans le message d'exception.

J'irais avec NotSupportedException. Bien que cela ArgumentExceptionsemble correct, il est vraiment attendu lorsqu'un argument passé à une méthode est inacceptable. Un argument de type est une caractéristique déterminante pour la méthode réelle que vous souhaitez appeler, pas un véritable «argument». InvalidOperationExceptiondoit être lancée lorsque l'opération que vous effectuez peut être valide dans certains cas, mais pour la situation particulière, c'est inacceptable.

NotSupportedExceptionest levée lorsqu'une opération n'est pas prise en charge par nature. Par exemple, lors de l'implémentation d'une interface où un membre particulier n'a pas de sens pour une classe. Cela ressemble à une situation similaire.

Apparemment, Microsoft utilise ArgumentExceptionpour cela, comme illustré sur l'exemple de Expression.Lambda <> , Enum.TryParse <> ou Marshal.GetDelegateForFunctionPointer <> dans la section Exceptions. Je n'ai pas trouvé d'exemple indiquant le contraire non plus (malgré la recherche d'une source de référence locale pour TDelegateet TEnum).

Donc, je pense qu'il est prudent de supposer qu'au moins dans le code Microsoft, c'est une pratique courante à utiliser ArgumentExceptionpour les arguments de type générique non valides en dehors des variables de base. Étant donné que la description de l'exception dans la documentation ne fait pas de distinction entre celles-ci, ce n'est pas non plus trop extensible.

Espérons qu'il décide une fois pour toutes de la question.

Id aller avec NotSupportedExpcetion.

Lancer une exception personnalisée doit toujours être fait dans tous les cas où cela est discutable. Une exception personnalisée fonctionnera toujours, quels que soient les besoins des utilisateurs de l'API. Le développeur pourrait attraper l'un ou l'autre type d'exception s'il ne s'en soucie pas, mais si le développeur a besoin d'un traitement spécial, il sera SOL.

Que diriez-vous d'hériter de NotSupportedException. Bien que je sois d'accord avec @Mehrdad pour dire que cela a le plus de sens, j'entends votre remarque que cela ne semble pas correspondre parfaitement. Alors héritez de NotSupportedException, et de cette façon, les gens qui codent contre votre API peuvent toujours attraper une NotSupportedException.

Je me méfie toujours d'écrire des exceptions personnalisées, uniquement au motif qu'elles ne sont pas toujours clairement documentées et qu'elles causent de la confusion si elles ne sont pas nommées correctement.

Dans ce cas, je lancerais une ArgumentException pour l'échec de la vérification des indicateurs. C'est vraiment une question de préférence. Certaines normes de codage que j'ai vues vont jusqu'à définir les types d'exceptions à lancer dans des scénarios comme celui-ci.

Si l'utilisateur essayait de transmettre quelque chose qui n'était pas une énumération, je lancerais une exception InvalidOperationException.

Éditer:

Les autres soulèvent un point intéressant sur le fait que cela n'est pas pris en charge. Ma seule préoccupation avec une NotSupportedException est que ce sont généralement les exceptions qui sont levées lorsque la "matière noire" a été introduite dans le système, ou pour le dire autrement, "Cette méthode doit aller dans le système sur cette interface, mais nous avons gagné ne l’activez pas avant la version 2.4 "

J'ai également vu NotSupportedExceptions être levé comme une exception de licence "vous exécutez la version gratuite de ce logiciel, cette fonction n'est pas prise en charge".

Modifier 2:

Un autre possible:

System.ComponentModel.InvalidEnumArgumentException  

L'exception levée lors de l'utilisation d'arguments non valides qui sont des énumérateurs.

Je voterais également pour InvalidOperationException. J'ai fait un organigramme (incomplet) sur les directives de lancement d'exceptions .NET basées sur les Framework Design Guidelines 2nd Ed. il y a quelque temps si quelqu'un est intéressé.