Come faccio a convertire un decimale in un int in C #?

Come faccio a convertire un decimale in un int?

Utilizzare Convert.ToInt32da mscorlibcome in

decimal value = 3.14m;
int n = Convert.ToInt32(value);

Vedi MSDN . Puoi anche usare Decimal.ToInt32. Ancora una volta, vedi MSDN . Infine, puoi eseguire un cast diretto come in

decimal value = 3.14m;
int n = (int) value;

che utilizza l'operatore di cast esplicito. Vedi MSDN .

Non puoi.

Bene, certo che potresti , tuttavia un int (System.Int32) non è abbastanza grande da contenere ogni possibile valore decimale.

Ciò significa che se si esegue il cast di un decimale più grande di int.MaxValue si verificherà un overflow e se il decimale è più piccolo di int.MinValue, sarà underflow.

Cosa succede in caso di underflow / overflow? Una delle due cose Se la tua build è deselezionata (ovvero, al CLR non importa se lo fai), la tua applicazione continuerà dopo il valore over / underflow, ma il valore in int non sarà quello che ti aspettavi. Ciò può portare a bug intermittenti e può essere difficile da correggere. Finirai la tua applicazione in uno stato sconosciuto che potrebbe causare la corruzione della tua applicazione da qualsiasi dato importante su cui sta lavorando. Non bene.

Se il tuo assieme è spuntato (proprietà-> build-> avanzato-> verifica la presenza di overflow / underflow aritmetici o l'opzione del compilatore / checked), il tuo codice genererà un'eccezione quando si verifica un under / overflow. Questo è probabilmente meglio di no; tuttavia l'impostazione predefinita per gli assiemi non è quella di verificare l'overflow / underflow.

La vera domanda è "cosa stai cercando di fare?" Senza conoscere le tue esigenze, nessuno può dirti cosa dovresti fare in questo caso, a parte l'ovvio: NON FARLO.

Se in particolare NON ti interessa, le risposte qui sono valide. Tuttavia, dovresti comunicare la tua comprensione del fatto che potrebbe verificarsi un overflow e che non importa avvolgendo il codice cast in un blocco non selezionato

unchecked
{
  // do your conversions that may underflow/overflow here
}

In questo modo le persone che arrivano dietro di te capiscono che non ti interessa, e se in futuro qualcuno cambierà le tue build in / controllerà, il tuo codice non si romperà inaspettatamente.

Se tutto ciò che vuoi fare è rilasciare la parte frazionaria del numero, lasciando la parte integrale, puoi usare Math.Truncate.

decimal actual = 10.5M;
decimal expected = 10M;
Assert.AreEqual(expected, Math.Truncate(actual));

int i = (int)d;

ti darà il numero arrotondato per difetto.

Se si desidera arrotondare al numero pari più vicino (ovvero> 0,5 arrotonderà per eccesso) è possibile utilizzare

int i = (int)Math.Round(d, MidpointRounding.ToEven);

In generale è possibile eseguire il cast tra tutti i tipi numerici in C #. Se non ci sono informazioni che andranno perse durante il cast, puoi farlo implicitamente:

int i = 10;
decimal d = i;

anche se puoi ancora farlo esplicitamente se desideri:

int i = 10;
decimal d = (decimal)i;

Tuttavia, se stai per perdere informazioni attraverso il cast, devi farlo esplicitamente (per mostrare che sei consapevole che potresti perdere informazioni):

decimal d = 10.5M;
int i = (int)d;

Qui stai perdendo il ".5". Questo può andare bene, ma devi essere esplicito al riguardo e fare un cast esplicito per dimostrare che potresti perdere le informazioni.

decimal d = 2;
int i = (int) d;

Questo dovrebbe funzionare bene.

decimal vIn = 0.0M;
int vOut = Convert.ToInt32(vIn);

Ecco una pagina web molto utile per convertire i tipi di dati per quelli degli altri. http://www.convertdatatypes.com/Convert-decimal-to-int-in-CSharp.html

System.Decimalimplementa l' IConvertableinterfaccia, che ha un ToInt32()membro.

La chiamata System.Decimal.ToInt32()funziona per te?

Un trucco accurato per l'arrotondamento veloce è l'aggiunta di 0,5 prima di lanciare il tuo decimale su un int.

decimal d = 10.1m;
d += .5m;
int i = (int)d;

Va ancora i=10, ma

decimal d = 10.5m;
d += .5m;
int i = (int)d;

Arrotonderebbe per quello i=11.

Preferisco usare Math.Round , Math.Floor , Math.Ceiling o Math.Truncate per impostare esplicitamente la modalità di arrotondamento nel modo appropriato.

Si noti che restituiscono anche tutti i decimali, poiché Decimal ha un intervallo di valori più ampio rispetto a un Int32, quindi sarà comunque necessario eseguire il cast (e verificare la presenza di overflow / underflow).

 checked {
   int i = (int)Math.Floor(d);
 }

decimale d = 5.5;

int i = decimal.ToInt32(d);// you will get i = 5

ref: collegamento del testo

Arrotondare un decimale all'intero più vicino

decimal a ;
int b = (int)(a + 0.5m);

quando a = 49.9, allorab = 50

quando a = 49.5, allorab = 50

quando a = 49.4, quindi b = 49ecc.

Trovo che l'operatore di casting non funzioni se hai un decimale inscatolato (cioè un valore decimale all'interno di un tipo di oggetto). Convert.ToInt32 (decimale come oggetto) funziona bene in questo caso.

Questa situazione si presenta quando si recuperano i valori IDENTITY / AUTONUMBER dal database:

SqlCommand foo = new SqlCommand("INSERT INTO...; SELECT SCOPE_IDENTITY()", conn);
int ID = Convert.ToInt32(foo.ExecuteScalar());  // works
int ID = (int)foo.ExecuteScalar();              // throws InvalidCastException

Vedi 4.3.2 Conversioni di unboxing

Nessuna risposta sembra avere a che fare con OverflowException / UnderflowException che proviene dal tentativo di convertire un decimale al di fuori dell'intervallo di int.

int intValue = (int)Math.Max(int.MinValue, Math.Min(int.MaxValue, decimalValue));

Questa soluzione restituirà il valore int massimo o minimo possibile se il valore decimale è al di fuori dell'intervallo int. Potresti voler aggiungere alcuni arrotondamenti con Math.Round, Math.Ceiling o Math.Floor per quando il valore è compreso nell'intervallo int.