Em C #, int
e Int32
são a mesma coisa, mas eu li várias vezes que int
é preferível, Int32
sem nenhum motivo. Existe uma razão e devo me importar?
c#
variable-types
Graham
fonte
fonte
System.Int32
)When something can be read without effort, great effort has gone into its writing.
Easy writing is hard reading
Respostas:
ECMA-334 : 2006 Especificação de idioma C # (p18):
fonte
Os dois são realmente sinônimos;
int
terá uma aparência um pouco mais familiar,Int32
torna o número 32-bit mais explícito para quem lê seu código. Eu estaria inclinado a usarint
onde eu só preciso de 'um número inteiro',Int32
onde o tamanho é importante (código criptográfico, estruturas) para que futuros mantenedores saibam que é seguro aumentar um,int
se apropriado, mas devem tomar cuidado ao mudarInt32
s da mesma maneira.O código resultante será idêntico: a diferença é puramente de legibilidade ou aparência do código.
fonte
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:
mas permitirá isso:
Vai saber.
fonte
enum
para usarint
não é umderive
, mas especificar umunderlying type
; consulte msdn.microsoft.com/pt-br/library/sbbt4032.aspx#code-snippet-2Eu sempre uso os tipos de sistema - por exemplo, em
Int32
vez deint
. 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:Os nomes dos tipos podem variar entre os idiomas do .NET. Por exemplo, em C #,
long
mapeia para System.Int64 enquanto em C ++ com extensões gerenciadas,long
mapeia 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.Muitos métodos de estrutura têm nomes de tipos como parte de seus nomes de métodos:
fonte
List<Tuple<Int32, Boolean>> test = new
, o Visual Studio agora será inseridoList<Tuple<int, bool>>()
. Você conhece uma maneira de alterar esses preenchimentos automáticos?var
o máximo possível para reduzir a redação do código. Nos locais ocasionais em que o preenchimento automático entra e cospe no meu piso, eu ajusto manualmente - é literalmente um ou dois segundos do meu tempo.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:
fonte
Como já foi dito,
int
=Int32
. Para estar seguro, sempre useint.MinValue
/int.MaxValue
ao implementar qualquer coisa que se importe com os limites do tipo de dados. Suponha que o .NET decidiu queint
agora seriaInt64
, seu código seria menos dependente dos limites.fonte
int
64 bits, seria uma mudança tão surpreendente que eu não acredito que seja possível (ou certamente sensato) codificar defensivamente contra tais eventualidades.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.
fonte
Não há diferença entre
int
eInt32
, mas comoint
é uma palavra-chave no idioma, muitas pessoas preferem estilisticamente (assim como nostring
vsString
).fonte
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 é:
Gosto especialmente desse último. :)
fonte
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:
Parece feio ver algo como int.TryParse (). Não há outra razão para fazer isso além de estilo.
fonte
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.
fonte
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.MaxValue
ouInt32 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
Mas isso irá:
fonte
Você não deveria se importar. Você deve usar a
int
maior parte do tempo. Isso ajudará a portar seu programa para uma arquitetura mais ampla no futuro (atualmenteint
é um alias para,System.Int32
mas isso pode mudar). Somente quando a largura de bits da variável é importante (por exemplo: para controlar o layout na memória de astruct
), você deve usarint32
e outros (com o "using System;
" associado ).fonte
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 ".
fonte
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 ...
fonte
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.
fonte
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.
fonte
int
eInt32
é o mesmo.int
é um alias paraInt32
.fonte
using int = System.Int32;
diretiva para todos os seus arquivos de código-fonte.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.
fonte
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:
fonte
int
é um alias paraSystem.Int32
, conforme definido nesta tabela: Tabela de tipos internos (referência de C #)fonte
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.
fonte
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)
fonte
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.
fonte
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.
fonte
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.
fonte
It is also good to specify prefixes for different type variables
Atualmente, a notação húngara é amplamente obsoleta e a maioria dos estilos de codificação desencoraja o uso dela. Convenções internas de empresas de software também muitas vezes não permita que a notaçãoO uso do
Int32
tipo requer uma referência de espaço para nomeSystem
ou é totalmente qualificado (System.Int32
). Eu sou favorávelint
, 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.fonte
De acordo com a janela imediata no Visual Studio 2012 Int32 é int, Int64 é longo. Aqui está a saída:
fonte
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 é .)
fonte
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:
Isso funciona.
Retirado de: Int32 notation vs. int
fonte