Dois-je utiliser int ou Int32

les deux sont en effet synonymes; int sera un peu plus familier, Int32 rend le 32-Bit plus explicite à 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) de sorte que les futurs responsables sauront qu'il est sûr d'agrandir un int si approprié, mais devrait prendre soin de changer Int32 s de la même manière.

Le code résultant sera identique: la différence est purement une question de lisibilité ou d'apparence du code.

ils déclarent tous les deux des entiers 32 bits, et comme les autres posters l'indiquent, celui que vous utilisez est principalement une question de style syntaxique. Cependant, ils ne se comportent pas de la même façon. Par exemple, le compilateur C# ne permettra pas cela:

public enum MyEnum : Int32
{
    member1 = 0
}

mais il permettra cela:

public enum MyEnum : int
{
    member1 = 0
}

Aller à la figure.

j'utilise toujours les types de systèmes - par exemple, Int32 au lieu de int. J'ai adopté cette pratique après avoir lu Applied.NET Framework Programming - L'auteur Jeffrey Richter présente de bons arguments pour l'utilisation des noms complets. Voici les deux points qui m'ont retenu:

1. les noms de types peuvent varier entre les langues .NET. Par exemple, dans C#, long correspond au système.Int64 alors Qu'en C++ avec managed extensions, long correspond à Int32. Puisque les langages peuvent être mélangés et appariés en utilisant .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.

2. de nombreuses méthodes cadres ont des noms de type dans le cadre de leurs noms de méthode:

   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 qui vont à L'encontre de Int32:

• vous devez avoir une déclaration " utiliser le système;". l'utilisation de " int " ne nécessite aucune déclaration d'utilisation.
• il est possible de définir votre propre classe appelée Int32 (qui serait stupide et déroutante). int signifie toujours int.

comme déjà indiqué, int = Int32 . Pour être sûr, assurez-vous d'utiliser toujours int.MinValue / int.MaxValue lors de la mise en œuvre de tout ce qui se soucie des limites de type de données. Supposons que .NET décide que int serait maintenant Int64 , votre code serait moins dépendant des limites.

il n'y a pas de différence entre int et Int32 , mais comme int est un mot-clé de la langue que beaucoup de gens préfèrent stylistiquement (comme avec string vs String ).

la taille des octets pour les types n'est pas trop intéressante lorsque vous n'avez affaire 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 quand vous faites le pont entre une langue à une autre, C# to COM object, etc., ou vous faites un peu de bit-shifting ou de masquage et vous devez vous rappeler (et vos co-wokers code-review) de la taille des données.

en pratique, J'utilise Int32 juste pour Rappelez-moi quelle taille ils sont parce que j'écris du C++ géré (pour passer à C# par exemple) aussi bien que du C++non géré/natif.

tant que vous le savez probablement, en C# est 64 bits, mais en C++ natif, il se termine en 32 bits, ou char est unicode/16 bits tandis qu'en C++ il est 8 bits. Mais comment savons-nous cela? La réponse est, parce que nous avons regardé dans le manuel et il l'a dit.

avec le temps et les expériences, vous commencerez à être plus type-consciencieux quand vous écrivez des codes pour faire le pont entre C# et d'autres langues (certains lecteurs ici pensent "pourquoi le feriez-vous?"), mais IMHO je crois que c'est une meilleure pratique parce que je ne peux pas me rappeler ce que j'ai codé la semaine dernière (ou je n'ai pas à spécifier dans mon document API que "ce paramètre est 32 bits entier").

Dans F# (bien que je n'ai jamais utilisé), ils définissent int , int32 , et nativeint . La même question devrait se poser, " laquelle 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 juste pour lever les ambiguïtés.

je suppose que cela dépend juste des applications que vous codez, qui l'utilise, quelles pratiques de codage vous et votre équipe suivez, etc. pour justifier quand utiliser Int32.

d'après mon expérience, c'est une convention. Je ne suis pas au courant d'une raison technique d'utiliser int sur Int32, mais c'est:

1. plus rapide à taper.
2. plus familier au développeur C# typique.
3. une couleur différente dans la mise en évidence syntaxique par défaut de visual studio.

j'aime particulièrement ce dernier. :)

je sais que la meilleure pratique est d'utiliser int, et tous les codes MSDN utilisent int. Cependant, à ma connaissance, il n'y a pas de raison autre que la standardisation et la cohérence.

bien qu'ils soient (pour la plupart) identiques (voir ci-dessous pour la différence d'un [bug]), vous devez certainement vous en soucier et vous devez utiliser Int32.

• le nom d'un entier de 16 bits est Int16. Pour un entier 64 bits C'est Int64, et pour un entier 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érencement, mais la question de la taille d'une variable de type int est une question parfaitement valide et les questions, aussi insignifiantes soient-elles, sont distrayantes, conduisent à la confusion, à la perte de temps, entravent la discussion, etc. (le fait que cette question existe prouve le point).

• L'utilisation de Int32 encourage que le développeur est conscient de son choix de type. Quelle taille fait un int déjà? Oh oui, 32 ans. La probabilité que la taille du type sera réellement considérée est plus grande lorsque la taille est inclus dans le nom. L'utilisation de Int32 favorise également la connaissance des autres choix. Quand les gens ne sont pas forcés de reconnaître au moins il ya des alternatives, il devient beaucoup trop facile pour int de devenir "le type entier".

• la classe dans le cadre destiné à interagir avec des entiers 32 bits est appelé Int32. Une fois de plus, ce qui est: plus intuitif, moins confus, manque d'une traduction (inutile) (pas une traduction dans le système, mais dans l'esprit de le développeur), etc. int lMax = Int32.MaxValue ou Int32 lMax = Int32.MaxValue ?

• int n'est pas un mot-clé dans toutes les langues.net.

• bien qu'il y ait des arguments pour lesquels il est peu probable que cela change un jour, l'int n'est pas toujours un Int32.

les inconvénients sont deux caractères supplémentaires à taper et [bug].

ce ne sera pas compiler

public enum MyEnum : Int32
{
    AEnum = 0
}

mais ceci:

public enum MyEnum : int
{
    AEnum = 0
}

j'utilise toujours les types alias (int, string, etc.) lors de la définition d'une variable et utiliser le nom réel lors de l'accès à une méthode statique:

int x, y;
...
String.Format ("{0}x{1}", x, y);

il semble juste laid de voir quelque chose comme int.TryParse(). Il n'y a pas d'autre raison pour laquelle je fais ce d'autre que de style.

vous ne devriez pas vous en soucier. Vous devez utiliser int la plupart du temps. Cela aidera le portage de votre programme vers une architecture plus large à l'avenir (actuellement int est un alias de System.Int32 mais cela pourrait changer). Ce n'est que lorsque la largeur de bits de la variable est importante (par exemple: pour contrôler la mise en page en mémoire d'un struct ) que vous devez utiliser int32 et d'autres (avec le using System; " associé ").

int est le raccourci de la langue C# pour le système.Int32

alors que cela signifie que Microsoft pourrait changer cette cartographie, un post sur les discussions de FogCreek a déclaré [source]

"Sur le 64 bits -- Microsoft est en effet travailler sur une version 64 bits de l' .NET Framework, mais je suis sûr que l'int ne sera PAS une carte de 64 bits sur ce système.

motifs:

1. La norme C# ECMA spécifie que l'int est de 32 bits et la longueur de 64 bits.

2. Microsoft a introduit des propriétés et des méthodes supplémentaires dans la version 1.1 De Framework qui renvoient de longues valeurs au lieu de valeurs int, comme Array.GetLongLength en plus du tableau.GetLength.

donc je pense qu'il est sûr de dire que tous les types de C intégrés garderont leur cartographie actuelle."

int is the same as System.Int32 et une fois compilé, il deviendra la même chose dans CIL .

nous utilisons int par convention en C# car C# veut ressembler à C et C++ (et Java) et c'est ce que nous utilisons là...

BTW, je finis par utiliser le système.Int32 lors de la déclaration des importations de diverses fonctions API Windows. Je ne suis pas sûr qu'il s'agisse d'une convention définie ou pas, mais cela me rappelle que je vais à une DLL...

il était une fois, le type de données int était relié à la taille de registre de la machine visée par le compilateur. Ainsi, par exemple, un compilateur pour un système 16 bits serait d'utiliser un entier 16 bits.

Cependant, nous ne voyons heureusement pas beaucoup 16-bit plus, et quand 64-bit a commencé à obtenir les gens populaires étaient plus soucieux de le rendre compatible avec les logiciels plus anciens et 32-bit avait été autour si longtemps que pour la plupart des compilateurs un int est juste supposé être de 32 bits.

je recommande L'utilisation de Microsoft StyleCop .

C'est comme FxCop , mais pour le style et les questions connexes. 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 votre code plus agréable.

Vous pouvez l'inclure dans votre processus de génération de vérifier automatiquement violation.

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 classe lors de l'utilisation de méthodes statiques et tels:

int total = Int32.Parse ("1009");

int et Int32 est le même. int est un alias pour Int32 .

vous ne devriez pas vous en soucier. Si la taille est un problème, j'utiliserais byte, short, int, puis long. La seule raison pour laquelle vous utiliseriez un int plus grand que int32 est si vous avez besoin d'un nombre supérieur à 2147483647 ou inférieur à -2147483648.

, sauf que je m'en foutrais, il ya beaucoup d'autres éléments d'inquiétude.

int est un alias pour System.Int32 , tel que défini dans ce tableau: Tableau Des Types Intégrés (Référence C)

j'utilise int dans le cas où Microsoft change l'implémentation par défaut pour un entier à une nouvelle version changée (appelons-le Int32b).

Microsoft peut alors changer L'alias int en Int32b, et je n'ai pas à changer mon code pour profiter de leur nouvelle (et, espérons-le, améliorée) implémentation d'entier.

il en va de même pour n'importe lequel des mots-clés de type.

vous ne devriez pas vous soucier dans la plupart des langages de programmation, sauf si vous avez besoin d'écrire des fonctions mathématiques très spécifiques, ou le code optimisé pour une architecture spécifique... Il suffit de s'assurer que la taille du type est assez pour vous (utilisez quelque chose de plus grand qu'Un Int si vous savoir vous aurez besoin de plus de 32 bits par exemple)

ça n'a pas d'importance. int est le mot-clé de la langue et Int32 son type de système réel.

Voir aussi mes réponse à une question connexe.

utilisation de Int ou Int32 sont les mêmes Int est juste du sucre pour simplifier le code pour le lecteur.

utiliser la variante Nullable Int? ou Int32? lorsque vous travaillez avec des bases de données sur des champs contenant null. Cela vous sauvera de beaucoup de problèmes d'exécution.

certains compilateurs ont différentes tailles pour int sur différentes plates-formes (Pas C# spécifique)

certaines normes de codage (MISRA C) exigent que tous les types utilisés soient de taille spécifiée (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 8 octets, w pour 16 bits et l pour 32 bits = > Int32 lMyVariable)

vous devriez vous en soucier parce qu'il rend votre code plus portable et plus facile à entretenir.

Portable peut ne pas être applicable à C# si vous allez toujours utiliser C# et la spécification C# ne changera jamais à cet égard.

ihmo maintenable sera toujours applicable, parce que la personne qui maintient votre code peut ne pas être au courant de cette spécification particulière C#, et manquer un bug où l'int devient occasionnellement plus de 2147483647.

dans un simple pour-boucle qui compte par exemple les mois de l'année, vous n'aurez pas de soins, mais lorsque vous utilisez la variable dans un contexte où il pourrait owerflow, vous devez prendre soin.

vous devriez également vous soucier si vous allez faire des opérations bit-wise sur elle.

utilisant le type Int32 nécessite une référence à System , ou entièrement qualificatif ( System.Int32 ). J'ai tendance vers int , parce qu'il ne nécessite pas d'importation d'espace de noms, réduisant ainsi le risque de collision d'espace de noms dans certains cas. Lorsqu'il est compilé en IL, il n'y a pas de différence entre les deux.

selon la fenêtre immédiate dans 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

Aussi envisager de Int16. Si vous avez besoin de stocker un entier en mémoire dans votre application et que vous êtes préoccupé par la quantité de mémoire utilisée, alors vous pouvez aller avec Int16 car il utilise moins de mémoire et a une plus petite gamme min/max que Int32 (qui est ce que int est.)

il y a quelque temps, je travaillais sur un projet avec Microsoft lorsque nous avons eu la visite de quelqu'un de L'équipe de produits Microsoft .NET CLR. Cette personne a codé des exemples et lorsqu'il a défini ses variables, il a utilisé "Int32" vs. "int" et "String" vs. "string".

Je m'étais souvenu avoir vu ce style dans un autre exemple de code de Microsoft. Donc, j'ai fait quelques recherches et j'ai découvert que tout le monde dit qu'il n'y a pas de différence entre le "Int32" et le "int" sauf pour la coloration syntaxique. Dans en fait, j'ai trouvé beaucoup de matériel 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 permet pas de taper enum en utilisant le "Int32", mais il le fait quand vous utilisez "int". Ne me demande pas pourquoi parce que je ne sais pas encore.

exemple:

public  enum MyEnum : Int32
{
    AEnum = 0
}

ça marche.

public enum MyEnum : int
{
    AEnum = 0
}

tiré de: Int32 notation vs. int