Façon de voir automatiquement les fonctions peuvent revenir potentiellement exception dans c #

https://stackoverflow.com/questions/915941

06-09-2019
|

Question

rien de plus frustrant que de voir votre accident de code dans le débogueur sur une méthode qui exceptionned et vous ne l'avez pas essayer / attraper.

Y at-il un moyen facile de parcourir vos sources et baliser toutes les fonctions qui peuvent potentiellement lancer des exceptions?

La construction en aide visuelle ont une option cachée pour colorer ces fonctions dans une couleur spécifique?

Merci

La solution

Je pense que Redgate ont un certain un outil pour cette « exception Hunter » Ils facturent après un procès.

http://www.red-gate.com/products/Exception_Hunter /index.htm

Autres conseils

Tout le code, mais le plus trivial pourrait lancer des exceptions (de mémoire, à tout le moins). Vous êtes probablement mieux écrire votre code défensivement, avec au moins un essai global / catch plutôt que d'essayer de microgérer les sections de code sera ou ne sera pas lancer des exceptions.

Non, il n'y a aucun moyen de faire automatiquement ce n'est-il un bon moyen d'obtenir une liste de toutes les exceptions possibles lancées par une méthode. Voici quelques raisons pour lesquelles

Considérez les exceptions lancées implicitement telles que StackOverflowException peut être jeté à tout moment de toute méthode. Vous devez supposer que toute méthode dans le CLR peut lancer ces types d'exceptions
Réflexion et / ou délégués peuvent cacher le code réel étant appelé à une méthode particulière de sorte que vous ne pouvez pas inspecter tous les chemins de code possibles d'une méthode.
Il faudrait inspecter IL et métadonnées.
Dans .Net il n'y a pas d'obligation de documenter les exceptions levées explicitement par une API

Comme d'autres l'ont dit, je ne sais pas si vous trouverez un moyen infaillible de faire cela en C # depuis ne supporte pas les exceptions vérifiées.

Comme un peu d'un côté, cela me rappelle d'un entretien avec Anders Hejlsberg discuter « Le problème avec des exceptions cochés ». Je ne cherche pas à la flamme vérifié des exceptions, mais ce qui suggère que vous lisez la raison d'être Ander derrière la conception d'exception de C # et de la manière suggérée pour la gestion des exceptions:. Gestion des exceptions centralisée

Je pense que le ReSharper vous donne des conseils sur les exceptions. Mais pour la raison que C # ne supporte pas les exceptions vérifiées, il y a moyen de déterminer les exceptions. Peut-être que des outils d'analyse de code comme NDepend l'appui.

Tout peut lancer une exception. Consultez MSDN pour une liste d'exceptions qui peuvent être jeté par une méthode.

Toutes les méthodes non vides peuvent lancer des exceptions sous une forme ou une autre. Si vous êtes préoccupé par des exceptions que vous avez personnellement généré, vous pouvez les afficher à partir IntelliSense dans les mêmes méthodes cadres comme le font au moyen de documents XML, comme ceci:

/// <summary>  
/// I seem to have written a method to do a thing.
/// </summary>  
/// <exception cref="System.Exception">An unfortunate failure.</exception>
public void DoSomething()
{
   /* ... */
}

Tout code pourrait provoquer une exception, il est de votre devoir d'essayer et d'anticiper cela!

Il y a un certain nombre d'outils tiers qui peuvent aider à trouver des erreurs communes et des outils FxCop par exemple tels que refactor peuvent faire des suggestions.

Il y a du travail accompli au moment qui peut vous aider à trouver des exceptions possibles. Jetez un coup d'oeil dans PEX qui peut aider à générer des tests pour vos fonctions: research.microsoft.com/en-us/projects/Pex/ (lien semble être en baisse au moment de l'affichage)

Un autre domaine intéressant est celui des contrats de code (à venir en .net 4 / disponibles comme spécifications #). contrats de code vous permettent d'écrire des déclarations qui précisent les conditions qui doivent être remplies. Ceux-ci peuvent être avant et après votre fonction appelée et vous pouvez également déclarer invariants. Une condition pourrait être quelque chose d'aussi simple que la valeur! = Null. Ces conditions sont ensuite analysées lors de la compilation et l'exécution pour vérifier le code des chemins ne les violent.

Comme les autres l'ont dit, vous devriez supposer que chaque ligne de code peut lancer une exception, à moins que vous avez prouvé qu'il ne peut pas. La meilleure question est, « qu'allez-vous faire à ce sujet? »

En général, vous ne devriez pas prendras des exceptions du tout.

Bien sûr, tout est bien une exception à cette règle. Il est logique de prendre une exception pour vous identifier (si votre environnement ne fait pas pour vous, tout comme ASP.NET). Il est logique de prendre une exception afin de le remplacer par une autre exception qui fournit plus de détails sur le contexte:

public int GetConfiguredInteger(string name) {
    string s = null;
    try {
        s = GetStringFromConfigFile(name);
    }
    catch (IOException ex) {
        throw new Exception(String.Format(
            "Error in configuration file foo.config when processing {0}", name),
            ex);
    }
    return int.Parse(s);
}

L'appelant ne pouvait pas savoir que le IOException a été causé par un fichier de configuration si vous les aviez pas dit. Notez également la façon dont je l'ai ignoré toutes les exceptions ne sont pas liées au fichier E / S. En particulier, notez que le int.Parse n'est pas même à l'intérieur du bloc try / catch.

Il y a un petit nombre d'autres de telles exceptions, mais l'idée de base de Attraper les exceptions sont:. Ne le faites pas à moins que ce serait pire si vous ne l'avez pas

Il y a un réflecteur ajouter Exception Finder qui montrera quelles exceptions pourraient être projetés par une méthode. Je ne l'ai pas utilisé, mais a vu un exemple de celui-ci lors d'une réunion de groupe d'utilisateurs .Net.

Il est un outil qui il peut le faire. Vous pouvez télécharger le procès et voir si vous l'aimez. Je ne pense pas vraiment que ce serait si nécessaire, mais si vous travaillez pour une entreprise, et ils vont payer pour cela que vous pourriez vouloir examiner. Comme a été dit il y a juste trop d'exceptions possibles qui seront soulevées. Consultez Excpetion Hunter

Exception Hunter mentionné par quelques personnes est un bon outil pour aider. Je ne sais pas si elle a un lien dans le commentaire <exception> XML-Doc afin que vous puissiez appliquer la documentation des exceptions lancées par le code.

Je trouve beaucoup plus frustrant pour briser l'intérieur d'un bloc catch extérieur et creuser mon chemin jusqu'au point réel où l'exception happend.

La plupart du temps, si une exception a été levée et je ne m'y attendais pas, j'ai trouvé un bug et il est plus facile de le résoudre si elle n'a pas été obscurcie par une gestion des exceptions-rien Doing.

EDIT: Étant donné que vos exemples est en fait un bon je ne suis toujours pas convaincu qu'un tel outil pourrait vous aider. Il y aurait tant d'exceptions possibles que littéralement chaque ligne de code pourrait jeter que vous auriez du mal à trouver les « intéressants ».

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow