Comment et où utilisez-vous Assertions dans votre code C#?

Question

J'ai besoin de savoir comment et où vous utilisez des assertions dans C#.

EDIT J'ai besoin d'exemples pratiques d'où il est le plus approprié d'utiliser des assertions. C'est pourquoi j'ai besoin des exemples de ceux qui ont utilisé les

Answer 1

La réponse immédiate que je peux penser est lorsque vous testez le code:

Assert.IsNotNull(yourVariable); 

Vous pouvez également utiliser la Debug.Assert

System.Diagnostics.Debug.Assert(myBooleanProperty); 

Answer 2

Google devrait vous donner beaucoup d'exemples (indice: exemple de type csharp assert)

http://en.csharp-online.net/Assert

Answer 3

Je préfère utiliser des tests unitaires pour étoffer les problèmes. Comme mon produit principal est une bibliothèque/un assemblage, il est également nécessaire de s'assurer que les arguments sont validés et que les exceptions appropriées sont levées. Remarque intéressante: Debug.Assert() est intercepté par le compilateur MS C# dans une version release et supprimé.

Answer 4

Il y avait une bonne discussion sur l'utilisation de Debug.Assert() un certain temps: Debug.Assert vs Exceptions

Answer 5

Bien sûr, dans les tests unitaires.

tests unitaires extérieur je peux identifier 3 types d'erreurs (très simplifié):

1. erreur interne critique: Quelque chose qui vient de l'intérieur de votre unité de code, que l'utilisateur n'a aucun moyen d'influencer.
2. Utilisation abusive de certaines fonctionnalités: Par exemple en donnant une valeur nulle au lieu d'une certaine valeur
3. problèmes externes: tels que les fichiers non existants, aucune connexion réseau, etc.

Je pense que les affirmations doivent être appliquées uniquement au premier. Les numéros deux et trois doivent être traités en utilisant les exceptions appropriées.

Answer 6

J'aime vraiment soutenir ExceptionHandling pendant debugtime en utilisant Debug.Assert() ou même Debug.Fail():

if(!whatever_I_expect) 
{ 
    var message = "<exception message>"; 
    Debug.Fail(message); 
    throw new InvalidOperation(message); 
} 

De cette façon, je reçois la boîte de dialogue très pratique de Debug.Assert() et peut choisissez entre ignorer, réessayer et abandonner. Retry entrera dans le code où je peux commencer le débogage. Les méthodes particulièrement récursives ou les constructions d'essai-compliquées compliquées peuvent être mieux débuggées de cette façon. Vous obtenez toujours la bonne pile d'appels. Et dans mon releasecode j'ai toujours un errorlingling valide sans messageboxes.

Answer 7

J'utilise souvent Debug.Assert pour vérifier les conditions préalables pour mon code. Si un objet dépend de la présence d'un autre objet, je pourrais affirmer que cet autre objet n'est pas nul par exemple. Cela rend beaucoup de problèmes visibles avant même que je passe mes programmes à tester.

Il y a une fine ligne entre ce que je voudrais vérifier avec les tests unitaires et ce que je veux vérifier pendant l'exécution avec les assertions.Habituellement, les tests unitaires servent à tester une seule unité de code lorsque le reste de l'application est dans un état bien défini (j'utilise largement les objets fantaisie pour cela) et j'utilise debug.assert pour vérifier pendant l'exécution si l'état de l'application est J'esperais.

Answer 8

Il existe différentes vues (voir le sous-sujet récent dans comp.lang.C++. Modéré, sujet "Nous n'utilisons pas les exceptions C++"). Je considère que les assertions sont les meilleures pour vérifier et documenter les choses que vous savez ne peut pas être faux, sauf si l'implémentation est incohérente. C'est plus fort que les pré-conditions et les invariants.

E.g. qu'une fonction d'assistance, qui ne peut être appelée qu'à partir de plusieurs endroits différents, a une ressource disponible. Parce que cette aide est privée et seulement utilisée dans une classe en lançant une ArgumentException n'est pas appropriée (c'est pour l'interface public/protected).

Answer 9

J'ai utilisé un peu Debug.Assert() dans un code qui ne devrait jamais recevoir un paramètre incorrect/invalide - le type de code où les paramètres d'entrée et les variables dépendantes auraient déjà été validés. La vérité est, je sais Je vais faire des erreurs. Je ne sais pas où. :-) L'utilisation judicieuse de "Debug.Assert" m'aide à faire face à mes imperfections.

Voici un exemple de mon propre code:

public bool AddPoint(uint time, object value) 
    { 
     bool success = false; 
     int index = 0; 

     Debug.Assert(_selectedParameterName != null, "RecipeBusinessObject.InsertPointAtTime() _selectedParameterName = null"); 
     Debug.Assert(_currentRecipe != null, "RecipeBusinessObject.InsertPointAtTime() _currentRecipe = null");   
     Debug.Assert(CurrentParameterTable != null, "RecipeBusinessObject.InsertPointAtTime() CurrentParameterTable = null"); 

     Debug.Assert(index >= 0, "RecipeBusinessObject.InsertPoint(), index out of range, index = " + index.ToString()); 
     Debug.Assert(index <= CurrentParameterTable.Rows.Count, "RecipeBusinessObject.InsertPoint(), index out of range, index = " + index.ToString()); 

     DataRow newRow = CurrentParameterTable.NewRow(); 

     <snip>