Quand dois-je utiliser Debug?Assert ()?

mettez Debug.Assert() partout dans le code où vous voulez avoir des contrôles de bon sens pour assurer des invariants. Lorsque vous compilez une version (i.e., pas de constante de compilateur DEBUG ), les appels à Debug.Assert() seront supprimés afin qu'ils n'affectent pas les performances.

vous devez toujours jeter les exceptions avant d'appeler Debug.Assert() . L'assertion vient vérifier que tout est comme prévu alors que vous êtes encore en développement.

À Partir De Code Complete

8 Programmation Défensive

8.2 Affirmations

une assertion est un code qui est utilisé pendant le développement-généralement une routine ou macro-qui permet à un programme de vérifier lui-même pendant qu'il exécute. Lorsqu'un l'affirmation est vraie, cela signifie que tout fonctionne comme prévu. Quand il est faux, cela signifie qu'il a détecté une erreur inattendue dans le code. Pour par exemple, si le système suppose qu'une dossier ne sera jamais plus de 50.000 dossiers, le programme pourrait contenir une affirmation que le nombre de dossiers est inférieur ou égal à 50 000. Aussi longtemps que le nombre de dossiers est inférieure ou égale à 50 000, l'affirmation sera silencieuse. Si il rencontre plus de 50 000 disques, cependant, il va bruyamment "affirmer" qu'Il ya une erreur dans le programme.

Affirmations sont particulièrement utiles dans les grand, les programmes compliqués, et de dans les programmes de haute fiabilité. Ils permettent aux programmeurs de plus rapidement éliminer les hypothèses d'interface non concordantes, les erreurs qui se glissent quand le code est modifié, et ainsi de suite.

une assertion prend habituellement deux arguments: une expression booléenne qui décrit l'hypothèse qui est censée être vraie et un message à afficher si ce n'est pas le cas.

( ... )

Normalement, vous ne voulez pas les utilisateurs doivent voir les messages d'assertion dans code de production; les assertions sont principalement destinées à être utilisées pendant le développement et de la maintenance. Les affirmations sont compilés dans le code temps de développement et compilé hors du code pour la production. Lors développement, les assertions démasquent les hypothèses contradictoires, des conditions inattendues, des mauvaises valeurs transmises à la routine, et ainsi de suite. Au cours de la production, ils sont compilés hors du code de sorte que le les assertions ne dégradent pas les performances du système.

Utilisation affirme pour vérifier développeur hypothèses et à des exceptions pour vérifier les hypothèses liées à l'environnement.

FWIW ... Je trouve que mes méthodes publiques ont tendance à utiliser le if () { throw; } modèle pour s'assurer que la méthode est appelée correctement. Mes méthodes privées ont tendance à utiliser Debug.Assert() .

l'idée est qu'avec mes méthodes privées, je suis celui sous contrôle, donc si je commence à appeler une de mes propres méthodes privées avec des paramètres qui sont incorrects, alors j'ai brisé ma propre hypothèse quelque part--je n'aurais jamais dû entrer dans cet état. En production, ces privé affirme devrait idéalement être du travail inutile puisque je suis censé garder mon état interne valide et cohérente. Contrairement aux paramètres donnés aux méthodes publiques, qui pourraient être appelés par n'importe qui à l'exécution: j'ai encore besoin d'y imposer des contraintes de paramètre en lançant des exceptions.

en outre, mes méthodes privées peuvent encore lancer des exceptions si quelque chose ne fonctionne pas à l'exécution (erreur réseau, erreur d'accès aux données, mauvaises données extraites d'un service tiers, etc.). Mes assertions sont juste là pour s'assurer que je n'ai pas cassé ma propre interne des hypothèses sur l'état de l'objet.

Si j'étais vous, je ferais:

Debug.Assert(val != null);
if ( val == null )
    throw new exception();

ou pour éviter les contrôles répétés

if ( val == null )
{
    Debug.Assert(false,"breakpoint if val== null");
    throw new exception();
}

si vous voulez des assertions dans votre code de production (i.e. release builds), vous pouvez utiliser Trace.Affirmer la place de Débogage.Affirmer.

cela ajoute bien sûr des frais généraux à votre exécutable de production.

aussi si votre application est en mode interface utilisateur, la boîte de dialogue Assertion s'affichera par défaut, ce qui peut être un peu déconcertant pour vos utilisateurs.

vous pouvez outrepasser ce comportement en supprimant la Defaultracelistener: cherchez Trace dans la documentation.Auditeurs en MSDN.

en résumé,

• Utiliser Debug.Affirmer généreusement pour aider à attraper les bogues dans les constructions de débogage.

• si vous utilisez Trace.Assert en mode interface utilisateur, vous souhaitez probablement supprimer le Defaultracelistener pour éviter de déconcerter les utilisateurs.

• Tester est quelque chose que votre application ne peut pas gérer, vous êtes probablement mieux de lancer une exception, pour s'assurer que l'exécution ne continue pas. Être conscient qu'un utilisateur peut choisir d'ignorer une affirmation.

Affirme sont utilisés pour attraper les programmeur (vos) d'erreur, pas d'erreur de l'utilisateur. Ils doivent être utilisés que lorsqu'il n'y a aucune chance qu'un utilisateur pourrait provoquer l'affirmer à feu. Si vous écrivez une API, par exemple, asserts ne devrait pas être utilisé pour vérifier qu'un argument n'est pas null dans une méthode qu'un utilisateur D'API pourrait appeler. Mais il pourrait être utilisé dans une méthode privée non exposée dans le cadre de votre API pour affirmer que votre code ne passe jamais un argument null quand il n'est pas censé le faire.

I d'habitude, je préfère les exceptions aux affirmations quand je ne suis pas sûr.

la plupart du temps jamais dans mon livre. Dans la grande majorité des cas, si vous voulez vérifier si tout est sain d'esprit, jetez-le si ce n'est pas le cas.

ce que je n'aime pas c'est le fait qu'il rend une construction de débogage fonctionnellement différente d'une construction de version. Si un argument de débogage échoue mais que la fonctionnalité fonctionne dans la version alors comment cela a-t-il un sens? C'est encore mieux quand l'asserteur a quitté l'entreprise depuis longtemps et que personne ne connaît cette partie du code. Alors tu dois tuer certains de tes de temps à explorer la question pour voir si c'est vraiment un problème ou pas. Si c'est un problème alors pourquoi la personne ne jette pas en premier lieu?

pour moi cela suggère en utilisant Debug.Affirme que vous reportez le problème à quelqu'un d'autre, traiter le problème vous-même. Si quelque chose est supposé être le cas et il n'est pas alors jeter.

je suppose qu'Il ya peut-être des scénarios critiques de performance où vous voulez optimiser loin vos assertions et ils sont utile, mais je suis pas encore à la rencontre d'un tel scénario.

En Abrégé

Asserts sont utilisés pour les gardes et pour le contrôle de la conception par des contraintes contractuelles, à savoir:

• Asserts doit être réservé aux constructions de débogage et de non-Production. Les assertions sont typiquement ignorées par le compilateur dans les compilations Release.
• Asserts peut vérifier les bogues / conditions inattendues qui sont dans le contrôle de votre système
• Asserts ne sont PAS un mécanisme pour la première ligne de la validation de la saisie de l'utilisateur ou des règles de gestion
• Asserts devrait pas être utilisé pour détecter les conditions environnementales (qui sont en dehors du contrôle du code) par exemple de la mémoire, du réseau l'échec, l'échec de la base de données, etc. Bien que rares, ces conditions sont à prévoir (et votre code app ne peut pas résoudre des problèmes comme une panne de matériel ou l'épuisement des ressources). Généralement, les exceptions seront jeté-votre application peut alors soit prendre des mesures correctives (par exemple, réessayer une opération de base de données ou de réseau, tenter de libérer de la mémoire cache), ou avorter gracieusement si l'exception ne peut pas être traitée.
• une Assertion ratée devrait être fatale à votre système - c. - à-d. contrairement à une exception, n'essayez pas et ne saisissez pas ou ne manipulez pas échoué Asserts - votre code fonctionne en territoire inattendu. Les Traces de pile et les décharges de crash peuvent être utilisées pour déterminer ce qui a mal tourné.

Affirmations ont un énorme avantage:

• pour aider à trouver la validation manquante des entrées utilisateur, ou des bogues en amont dans le code de niveau supérieur.
• , Affirme dans la base de code expriment clairement les hypothèses formulées dans le code pour le lecteur
• Assert sera vérifié à l'exécution dans les constructions Debug .
• une fois que le code a été testé de manière exhaustive, en reconstruisant le code comme suit: Release supprimera la charge de vérification des performances de l'hypothèse (mais avec l'avantage qu'une construction de débogage ultérieure retournera toujours les vérifications, si nécessaire).

... Plus De Détails

Debug.Assert exprime une condition qui a été assumée au sujet de l'état par le reste du bloc de code dans le contrôle du programme. Cela peut inclure l'état des paramètres fournis, l'état des membres d'un class instance, ou que le retour d'un appel de méthode est dans sa gamme contractée / conçue. En général, les assertions devraient écraser le thread / processus / programme avec toutes les informations nécessaires( trace de la pile, Crash Dump, etc), car ils indiquent la présence d'un bogue ou d'une condition non considérée qui n'a pas été conçu pour (i.e. ne pas essayer et attraper ou gérer les échecs d'assertion), avec une exception possible de quand une assertion elle-même pourrait causer plus de dommages que le bogue (par exemple les contrôleurs de la circulation aérienne Je ne voudrais pas d'un YSOD quand un avion va sous-marin, bien qu'il soit discutable si une construction de débogage doit être déployé à la production ...)

Quand devez-vous utiliser Asserts? - À tout point d'un système, D'une API de bibliothèque ou d'un service où les entrées d'une fonction ou d'un État d'une classe sont supposées valides (par exemple, lorsque la validation a déjà été faite sur l'entrée de l'utilisateur dans le niveau de présentation d'un système, les classes business et data tier supposent généralement que les vérifications nulles, les vérifications, les vérifications de longueur de chaîne, etc sur l'entrée ont déjà été faites). - Les vérifications courantes Assert comprennent les cas où une hypothèse invalide entraînerait une déviation nulle de l'objet, un diviseur zéro, un débordement arithmétique numérique ou de la date, et un débordement général hors bande / non conçu pour le comportement (par exemple, si un int de 32 bits était utilisé pour modéliser l'âge d'un être humain, il serait prudent de Assert que l'âge se situe en fait entre 0 et 125 ou si des valeurs de -100 et 10^10 n'étaient pas conçues pour).

Code Net Contrats

Dans la pile .Net, Code Contracts peut être utilisé en plus de, ou comme une alternative à en utilisant Debug.Assert . LES CONTRATS DE Code peuvent formaliser davantage la vérification d'état, et peuvent aider à détecter les violations des hypothèses au moment de la compilation (ou peu de temps après, si exécuté comme une vérification des antécédents dans un IDE).

Conception par Contrat (DBC) les contrôles disponibles comprennent:

• Contract.Requires - Conditions Préalables Contractuelles
• Contract.Ensures - Traitance PostConditions
• Invariant - exprime une hypothèse sur l'état d'un objet à tous les moments de sa vie.
• Contract.Assumes - pacifie le vérificateur statique quand un appel à des méthodes décorées non-Contrat est fait.

selon le IDesign Standard , vous devez

affirme chaque hypothèse. En moyenne, une ligne sur cinq est une affirmation.

using System.Diagnostics;

object GetObject()
{...}

object someObject = GetObject();
Debug.Assert(someObject != null);

comme clause de non-responsabilité, je dois mentionner que je n'ai pas trouvé pratique de mettre en œuvre cette IRL. Mais c'est leur norme.

utilisez assertions seulement dans les cas où vous voulez que le contrôle soit supprimé pour les constructions de version. Rappelez-vous, vos assertions ne se déclencheront pas si vous ne compilez pas en mode debug.

étant donné votre exemple "check-for-null", s'il s'agit d'une API interne, je pourrais utiliser une assertion. Si c'est dans une API publique, j'utiliserais certainement le check and throw explicite.

Toutes les affirme devrait être le code qui pourrait être optimisée pour:

Debug.Assert(true);

parce qu'il vérifie quelque chose que vous avez déjà supposé être vrai. Par exemple:

public static void ConsumeEnumeration<T>(this IEnumerable<T> source)
{
  if(source != null)
    using(var en = source.GetEnumerator())
      RunThroughEnumerator(en);
}
public static T GetFirstAndConsume<T>(this IEnumerable<T> source)
{
  if(source == null)
    throw new ArgumentNullException("source");
  using(var en = source.GetEnumerator())
  {
    if(!en.MoveNext())
      throw new InvalidOperationException("Empty sequence");
    T ret = en.Current;
    RunThroughEnumerator(en);
    return ret;
  }
}
private static void RunThroughEnumerator<T>(IEnumerator<T> en)
{
  Debug.Assert(en != null);
  while(en.MoveNext());
}

dans ce qui précède, il y a trois approches différentes aux paramètres nuls. La première l'accepte comme admissible (elle ne fait simplement rien). La seconde lance une exception pour le code d'appel à traiter (ou non, résultant en un message d'erreur). La troisième suppose qu'il ne peut pas arriver, et il affirme que c'est ainsi.

Dans le premier cas, il n'y a pas de problème.

dans le second cas, il y a un problème avec le code d'appel - il n'aurait pas dû appeler GetFirstAndConsume avec null, donc il obtient une exception de retour.

dans le troisième cas, il y a un problème avec ce code, parce qu'il aurait déjà dû être vérifié que en != null avant qu'il n'ait jamais été appelé, de sorte que ce n'est pas vrai est un bug. Ou en d'autres termes, il devrait être le code qui pourrait théoriquement être optimisé à Debug.Assert(true) , sicne en != null devrait toujours être true !

j'ai pensé que je voudrais ajouter quatre cas supplémentaires, où Debug.Affirmer peut être le bon choix.

1) une chose que je n'ai pas vu mentionné ici est le la couverture conceptuelle supplémentaire affirme peut fournir pendant les tests automatisés . Comme exemple simple:

Lorsqu'un interlocuteur de haut niveau est modifié par un auteur qui croit qu'il a élargi la portée du code pour traiter des scénarios supplémentaires, idéalement (!) ils rédigeront des tests unitaires pour couvrir cette nouvelle condition. Il se peut alors que le code entièrement intégré semble bien fonctionner.

Cependant, en fait, un défaut subtil a été introduit, mais pas détecté dans les résultats des tests. L'appel est devenu non déterministe dans ce cas, et seulement arrive pour fournir le résultat attendu. Ou peut-être a-t-il produit une erreur d'arrondissement qui est passée inaperçue. Ou a causé une erreur qui a été compensée également ailleurs. Ou accordé non seulement l'accès demandé, mais des privilèges supplémentaires qui ne devrait pas être accordée. Etc.

à ce point, le débogage.Les déclarations d'Assert() contenues dans l'appel combiné avec le nouveau cas (ou le nouveau cas edge) piloté par des tests unitaires peuvent fournir un précieux avis au cours du test que les hypothèses de l'auteur original ont été invalidées, et le code ne devrait pas être publié sans examen supplémentaire. Affirme avec des tests unitaires sont les partenaires parfaits.

2) de plus, certains tests sont simples à écrire, mais coûteux et inutiles étant donné les hypothèses initiales . Par exemple:

si un objet n'est accessible qu'à partir d'un certain point d'entrée sécurisé, est-ce qu'une requête supplémentaire devrait être faite à une base de données de droits réseau à partir de chaque méthode d'objet pour s'assurer que l'appelant a des permissions? Sûrement pas. Peut-être la solution idéale comprend la mise en cache ou une autre expansion de caractéristiques, mais la conception ne l'exige pas. débogage.Assert () montrera immédiatement quand l'objet a été attaché à un point d'entrée non sécurisé.

3) ensuite, dans certains cas, votre produit peut ne pas avoir d'interaction diagnostique utile pour tout ou partie de ses opérations lorsqu'il est déployé en mode de libération . Par exemple:

supposons qu'il s'agisse d'un dispositif intégré en temps réel. Lancer des exceptions et redémarrer quand il rencontres un paquet malformé est contre-productif. Au lieu de cela, l'appareil peut bénéficier d'un meilleur fonctionnement, même au point de rendre le bruit dans sa sortie. Il se peut également qu'il n'ait pas d'interface humaine, de dispositif de journalisation, ou même qu'il ne soit pas du tout accessible physiquement par l'homme lorsqu'il est déployé en mode de publication, et la meilleure façon de se rendre compte des erreurs est d'évaluer la même sortie. Dans ce cas, les affirmations libérales et les tests approfondis préalables à la mise en liberté sont plus valables que les exceptions.

4) enfin, certains tests sont inutiles uniquement parce que l'appelant est perçu comme extrêmement fiable . Dans la plupart des cas, plus le code est réutilisable, plus on s'efforce de le rendre fiable. Par conséquent, il est commun D'Exclure pour les paramètres inattendus des appelants, mais D'affirmer pour les résultats inattendus de callees. Par exemple:

si un noyau String.Find opération indique qu'il retournera un -1 lorsque la recherche les critères ne sont pas trouvés, vous pouvez être en mesure d'effectuer en toute sécurité une opération plutôt que trois. Toutefois , s'il retourne effectivement -2 , il se peut que vous n'ayez aucune ligne de conduite raisonnable. Il serait inutile de remplacer le calcul plus simple par un calcul qui teste séparément pour une valeur -1 , et déraisonnable dans la plupart des environnements de publication de polluer votre code avec des tests garantissant que les bibliothèques centrales fonctionnent comme prévu. Dans ce cas, les affirmations sont idéales.

Citation tirée de The pragmatic programmer: De Compagnon, de Maître

Laisser Les Assertions Sous Tension

il y a un malentendu commun au sujet des assertions, promulgué par les gens qui écrivent des compilateurs et environnements de langage. Il va quelque chose comme ceci:

Affirmations ajouter une surcharge de code. Parce qu'ils vérifient des choses cela ne devrait jamais se produire, ils seront déclenchés seulement par un bug dans le code. Une fois que le code a été testé et envoyé, il n'est plus nécessaire, et doit être éteint pour rendre le code plus rapide. Les affirmations sont une fonctionnalité de débogage.

il y a ici deux hypothèses manifestement erronées. Tout d'abord, ils supposent que testing trouve tous les bogues. En réalité, pour tout programme complexe vous est rare de tester, même un minuscule pourcentage des permutations votre code sera mis en place (voir tests impitoyables).

Deuxièmement, les optimistes oublient que votre programme fonctionne dans un monde dangereux. Pendant les tests, les rats ne vont probablement pas ronger à travers un un câble de communication, quelqu'un qui joue à un jeu n'épuisera pas sa mémoire, et les fichiers journaux ne rempliront pas le disque dur. Ces choses peuvent arriver quand votre programme fonctionne dans un environnement de production. Votre première ligne de la défense vérifie toute erreur possible, et votre seconde utilise affirmations pour essayer de détecter ceux que vous avez manqués.

désactiver les assertions lorsque vous livrez une émission à la production est comme traverser un haut fil sans filet parce que tu l'as fait across dans la pratique . Il y a une valeur dramatique, mais c'est dur d'avoir la vie assurance.

même si vous avez des problèmes de performance, éteignez seulement ceux des affirmations que vraiment vous frapper .

vous devez toujours utiliser la deuxième approche (lancer des exceptions).

aussi si vous êtes en production (et avez une release-build), il est préférable de jeter une exception (et laisser l'application planter dans le pire des cas) que de travailler avec des valeurs invalides et peut-être détruire les données de votre client (qui peuvent coûter des milliers de dollars).

vous devez utiliser Debug.Affirmer pour tester la logique des erreurs dans vos programmes. Le compilateur ne peut vous informer des erreurs de syntaxe. Donc, vous devriez définitivement l'utilisation d'Affirmer déclarations pour tester les erreurs logiques. Comme par exemple tester un programme qui vend des voitures que seuls les BMW qui sont bleus devraient obtenir un rabais de 15%. Le compilateur ne pourrait rien vous dire si votre programme est logiquement correct dans l'exécution de ceci mais un énoncé d'affirmation pourrait.

j'ai lu les réponses ici et j'ai pensé que je devrais ajouter une distinction importante. Il y a deux façons très différentes d'utiliser les assertions. L'un est comme un raccourci temporaire de développeur pour "cela ne devrait pas vraiment se produire donc si elle me le fait savoir pour que je puisse décider quoi faire", un peu comme un point de rupture conditionnel, pour les cas dans lesquels votre programme est en mesure de continuer. L'autre, est un moyen de mettre des hypothèses sur des états de programme valides dans votre code.

dans le premier cas, les assertions n'ont même pas besoin d'être dans le code final. Vous devez utiliser Debug.Assert pendant le développement et vous pouvez les supprimer si/quand plus nécessaire. Si vous voulez les laisser ou si vous oubliez de les enlever, aucun problème, car ils n'auront aucune conséquence dans les compilations de version.

mais dans le second cas, les assertions font partie du code. Ils affirment que vos suppositions sont vraies et les documentent. Dans ce cas, vous voulez vraiment les laisser dans le code. Si le programme est dans un état invalide, il ne devrait pas être autorisé à continuer. Si tu ne pouvais pas te permettre le succès, tu n'utiliserais pas C#. D'une part, il peut être utile de pouvoir fixer un débogueur si cela se produit. De l'autre, vous ne voulez pas que la trace de la pile apparaisse sur vos utilisateurs et peut-être plus important, vous ne voulez pas qu'ils puissent l'ignorer. D'ailleurs, si il est dans un service, il sera toujours ignoré. Par conséquent dans la production le comportement correct soyez pour jeter une Exception, et utilisez la manipulation d'exception normale de votre programme, qui pourrait montrer à l'utilisateur un message agréable et enregistrer les détails.

Trace.Assert a le moyen parfait pour atteindre cet objectif. Il ne sera pas supprimé en production, et peut être configuré avec différents auditeurs en utilisant app.config. Donc pour le développement le handler par défaut est très bien, et pour la production vous pouvez créer un TraceListener simple comme ci-dessous qui jette une exception et l'activer dans la production fichier de configuration.

using System.Diagnostics;

public class ExceptionTraceListener : DefaultTraceListener
{
    [DebuggerStepThrough]
    public override void Fail(string message, string detailMessage)
    {
        throw new AssertException(message);
    }
}

public class AssertException : Exception
{
    public AssertException(string message) : base(message) { }
}

et dans le fichier de configuration de production:

<system.diagnostics>
  <trace>
    <listeners>
      <remove name="Default"/>
      <add name="ExceptionListener" type="Namespace.ExceptionTraceListener,AssemblyName"/>
    </listeners>
  </trace>
 </system.diagnostics>

Je ne sais pas comment C'est en C# et .NET, mais en C n'assert() fonctionne que si compilé avec-DDEBUG - l'utilisateur final ne verra jamais un assert() s'il est compilé sans. C'est pour les développeurs seulement. Je l'utilise très souvent, il est parfois plus facile de suivre les bogues.

Je ne les utiliserais pas dans le code de production. Jeter les exceptions, la prise et le journal de bord.

aussi besoin d'être prudent dans asp.net, comme un assert peut apparaître sur la console et geler la(Les) requête (s).