Dovrei usare int o Int32

In C #, inte Int32sono la stessa cosa, ma ho letto un numero di volte che intè preferito rispetto Int32a nessun motivo dato. C'è una ragione, e dovrei preoccuparmene?

ECMA-334 : 2006 Specifica del linguaggio C # (p18):

Ciascuno dei tipi predefiniti è una scorciatoia per un tipo fornito dal sistema. Ad esempio, la parola chiave si intriferisce alla struttura System.Int32. Per motivi di stile, l'uso della parola chiave è preferito rispetto all'uso del nome completo del tipo di sistema.

I due sono davvero sinonimi; intsarà un po 'più familiare, Int32renderà il 32-testimone più esplicito per coloro che leggono il tuo codice. Sarei propenso a usare intdove ho solo bisogno di 'un numero intero', Int32dove la dimensione è importante (codice crittografico, strutture) in modo che i futuri manutentori sapranno che è sicuro ingrandire un intse appropriato, ma dovrei fare attenzione a cambiare Int32s allo stesso modo.

Il codice risultante sarà identico: la differenza è puramente di leggibilità o aspetto del codice.

Entrambi dichiarano numeri interi a 32 bit e, come affermato da altri poster, quale si utilizza è principalmente una questione di stile sintattico. Tuttavia non si comportano sempre allo stesso modo. Ad esempio, il compilatore C # non lo consentirà:

public enum MyEnum : Int32
{
    member1 = 0
}

ma consentirà questo:

public enum MyEnum : int
{
    member1 = 0
}

Vai a capire.

Uso sempre i tipi di sistema, ad esempio Int32invece di int. Ho adottato questa pratica dopo aver letto la programmazione di Applied .NET Framework - l'autore Jeffrey Richter è un buon caso per usare i nomi di tipo completo. Ecco i due punti che mi hanno attaccato:

1. I nomi dei tipi possono variare tra le lingue .NET. Ad esempio, in C #, longmappa a System.Int64 mentre in C ++ con estensioni gestite, longmappa a Int32. Poiché le lingue possono essere combinate e abbinate durante l'utilizzo di .NET, si può essere certi che l'utilizzo del nome della classe esplicita sarà sempre più chiaro, indipendentemente dalla lingua preferita del lettore.

2. Molti metodi framework hanno nomi di tipi come parte dei nomi dei metodi:

   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 è una parola chiave C # ed è inequivocabile.

Il più delle volte non importa, ma due cose che vanno contro Int32:

• È necessario disporre di un "utilizzo del sistema;" dichiarazione. l'utilizzo di "int" non richiede alcuna istruzione using.
• È possibile definire la propria classe chiamata Int32 (che sarebbe sciocca e confusa). int significa sempre int.

Come già detto, int= Int32. Per sicurezza, utilizzare sempre int.MinValue/ int.MaxValuequando si implementa qualcosa che si preoccupa dei limiti del tipo di dati. Supponiamo che .NET abbia deciso che intora sarebbe Int64, il tuo codice sarebbe meno dipendente dai limiti.

La dimensione dei byte per i tipi non è troppo interessante quando si ha a che fare solo con una singola lingua (e per il codice che non è necessario ricordare a te stesso sugli overflow matematici). La parte che diventa interessante è quando fai un ponte tra una lingua e un'altra, da C # a oggetto COM, ecc., O stai facendo qualche spostamento di bit o mascheramento e devi ricordare a te stesso (e ai tuoi co-wokers di revisione del codice) delle dimensioni dei dati.

In pratica, di solito uso Int32 solo per ricordare a me stesso di che dimensione sono perché scrivo C ++ gestito (per passare ad esempio a C #) e C ++ non gestito / nativo.

Per quanto probabilmente sai, in C # è 64 bit, ma in C ++ nativo, finisce come 32 bit, oppure char è unicode / 16 bit mentre in C ++ è 8 bit. Ma come lo sappiamo? La risposta è, perché l'abbiamo cercata nel manuale e lo ha detto.

Con il tempo e le esperienze, inizierai a essere più coscienzioso quando scrivi codici per creare un ponte tra C # e altre lingue (alcuni lettori qui pensano "perché dovresti?"), Ma IMHO credo che sia una pratica migliore perché Non ricordo cosa ho codificato la scorsa settimana (o non devo specificare nel mio documento API che "questo parametro è un numero intero a 32 bit").

In F # (anche se non l'ho mai usato), definiscono int , int32 e nativeint . La stessa domanda dovrebbe sorgere, "quale devo usare?". Come altri hanno già detto, nella maggior parte dei casi non dovrebbe importare (dovrebbe essere trasparente). Ma io per uno sceglierei int32 e uint32 solo per rimuovere le ambiguità.

Immagino dipenderebbe solo da quali applicazioni stai codificando, da chi lo sta usando, da quali pratiche di codifica segui te e il tuo team, ecc. Per giustificare quando usare Int32.

Non c'è alcuna differenza tra inte Int32, ma poiché intè una parola chiave per linguaggio molte persone la preferiscono stilisticamente (proprio come con stringvs String).

Nella mia esperienza è stata una cosa convenzionale. Non sono a conoscenza di alcun motivo tecnico per utilizzare int su Int32, ma è:

1. Più veloce da digitare.
2. Più familiare allo sviluppatore C # tipico.
3. Un colore diverso nell'evidenziazione della sintassi di Visual Studio predefinita.

Sono particolarmente affezionato a quest'ultimo. :)

Uso sempre i tipi con alias (int, string, ecc.) Quando definisco una variabile e utilizzo il nome reale quando accedo a un metodo statico:

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

Sembra brutto vedere qualcosa di simile a int.TryParse (). Non c'è altro motivo per cui lo faccio oltre allo stile.

So che la migliore pratica è usare int, e tutto il codice MSDN usa int. Tuttavia, per quanto ne so, non c'è motivo al di là della standardizzazione e della coerenza.

Sebbene siano (per lo più) identici (vedi sotto per la differenza [bug]), sicuramente ti dovrebbe interessare e dovresti usare Int32.

• Il nome per un numero intero a 16 bit è Int16. Per un numero intero a 64 bit è Int64 e per un numero intero a 32 bit la scelta intuitiva è: int o Int32?

• La domanda sulla dimensione di una variabile di tipo Int16, Int32 o Int64 è autoreferenziale, ma la domanda sulla dimensione di una variabile di tipo int è una domanda perfettamente valida e domande, non importa quanto banali, siano fonte di distrazione, conducono confusione, perdita di tempo, ostacolo alla discussione, ecc. (il fatto che questa domanda esista dimostra il punto).

• L'utilizzo di Int32 promuove che lo sviluppatore è consapevole della propria scelta del tipo. Quanto è grande di nuovo un int? Oh sì, 32. La probabilità che la dimensione del tipo venga effettivamente considerata è maggiore quando la dimensione è inclusa nel nome. L'uso di Int32 promuove anche la conoscenza delle altre scelte. Quando le persone non sono costrette a riconoscere almeno ci sono alternative, diventa troppo facile per int per diventare "IL tipo intero".

• La classe all'interno del framework destinata a interagire con numeri interi a 32 bit è denominata Int32. Ancora una volta, che è: più intuitivo, meno confuso, manca di una traduzione (non necessaria) (non una traduzione nel sistema, ma nella mente dello sviluppatore), ecc. int lMax = Int32.MaxValueOppure Int32 lMax = Int32.MaxValue?

• int non è una parola chiave in tutte le lingue .NET.

• Sebbene ci siano argomenti per cui non è probabile che cambi mai, int potrebbe non essere sempre un Int32.

Gli svantaggi sono due caratteri extra da digitare e [bug].

Questo non verrà compilato

public enum MyEnum : Int32
{
    AEnum = 0
}

Ma questo:

public enum MyEnum : int
{
    AEnum = 0
}

Non dovrebbe interessarti. Dovresti usare la intmaggior parte del tempo. Aiuterà il porting del tuo programma su un'architettura più ampia in futuro (attualmente intè un alias System.Int32ma potrebbe cambiare). Solo quando l'ampiezza dei bit della variabile è importante (ad esempio: per controllare il layout in memoria di a struct) dovresti usare int32e altri (con il " using System;" associato ).

int è la scorciatoia del linguaggio C # per System.Int32

Mentre questo significa che Microsoft potrebbe cambiare questa mappatura, un post sulle discussioni di FogCreek ha dichiarato [fonte]

"Sul problema a 64 bit - Microsoft sta davvero lavorando su una versione a 64 bit di .NET Framework ma sono abbastanza sicuro che int non eseguirà il mapping a 64 bit su quel sistema.

Motivi:

1. Lo standard ECMA C # afferma specificamente che int è a 32 bit e long è a 64 bit.

2. Microsoft ha introdotto ulteriori proprietà e metodi in Framework versione 1.1 che restituiscono valori lunghi anziché valori int, come Array.GetLongLength oltre a Array.GetLength.

Quindi penso che sia sicuro dire che tutti i tipi C # integrati manterranno la loro mappatura attuale. "

int è uguale a System.Int32 e una volta compilato si trasformerà nella stessa cosa in CIL .

Usiamo int per convenzione in C # poiché C # vuole apparire come C e C ++ (e Java) ed è quello che usiamo lì ...

A proposito, finisco con System.Int32 quando dichiaro le importazioni di varie funzioni dell'API di Windows. Non sono sicuro se si tratta di una convenzione definita o meno, ma mi ricorda che sto andando a una DLL esterna ...

C'era una volta, il tipo di dati int era ancorato alla dimensione del registro della macchina targetizzata dal compilatore. Quindi, ad esempio, un compilatore per un sistema a 16 bit userebbe un numero intero a 16 bit.

Tuttavia, per fortuna non vediamo più molto a 16 bit, e quando 64 bit hanno iniziato a diventare popolari, le persone erano più preoccupate di renderlo compatibile con i software più vecchi e 32 bit erano in circolazione da così tanto tempo che per la maggior parte dei compilatori un int si presume che sia a 32 bit.

Consiglierei di usare Microsoft StyleCop .

È come FxCop , ma per problemi legati allo stile. La configurazione predefinita corrisponde alle guide di stile interne di Microsoft, ma può essere personalizzata per il tuo progetto.

Ci può volere un po 'per abituarsi, ma sicuramente rende il codice più bello.

Puoi includerlo nel processo di compilazione per verificare automaticamente la presenza di violazioni.

inted Int32è lo stesso. intè un alias per Int32.

Non dovrebbe interessarti. Se la dimensione è un problema, userei byte, short, int, quindi long. L'unico motivo per cui dovresti usare un int più grande di int32 è se hai bisogno di un numero maggiore di 2147483647 o inferiore a -2147483648.

A parte questo non mi importerebbe, ci sono molti altri elementi di cui preoccuparsi.

Non fa differenza nella pratica e col tempo adotterai la tua convenzione. Tendo a utilizzare la parola chiave quando si assegna un tipo e la versione della classe quando si utilizzano metodi statici e simili:

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

intè un alias per System.Int32, come definito in questa tabella: Tabella dei tipi predefiniti (Riferimenti per C #)

Uso int nel caso in cui Microsoft cambi l'implementazione predefinita per un numero intero in una nuova versione confusa (chiamiamola Int32b).

Microsoft può quindi modificare l'alias int in Int32b e non devo modificare alcuno del mio codice per sfruttare la loro nuova (e si spera migliorata) implementazione di numeri interi.

Lo stesso vale per qualsiasi parola chiave del tipo.

Non dovresti preoccuparti della maggior parte dei linguaggi di programmazione, a meno che non sia necessario scrivere funzioni matematiche molto specifiche o un codice ottimizzato per un'architettura specifica ... Assicurati solo che la dimensione del tipo sia sufficiente per te (usa qualcosa di più grande di un Int se sai che avrai bisogno di più di 32 bit per esempio)

Non importa int è la parola chiave language e Int32 il suo tipo di sistema attuale.

Vedi anche la mia risposta qui a una domanda correlata.

L'uso di Int o Int32 è lo stesso Int è solo zucchero per semplificare il codice per il lettore.

Utilizzare la variante Nullable Int? o Int32? quando si lavora con database su campi contenenti null. Ciò ti salverà da molti problemi di runtime.

Alcuni compilatori hanno dimensioni diverse per int su piattaforme diverse (non specifiche per C #)

Alcuni standard di codifica (MISRA C) richiedono che tutti i tipi utilizzati siano specificati in base alle dimensioni (ovvero Int32 e non int).

È anche utile specificare i prefissi per diverse variabili di tipo (ad es. B per byte a 8 bit, w per parola a 16 bit e l per parola lunga a 32 bit => Int32 lMyVariable)

Dovresti preoccuparti perché rende il tuo codice più portatile e più gestibile.

Portable potrebbe non essere applicabile a C # se si utilizzerà sempre C # e le specifiche C # non cambieranno mai in questo senso.

Ihmo gestibile sarà sempre applicabile, perché la persona che mantiene il codice potrebbe non essere a conoscenza di questa specifica specifica C # e perdere un bug se l'int diventa occasionalmente più di 2147483647.

In un semplice for-loop che conta ad esempio i mesi dell'anno, non ti importerai, ma quando usi la variabile in un contesto in cui potrebbe eventualmente provenire, ti dovrebbe interessare.

Dovresti anche preoccuparti se hai intenzione di fare operazioni bit-saggio su di esso.

L'uso del Int32tipo richiede un riferimento allo spazio dei nomi Systemo pienamente qualificato ( System.Int32). Tendo a intfarlo, perché non richiede l'importazione di uno spazio dei nomi, riducendo quindi la possibilità di collisione dello spazio dei nomi in alcuni casi. Se compilato in IL, non c'è differenza tra i due.

Secondo la finestra immediata di Visual Studio 2012 Int32 è int, Int64 è lungo. Ecco l'output:

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

Considera anche Int16. Se è necessario memorizzare un numero intero in memoria nella propria applicazione e si è preoccupati per la quantità di memoria utilizzata, è possibile utilizzare Int16 poiché utilizza meno memeory e ha un intervallo min / max minore di Int32 (che è ciò che int è .)

Qualche tempo fa stavo lavorando a un progetto con Microsoft quando abbiamo ricevuto una visita da qualcuno del team del prodotto CLR di Microsoft .NET. Questa persona ha codificato degli esempi e quando ha definito le sue variabili ha usato "Int32" vs. "int" e "String" vs. "string".

Mi ero ricordato di aver visto questo stile in un altro codice di esempio di Microsoft. Quindi, ho fatto qualche ricerca e ho scoperto che tutti dicono che non c'è differenza tra "Int32" e "int", tranne per la colorazione della sintassi. In effetti, ho trovato molto materiale che suggerisce di usare "Int32" per rendere il tuo codice più leggibile. Quindi, ho adottato lo stile.

L'altro giorno ho trovato la differenza! Il compilatore non ti consente di digitare enum usando "Int32", ma lo fa quando usi "int". Non chiedermi perché, perché non lo so ancora.

Esempio:

public  enum MyEnum : Int32
{
    AEnum = 0
}

Questo funziona

public enum MyEnum : int
{
    AEnum = 0
}

Tratto da: notazione Int32 vs. int