Devrais-je utiliser UINT en C # pour des valeurs qui ne peuvent pas être négatives?
Je viens d'essayer de mettre en œuvre une classe où de nombreuses propriétés de longueur/comptage, etc. sont uint au lieu de int. Cependant, tout en le faisant, j'ai remarqué que c'était vraiment douloureux de le faire, comme si personne ne veut réellement faire cela.
Presque tout ce qui maintient un type intégré retourne un int, nécessitant donc des mises en plusieurs points. Je voulais construire un StringBuffer avec sa longueur de tampon défaut sur l'un des champs de cette classe. Nécessite un casting aussi.
Je me suis donc demandé si je devrais simplement revenir à int ici. Je n'utilise certainement pas toute la gamme. Je pensais juste depuis ce que je traite de là simplement ne peut pas être négatif (si c'était, ce serait une erreur) Soyez une bonne idée d'utiliser réellement uint.
PS: J'ai vu - cette question et cela explique au moins pourquoi le cadre lui-même utilise toujours int mais même dans son propre code, il est en fait fastidieux à coller à uint ce qui me fait pense que cela n'est apparemment pas vraiment recherché.
Bien que vous devriez strictement, vous devriez utiliser uint pour les variables qui détiennent un entier non négatif, vous avez rencontré une des raisons pour lesquelles il n'est pas toujours praticable.
Dans ce cas, je ne pense pas que la réduction de la lisibilité qui vienne avec qui devoir faire des mouffets en vaut la peine.
J'ajouterai également aux autres réponses que vous utilisez UINT en tant que type de champ public, de biens, de méthodes, de paramètres, etc., est une violation des règles de spécification de langue communes et d'être évitée lorsque cela est possible.
L'utilisation d'un Int est également utile pour détecter le débordement entier dans les opérations.
IMO, l'inconvénient de l'utilisation uint est qu'il masque les conditions d'erreur. Les équivalents du code suivant ne sont pas aussi gentils:
if (len < 0)
terminate_program("length attained impossible value.");
Bien sûr, vos programmes ne devraient pas y avoir mal calculé, mais je pense qu'ils devraient également être écrits pour détecter rapidement les erros numériques sans propagation. Dans le cas où une maxvalue de 2 ^ 31 est suffisante, je dis utiliser int avec une utilisation correcte de System.Diagnostics.Debug.Assert() et des contrôles d'erreur correspondants comme illustrés ci-dessus.
Si vous utilisez uint _ Utilisez-le avec checked pour empêcher le sousfluentation et obtenir les mêmes résultats. Cependant, j'ai trouvé que la vérification est un peu difficile à appliquer au code existant qui utilise des moulages à des fins.
Mon sentiment personnel est que vous devriez probablement rester à l'int. Il ne vaut pas la peine d'ajouter une distribution à peu près tous les accès à la propriété pour récupérer une plage numérique que .NET peu probable de vous laisser utiliser de toute façon.
Si vous souhaitez vérifier qu'une valeur est positive, une meilleure façon est probablement simplement en utilisant Assert (note que ceci est juste une technique de débogage - vous devez vous assurer que cela ne se produit jamais dans le code final).
using System.Diagnostics;
...
Debug.Assert (i > 0);
Ne nagez pas en amont si vous n'êtes pas obligé. Ne litige pas votre code avec des moulages rend votre code plus lisible. En outre, si vos valeurs possibles correspondent à l'INT, l'utilisation d'un int n'est pas un problème.
Si vous avez peur que vous puissiez déborder un INT, alors là par tous les moyens .. mais n'opiez pas prématurément.
Je dirais que la lisibilité améliorée de minimiser les couts l'emporte sur le risque légèrement élevé d'un bug avec l'utilisation d'int.