Devrais-je utiliser int ou Int32
En C #, int et Int32 sont identiques, mais j'ai lu à plusieurs reprises que int est préférable à Int32 sans raison. Y a-t-il une raison et devrais-je m'en soucier?
ECMA-334 : 2006 Spécification du langage C # (p18):
Chacun des types prédéfinis est un raccourci pour un type fourni par le système. Par exemple, le mot clé
intfait référence à la structureSystem.Int32. En termes de style, l'utilisation du mot clé est préférée à l'utilisation du nom de type de système complet.
Les deux sont en effet synonymes; int sera un peu plus familier, Int32 rend le bit 32 bits plus explicite pour ceux qui lisent votre code. Je serais enclin à utiliser int où j'ai juste besoin d'un 'entier', Int32 où la taille est importante (code cryptographique, structures) pour que les futurs responsables sachent qu'il est prudent d'agrandir un int Le cas échéant, mais veillez à changer Int32s de la même manière.
Le code résultant sera identique: la différence est purement de lisibilité ou d’apparence de code.
Ils déclarent tous les deux des entiers 32 bits et, comme d’autres afficheurs l’ont indiqué, celle que vous utilisez est essentiellement une question de style syntaxique. Cependant, ils ne se comportent pas toujours de la même manière. Par exemple, le compilateur C # ne permettra pas ceci:
public enum MyEnum : Int32
{
member1 = 0
}
mais cela permettra ceci:
public enum MyEnum : int
{
member1 = 0
}
Allez comprendre.
J'utilise toujours les types de système - par exemple, Int32 au lieu de int. J'ai adopté cette pratique après avoir lu Programmation .NET Framework appliquée - l'auteur Jeffrey Richter explique bien l'utilisation des noms de type complets. . Voici les deux points qui me sont restés:
Les noms de type peuvent varier entre les langages .NET. Par exemple, en C #,
longest mappé sur System.Int64 alors que dans C++ avec des extensions gérées,longest mappé sur Int32. Étant donné que les langues peuvent être combinées lors de l'utilisation de .NET, vous pouvez être sûr que l'utilisation du nom de classe explicite sera toujours plus claire, quelle que soit la langue préférée du lecteur.De nombreuses méthodes d'infrastructure ont des noms de types dans leurs noms de méthodes:
BinaryReader br = new BinaryReader( /* ... */ );float val = br.ReadSingle(); // OK, but it looks a little odd...Single val = br.ReadSingle(); // OK, and is easier to read
int est un mot clé C # et est sans ambiguïté.
La plupart du temps, cela n'a pas d'importance, mais deux choses vont à l'encontre de Int32:
- Vous devez avoir un "système utilisant"; déclaration. utiliser "int" ne nécessite aucune instruction using.
- Il est possible de définir votre propre classe appelée Int32 (ce qui serait stupide et déroutant). int signifie toujours int.
Comme déjà indiqué, int = Int32. Pour des raisons de sécurité, veillez à toujours utiliser int.MinValue/int.MaxValue lors de la mise en œuvre de tout ce qui concerne les limites du type de données. Supposons que .NET décide que int serait maintenant Int64, votre code serait moins dépendant des limites.
La taille en octets pour les types n'est pas très intéressante lorsque vous ne devez gérer qu'une seule langue (et pour le code que vous n'avez pas à vous rappeler des débordements de mathématiques). La partie qui devient intéressante est lorsque vous passez d'un langage à un autre, d'un objet C # à un objet COM, etc., ou que vous effectuez un décalage ou un masquage et que vous devez vous rappeler (ainsi que vos co-experts de la révision de code). de la taille des données.
En pratique, j'utilise généralement Int32 uniquement pour me rappeler leur taille, car j'écris en C++ géré (pour établir une liaison avec C # par exemple) ainsi qu'en C++ non géré/natif.
Comme vous le savez probablement, C # est en 64 bits, mais en C++ natif, il se termine en 32 bits ou char est en unicode/16 bits, alors que C + en est de 8 bits. Mais comment savons-nous cela? La réponse est, parce que nous avons examiné cela dans le manuel et il l’a dit.
Avec le temps et l'expérience, vous commencerez à être plus consciencieux en écrivant des codes pour faire le pont entre le C # et d'autres langages (certains lecteurs ici pensent "pourquoi le voudriez-vous?"), Mais à mon humble avis, il s'agit d'une meilleure pratique car Je ne me souviens pas de ce que j'ai codé la semaine dernière (ou je n'ai pas à spécifier dans mon document d'API que "ce paramètre est un entier de 32 bits").
Dans F # (bien que je ne l'ait jamais utilisé), ils définissent int , int32 et nativeint . La même question devrait se poser, "lequel dois-je utiliser?". Comme d'autres l'ont mentionné, dans la plupart des cas, cela ne devrait pas avoir d'importance (devrait être transparent). Mais pour ma part, je choisirais int32 et uint32 simplement pour lever les ambiguïtés.
J'imagine que cela dépendrait simplement des applications que vous codez, de qui les utilise, des pratiques de codage suivies par votre équipe, etc., pour justifier le moment d'utilisation d'Int32.
Il n'y a pas de différence entre int et Int32, mais comme int est un mot clé de langue, de nombreuses personnes le préfèrent stylistiquement (comme avec string vs String).
D'après mon expérience, cela a été une affaire de convention. Je ne connais aucune raison technique d'utiliser int sur Int32, mais c'est:
- Plus rapide à taper.
- Plus familier au développeur C # typique.
- Une couleur différente dans la coloration syntaxique par défaut de Visual Studio.
J'aime particulièrement ce dernier. :)
J'utilise toujours les types avec alias (int, string, etc.) lors de la définition d'une variable et utilise le nom réel pour accéder à une méthode statique:
int x, y;
...
String.Format ("{0}x{1}", x, y);
Il semble simplement moche de voir quelque chose comme int.TryParse (). Il n'y a aucune autre raison pour laquelle je fais cela autre que le style.
Bien qu'ils soient (pour la plupart) identiques (voir ci-dessous pour la différence [bug]), vous devez absolument vous en soucier et utiliser Int32.
Le nom d'un entier de 16 bits est Int16. Pour un entier de 64 bits, il s'agit de Int64, et pour un entier de 32 bits, le choix intuitif est: int ou Int32?
La question de la taille d'une variable de type Int16, Int32 ou Int64 est auto-référencée, mais la question de la taille d'une variable de type int est une question parfaitement valable et les questions, aussi triviales soient-elles, sont source de distraction à la confusion, perdre du temps, entraver la discussion, etc. (le fait que cette question existe prouve le point).
L'utilisation de Int32 encourage le développeur à être conscient de son choix de type. Quelle est la taille d'un int à nouveau? Oh oui, 32. La probabilité que la taille du type soit réellement prise en compte est plus grande lorsque la taille est incluse dans le nom. L'utilisation de Int32 favorise également la connaissance des autres choix. Quand les gens ne sont pas obligés de reconnaître au moins qu'il existe des alternatives, il devient beaucoup trop facile pour int de devenir "LE type entier".
La classe du cadre destinée à interagir avec les entiers 32 bits est appelée Int32. Encore une fois, ce qui est: plus intuitif, moins déroutant, il manque une traduction (inutile) (pas une traduction dans le système, mais dans l’esprit du développeur), etc.
int lMax = Int32.MaxValueouInt32 lMax = Int32.MaxValue?int n'est pas un mot clé dans tous les langages .NET.
Bien qu'il y ait des arguments pour qu'il ne soit pas susceptible de changer, int peut ne pas toujours être un Int32.
Les inconvénients sont deux caractères supplémentaires à taper et [bug].
Cela ne compilera pas
public enum MyEnum : Int32
{
AEnum = 0
}
Mais cela va:
public enum MyEnum : int
{
AEnum = 0
}
Je sais que la meilleure pratique consiste à utiliser int, et tout le code MSDN utilise int. Cependant, pour autant que je sache, rien ne justifie la normalisation et la cohérence.
Vous ne devriez pas vous en soucier. Vous devriez utiliser int la plupart du temps. Cela aidera le portage de votre programme vers une architecture plus large dans le futur (actuellement int est un alias de System.Int32 mais cela pourrait changer). Utilisez uniquement int32 et autres (avec le "using System;") associé lorsque la largeur de bit de la variable est importante (par exemple: pour contrôler la mise en mémoire en mémoire d'un struct).
Je recommanderais d'utiliser Microsoft StyleCop .
C'est comme FxCop , mais pour les problèmes liés au style. La configuration par défaut correspond aux guides de style internes de Microsoft, mais elle peut être personnalisée pour votre projet.
Il peut prendre un peu de temps pour s'y habituer, mais cela rend définitivement votre code plus agréable.
Vous pouvez l'inclure dans votre processus de construction pour vérifier automatiquement les violations.
int est identique à System.Int32 et, une fois compilé, il deviendra la même chose dans CIL .
Nous utilisons int par convention en C # puisque C # veut ressembler à C et C++ (et Java) et c'est ce que nous utilisons là ...
En passant, je finis par utiliser System.Int32 lors de la déclaration d’importations de diverses fonctions de l’API Windows. Je ne sais pas s'il s'agit d'une convention définie ou non, mais cela me rappelle que je vais utiliser une DLL externe ...
Il était une fois, le type de données int était indexé sur la taille de registre de la machine ciblée par le compilateur. Ainsi, par exemple, un compilateur pour un système 16 bits utiliserait un entier 16 bits.
Cependant, heureusement, nous ne voyons plus grand-chose en 16 bits, et lorsque la version 64 bits a commencé à séduire les gens, elle était plus soucieuse de le rendre compatible avec les logiciels plus anciens. int est simplement supposé être de 32 bits.
int est le raccourci du langage C # pour System.Int32
Bien que cela signifie que Microsoft pourrait modifier cette correspondance, un article sur les discussions de FogCreek déclarait: [source]
"Sur le problème 64 bits - Microsoft travaille effectivement sur une version 64 bits du .NET Framework, mais je suis sûr que int ne mappera PAS en 64 bits sur ce système.
Motifs:
1. La norme C # ECMA indique spécifiquement que int est 32 bits et long est 64 bits.
2. Dans la version 1.1 de Framework, Microsoft a introduit des propriétés et méthodes supplémentaires qui renvoient des valeurs longues au lieu de valeurs telles que Array.GetLongLength en plus de Array.GetLength.
Je pense donc qu'il est prudent de dire que tous les types C # intégrés conservent leur mappage actuel. "
Vous ne devriez pas vous en soucier. Si la taille est une préoccupation, j'utiliserais byte, short, int, puis long. Si vous avez besoin d'un nombre supérieur à 2147483647 ou inférieur à -2147483648, la seule raison pour laquelle vous souhaitez utiliser un int supérieur à int32 est.
Autre que cela ne me dérange pas, il y a beaucoup d'autres sujets de préoccupation.
int et Int32 est identique. int est un alias pour Int32.
Cela ne fait aucune différence dans la pratique et avec le temps, vous adopterez votre propre convention. J'ai tendance à utiliser le mot clé lors de l'attribution d'un type, et la version de la classe lors de l'utilisation de méthodes statiques et autres:
int total = Int32.Parse ("1009");
int est un alias pour System.Int32, comme défini dans ce tableau: Tableau des types intégrés (référence C #)
Utilisation de Int ou Int32 sont les mêmes Int est juste du sucre pour simplifier le code pour le lecteur.
Utilisez la variante Nullable Int? ou Int32? lorsque vous travaillez avec des bases de données sur des champs contenant null. Cela vous évitera beaucoup de problèmes d'exécution.
Il y a quelque temps, je travaillais sur un projet avec Microsoft lorsque nous avons eu la visite d'un membre de l'équipe produit Microsoft .NET CLR. Cette personne a codé des exemples et lorsqu'il a défini ses variables, il a utilisé "Int32" contre "int" et "Chaîne" contre "chaîne".
Je me souvenais avoir vu ce style dans un autre exemple de code fourni par Microsoft. J'ai donc fait des recherches et constaté que tout le monde disait qu'il n'y avait pas de différence entre “Int32” et “int”, à l'exception de la coloration syntaxique. En fait, j'ai trouvé beaucoup d'informations suggérant que vous utilisiez "Int32" pour rendre votre code plus lisible. Alors j'ai adopté le style.
L'autre jour, j'ai trouvé une différence! Le compilateur ne vous autorise pas à taper enum en utilisant "Int32", mais il le fait lorsque vous utilisez "int". Ne me demandez pas pourquoi parce que je ne sais pas encore.
Exemple:
public enum MyEnum : Int32
{
AEnum = 0
}
Cela marche.
public enum MyEnum : int
{
AEnum = 0
}
Tiré de: notation Int32 vs int
Certains compilateurs ont des tailles différentes pour int sur différentes plates-formes (non spécifiques à C #)
Certaines normes de codage (MISRA C) exigent que tous les types utilisés soient spécifiés en termes de taille (c'est-à-dire Int32 et non int).
Il est également bon de spécifier des préfixes pour différentes variables de type (par exemple, b pour un octet de 8 bits, w pour un mot de 16 bits et l pour un mot de 32 bits de long => Int32 lMyVariable).
Vous devriez faire attention car cela rend votre code plus portable et plus facile à gérer.
Portable peut ne pas s'appliquer à C # si vous utilisez toujours C # et que la spécification C # ne changera jamais à cet égard.
Ihmo maintenable sera toujours applicable, car la personne chargée de la maintenance de votre code peut ne pas être au courant de cette spécification C # particulière et manquer un bogue si la taille de l'interface devient parfois supérieure à 2147483647.
Dans une boucle for simple qui compte, par exemple, les mois de l'année, vous ne vous en souciez pas, mais lorsque vous utilisez la variable dans un contexte où elle pourrait éventuellement être en flux, vous devriez vous en soucier.
Vous devriez également vous préoccuper de savoir si vous allez effectuer des opérations binaires.
Ne vous souciez pas de la plupart des langages de programmation, sauf si vous devez écrire des fonctions mathématiques très spécifiques, ou du code optimisé pour une architecture spécifique ... Assurez-vous simplement que la taille du type est suffisante pour vous (utilisez quelque chose de plus grand qu'un Int savoir vous aurez besoin de plus de 32 bits par exemple)
L'utilisation du type Int32 nécessite une référence d'espace de nom à System, ou une qualification complète (System.Int32). Je suis plutôt orienté vers int, car il ne nécessite aucune importation d’espace de nom, ce qui réduit le risque de collision d’espace de nom dans certains cas. Une fois compilé en IL, il n'y a pas de différence entre les deux.
Ça n'a pas d'importance. int est le mot clé language et Int32 son type de système actuel.
Voir aussi mon répondre ici à une question connexe.
Selon la fenêtre Immediate de Visual Studio 2012, Int32 est Int, Int64 est long. Voici la sortie:
sizeof(int)
4
sizeof(Int32)
4
sizeof(Int64)
8
Int32
int
base {System.ValueType}: System.ValueType
MaxValue: 2147483647
MinValue: -2147483648
Int64
long
base {System.ValueType}: System.ValueType
MaxValue: 9223372036854775807
MinValue: -9223372036854775808
int
int
base {System.ValueType}: System.ValueType
MaxValue: 2147483647
MinValue: -2147483648
Considérez également Int16. Si vous avez besoin de stocker un nombre entier en mémoire dans votre application et que vous vous inquiétez de la quantité de mémoire utilisée, vous pouvez utiliser Int16 car il utilise moins de mémoire et a une plage min/max plus petite que Int32 (qui est ce que int est .)