Devo usar int ou Int32

Em C #, inte Int32são a mesma coisa, mas eu li várias vezes que inté preferível, Int32sem nenhum motivo. Existe uma razão e devo me importar?

ECMA-334 : 2006 Especificação de idioma C # (p18):

Cada um dos tipos predefinidos é uma abreviação de um tipo fornecido pelo sistema. Por exemplo, a palavra-chave intrefere-se à estrutura System.Int32. Por uma questão de estilo, o uso da palavra-chave é preferível ao uso do nome completo do tipo de sistema.

Os dois são realmente sinônimos; intterá uma aparência um pouco mais familiar, Int32torna o número 32-bit mais explícito para quem lê seu código. Eu estaria inclinado a usar intonde eu só preciso de 'um número inteiro', Int32onde o tamanho é importante (código criptográfico, estruturas) para que futuros mantenedores saibam que é seguro aumentar um, intse apropriado, mas devem tomar cuidado ao mudar Int32s da mesma maneira.

O código resultante será idêntico: a diferença é puramente de legibilidade ou aparência do código.

Ambos declaram números inteiros de 32 bits e, como outros pôsteres declararam, qual deles você usa é principalmente uma questão de estilo sintático. No entanto, eles nem sempre se comportam da mesma maneira. Por exemplo, o compilador C # não permitirá isso:

public enum MyEnum : Int32
{
    member1 = 0
}

mas permitirá isso:

public enum MyEnum : int
{
    member1 = 0
}

Vai saber.

Eu sempre uso os tipos de sistema - por exemplo, em Int32vez de int. Adotei essa prática depois de ler a programação aplicada ao .NET Framework - o autor Jeffrey Richter é um bom argumento para usar os nomes completos dos tipos. Aqui estão os dois pontos que ficaram comigo:

1. Os nomes dos tipos podem variar entre os idiomas do .NET. Por exemplo, em C #, longmapeia para System.Int64 enquanto em C ++ com extensões gerenciadas, longmapeia para Int32. Como os idiomas podem ser misturados e combinados durante o uso do .NET, você pode ter certeza de que o uso do nome explícito da classe sempre será mais claro, independentemente do idioma preferido do leitor.

2. Muitos métodos de estrutura têm nomes de tipos como parte de seus nomes de métodos:

   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 é uma palavra-chave C # e não é ambígua.

Na maioria das vezes, não importa, mas duas coisas que vão contra o Int32:

• Você precisa ter um "using System;" declaração. usar "int" não requer nenhuma instrução de uso.
• É possível definir sua própria classe chamada Int32 (o que seria bobo e confuso). int sempre significa int.

Como já foi dito, int= Int32. Para estar seguro, sempre use int.MinValue/ int.MaxValueao implementar qualquer coisa que se importe com os limites do tipo de dados. Suponha que o .NET decidiu que intagora seria Int64, seu código seria menos dependente dos limites.

O tamanho de bytes para tipos não é muito interessante quando você precisa lidar apenas com um único idioma (e para o código que você não precisa se lembrar sobre estouros de matemática). A parte que se torna interessante é quando você faz a ponte entre um idioma para outro, C # para objeto COM, etc., ou está fazendo alguma alteração ou mascaramento de bits e precisa se lembrar (e seus colegas de revisão de código) do tamanho dos dados.

Na prática, normalmente uso o Int32 apenas para me lembrar qual é o tamanho deles, porque escrevo C ++ gerenciado (para fazer a ponte para C # por exemplo), bem como C ++ nativo / não gerenciado.

Desde que você provavelmente saiba, em C # é de 64 bits, mas em C ++ nativo, ele termina em 32 bits ou char é unicode / 16 bits, enquanto em C ++ é de 8 bits. Mas como sabemos disso? A resposta é, porque nós procuramos no manual e ele disse isso.

Com o tempo e as experiências, você começará a ter mais consciência do tipo quando escrever códigos para fazer a ponte entre C # e outras línguas (alguns leitores aqui estão pensando "por que você faria isso?"), Mas IMHO acredito que é uma prática melhor porque Não me lembro do que codifiquei na semana passada (ou não preciso especificar no meu documento da API que "esse parâmetro é um número inteiro de 32 bits").

No F # (embora eu nunca o tenha usado), eles definem int , int32 e nativeint . A mesma pergunta deve surgir: "qual deles eu uso?". Como outros já mencionaram, na maioria dos casos, isso não deve importar (deve ser transparente). Mas eu escolheria int32 e uint32 apenas para remover as ambiguidades.

Eu acho que dependeria apenas de quais aplicativos você está codificando, quem está usando, quais práticas de codificação você e sua equipe seguem etc. para justificar quando usar o Int32.

Não há diferença entre inte Int32, mas como inté uma palavra-chave no idioma, muitas pessoas preferem estilisticamente (assim como no stringvs String).

Na minha experiência, tem sido uma coisa de convenção. Não conheço nenhum motivo técnico para usar int sobre Int32, mas é:

1. Mais rápido para digitar.
2. Mais familiar para o desenvolvedor C # típico.
3. Uma cor diferente no realce da sintaxe padrão do visual studio.

Gosto especialmente desse último. :)

Eu sempre uso os tipos com alias (int, string, etc.) ao definir uma variável e uso o nome real ao acessar um método estático:

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

Parece feio ver algo como int.TryParse (). Não há outra razão para fazer isso além de estilo.

Eu sei que a melhor prática é usar int e todo código MSDN usa int. No entanto, não há uma razão além da padronização e consistência, até onde eu saiba.

Embora eles sejam (na maioria) idênticos (veja abaixo a única diferença [bug]), você definitivamente deve se importar e usar o Int32.

• O nome para um número inteiro de 16 bits é Int16. Para um número inteiro de 64 bits, é Int64, e para um número inteiro de 32 bits, a escolha intuitiva é: int ou Int32?

• A questão do tamanho de uma variável do tipo Int16, Int32 ou Int64 é auto-referenciada, mas a questão do tamanho de uma variável do tipo int é uma pergunta e perguntas perfeitamente válidas, por mais triviais que sejam, que causam distração. confusão, perda de tempo, dificultar a discussão etc. (o fato de esta questão existir provar o ponto).

• O uso do Int32 promove que o desenvolvedor esteja consciente de sua escolha de tipo. Qual é o tamanho de um int novamente? Ah, sim, 32. A probabilidade de o tamanho do tipo ser realmente considerado é maior quando o tamanho é incluído no nome. O uso do Int32 também promove o conhecimento das outras opções. Quando as pessoas não são forçadas a pelo menos reconhecer que existem alternativas, fica muito fácil para o int se tornar "O tipo inteiro".

• A classe na estrutura destinada a interagir com números inteiros de 32 bits é denominada Int32. Mais uma vez, o que é: mais intuitivo, menos confuso, carece de uma tradução (desnecessária) (não uma tradução no sistema, mas na mente do desenvolvedor), etc. int lMax = Int32.MaxValueou Int32 lMax = Int32.MaxValue?

• int não é uma palavra-chave em todas as linguagens .NET.

• Embora haja argumentos sobre por que é provável que isso nunca mude, int pode nem sempre ser um Int32.

As desvantagens são dois caracteres extras para digitar e [bug].

Isso não será compilado

public enum MyEnum : Int32
{
    AEnum = 0
}

Mas isso irá:

public enum MyEnum : int
{
    AEnum = 0
}

Você não deveria se importar. Você deve usar a intmaior parte do tempo. Isso ajudará a portar seu programa para uma arquitetura mais ampla no futuro (atualmente inté um alias para, System.Int32mas isso pode mudar). Somente quando a largura de bits da variável é importante (por exemplo: para controlar o layout na memória de a struct), você deve usar int32e outros (com o " using System;" associado ).

int é o atalho da linguagem C # para System.Int32

Embora isso signifique que a Microsoft possa alterar esse mapeamento, um post sobre as discussões do FogCreek afirmou [fonte]

"Na questão de 64 bits - a Microsoft está realmente trabalhando em uma versão de 64 bits do .NET Framework, mas tenho certeza que o int NÃO será mapeado para 64 bits nesse sistema.

Razões:

1. O padrão C # ECMA diz especificamente que int é 32 bits e longo é 64 bits.

2. A Microsoft introduziu propriedades e métodos adicionais no Framework versão 1.1 que retornam valores longos em vez de valores int, como Array.GetLongLength além de Array.GetLength.

Portanto, acho seguro dizer que todos os tipos de C # internos manterão seu mapeamento atual ".

int é o mesmo que System.Int32 e, quando compilado, se transformará na mesma coisa no CIL .

Usamos int por convenção em C #, pois o C # quer se parecer com C e C ++ (e Java) e é isso que usamos lá ...

BTW, acabo usando System.Int32 ao declarar importações de várias funções da API do Windows. Não tenho certeza se essa é uma convenção definida ou não, mas isso me lembra que estou indo para uma DLL externa ...

Era uma vez, o tipo de dados int foi vinculado ao tamanho do registro da máquina direcionada pelo compilador. Portanto, por exemplo, um compilador para um sistema de 16 bits usaria um número inteiro de 16 bits.

No entanto, felizmente, não vemos mais 16 bits e, quando os 64 bits começaram a popular, as pessoas estavam mais preocupadas em torná-lo compatível com software mais antigo e os 32 bits já existiam há tanto tempo que, para a maioria dos compiladores, um int é assumido apenas como 32 bits.

Eu recomendo usar o Microsoft StyleCop .

É como FxCop , mas para problemas relacionados ao estilo. A configuração padrão corresponde aos guias de estilo internos da Microsoft, mas pode ser personalizada para o seu projeto.

Pode demorar um pouco para se acostumar, mas definitivamente torna seu código mais agradável.

Você pode incluí-lo em seu processo de compilação para verificar automaticamente se há violações.

inte Int32é o mesmo. inté um alias para Int32.

Você não deveria se importar. Se o tamanho é uma preocupação, eu usaria byte, short, int e long. O único motivo pelo qual você usaria um int maior que int32 é se precisar de um número maior que 2147483647 ou menor que -2147483648.

Fora isso, eu não me importaria, há muitos outros itens com os quais me preocupar.

Não faz diferença na prática e com o tempo você adotará sua própria convenção. Eu costumo usar a palavra-chave ao atribuir um tipo e a versão da classe ao usar métodos estáticos e:

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

inté um alias para System.Int32, conforme definido nesta tabela: Tabela de tipos internos (referência de C #)

Uso int no caso em que a Microsoft altera a implementação padrão de um número inteiro para alguma nova versão distorcida (vamos chamá-lo de Int32b).

A Microsoft pode alterar o alias int para Int32b e não preciso alterar nenhum código para tirar proveito de sua nova (e esperamos melhorar) implementação de número inteiro.

O mesmo vale para qualquer palavra-chave do tipo.

Você não deve se importar com a maioria das linguagens de programação, a menos que precise escrever funções matemáticas muito específicas ou código otimizado para uma arquitetura específica ... Apenas verifique se o tamanho do tipo é suficiente para você (use algo maior que um Int se desejar saiba que você precisará de mais de 32 bits, por exemplo)

Não importa. int é a palavra-chave language e Int32 é seu tipo de sistema real.

Veja também minha resposta aqui para uma pergunta relacionada.

O uso de Int ou Int32 é o mesmo que Int é apenas açúcar para simplificar o código para o leitor.

Use a variante anulável Int? ou Int32? quando você trabalha com bancos de dados em campos que contêm nulo. Isso evitará muitos problemas de tempo de execução.

Alguns compiladores têm tamanhos diferentes para int em plataformas diferentes (não específicas do C #)

Alguns padrões de codificação (MISRA C) exigem que todos os tipos usados ​​tenham o tamanho especificado (por exemplo, Int32 e não int).

Também é bom especificar prefixos para diferentes variáveis ​​de tipo (por exemplo, b para bytes de 8 bits, w para palavras de 16 bits e l para palavras longas de 32 bits => Int32 lMyVariable)

Você deve se preocupar, pois torna seu código mais portátil e mais sustentável.

Portable pode não ser aplicável ao C # se você sempre usar o C # e a especificação do C # nunca será alterada nesse sentido.

O ihmo de manutenção sempre será aplicável, porque a pessoa que mantém seu código pode não estar ciente dessa especificação específica do C # e perder um bug, caso o int ocasionalmente se torne mais que 2147483647.

Em um loop for simples que conta, por exemplo, os meses do ano, você não se importa, mas quando você usa a variável em um contexto em que ela possa possivelmente fluir, você deve se importar.

Você também deve se preocupar se fará operações pouco a pouco sobre ele.

O uso do Int32tipo requer uma referência de espaço para nome Systemou é totalmente qualificado ( System.Int32). Eu sou favorável int, porque não requer uma importação de namespace, reduzindo, portanto, a chance de colisão de namespace em alguns casos. Quando compilado para IL, não há diferença entre os dois.

De acordo com a janela imediata no Visual Studio 2012 Int32 é int, Int64 é longo. Aqui está a saída:

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

Considere também Int16. Se você precisar armazenar um número inteiro na memória do seu aplicativo e estiver preocupado com a quantidade de memória usada, poderá usar o Int16, pois ele usa menos memória e possui um intervalo mínimo / máximo menor que o Int32 (que é o que int é .)

Há algum tempo, eu estava trabalhando em um projeto com a Microsoft quando recebemos a visita de alguém da equipe de produtos Microsoft .NET CLR. Essa pessoa codificou exemplos e, quando definiu suas variáveis, usou "Int32" vs. "int" e "String" vs. "string".

Lembrei-me de ver esse estilo em outro código de exemplo da Microsoft. Então, eu fiz algumas pesquisas e descobri que todo mundo diz que não há diferença entre o "Int32" e o "int", exceto pela coloração da sintaxe. De fato, encontrei muito material sugerindo que você use “Int32” para tornar seu código mais legível. Então, eu adotei o estilo.

Outro dia, encontrei uma diferença! O compilador não permite que você digite enum usando o "Int32", mas o faz quando você usa "int". Não me pergunte por que, porque ainda não sei.

Exemplo:

public  enum MyEnum : Int32
{
    AEnum = 0
}

Isso funciona.

public enum MyEnum : int
{
    AEnum = 0
}

Retirado de: Int32 notation vs. int