Come convertire C # nullable int in int

Come faccio a convertire un nullable intin un int? Supponiamo di avere 2 tipi di int come di seguito:

int? v1;  
int v2; 

Voglio assegnare v1il valore a v2. v2 = v1;causerà un errore. Come posso convertire v1in v2?

Le altre risposte finora sono tutte corrette; Volevo solo aggiungere un altro che è leggermente più pulito:

v2 = v1 ?? default(int);

Qualsiasi Nullable<T>è implicitamente convertibile in suo T, A condizione che l'intera espressione valutata non possa mai tradursi in un'assegnazione nulla a un ValueType. Quindi, l'operatore a coalescenza nulla ??è solo zucchero di sintassi per l'operatore ternario:

v2 = v1 == null ? default(int) : v1;

... che è a sua volta zucchero di sintassi per un if / else:

if(v1==null)
   v2 = default(int);
else
   v2 = v1;

Inoltre, a partire da .NET 4.0 Nullable<T>ha un metodo "GetValueOrDefault ()", che è un getter null-safe che fondamentalmente esegue la coalescenza null mostrata sopra, quindi funziona anche:

v2 = v1.GetValueOrDefault();

Come questo,

if(v1.HasValue)
   v2=v1.Value

È possibile utilizzare la proprietà Value per l'assegnazione.

v2 = v1.Value;

Tutto ciò che serve è..

v2= v1.GetValueOrDefault();

Se sai che v1ha un valore, puoi utilizzare la Valueproprietà:

v2 = v1.Value;

L'uso del GetValueOrDefaultmetodo assegnerà il valore se ce n'è uno, altrimenti l'impostazione predefinita per il tipo o un valore predefinito specificato:

v2 = v1.GetValueOrDefault(); // assigns zero if v1 has no value

v2 = v1.GetValueOrDefault(-1); // assigns -1 if v1 has no value

È possibile utilizzare la HasValueproprietà per verificare se v1ha un valore:

if (v1.HasValue) {
  v2 = v1.Value;
}

Esiste anche il supporto linguistico per il GetValueOrDefault(T)metodo:

v2 = v1 ?? -1;

Non puoi farlo se v1 è null, ma puoi verificare con un operatore.

v2 = v1 ?? 0;

GetValueOrDefault()

recupera il valore dell'oggetto. Se è null, restituisce il valore predefinito di int, che è 0.

Esempio:

v2= v1.GetValueOrDefault();

Se il valore predefinito per un determinato tipo è un risultato accettabile:

if (v1.HasValue)
    v2 = v1.GetValueOrDefault();

Se si desidera un valore predefinito diverso quando il risultato non è definito:

v2 = v1.GetValueOrDefault(255);    // or any valid value for int in place of 255

Se si desidera solo restituire il valore (indipendentemente dal fatto che il metodo non sia riuscito o meno):

v2 = v1.GetValueOrDefault();

.NET 4.7.2 .: GetValueOrDefault()restituisce il valore del campo senza alcun controllo.

Per quanto mi riguarda, la soluzione migliore sta usando il GetValueOrDefault()metodo.

v2 = v1.GetValueOrDefault();

La conversione da nulla a int può essere eseguita in questo modo:

v2=(int)v1;

è possibile con v2 = Convert.ToInt32(v1);

Si potrebbe fare

v2 = v1.HasValue ? v1.Value : v2;

Una semplice conversione tra v1e v2non è possibile perché v1ha un dominio di valori più grande di v2. È tutto ciò che v1può contenere più lo nullstato. Per convertire è necessario indicare esplicitamente quale valore intverrà utilizzato per mappare lo nullstato. Il modo più semplice per farlo è l' ??operatore

v2 = v1 ?? 0;  // maps null of v1 to 0

Questo può essere fatto anche in forma lunga

int v2;
if (v1.HasValue) {
  v2 = v1.Value;
} else {
  v2 = 0;
}

A seconda del contesto di utilizzo, è possibile utilizzare la funzione di corrispondenza dei motivi di C # 7:

int? v1 = 100;
if (v1 is int v2)
{
    Console.WriteLine($"I'm not nullable anymore: {v2}");
}

MODIFICARE:

Dal momento che alcune persone effettuano il downvoting senza lasciare una spiegazione, vorrei aggiungere alcuni dettagli per spiegare la logica per includere questo come soluzione praticabile.

• La corrispondenza dei modelli di C # 7 ora ci consente di controllare il tipo di un valore e di lanciarlo implicitamente. Nel frammento precedente, la condizione if passerà solo quando il valore memorizzato v1è compatibile con il tipo per il tipo v2, che in questo caso lo è int. Ne consegue che quando il valore per v1è null, la condizione if fallirà poiché null non può essere assegnato a un int. Più propriamente, nullnon è un int.

• Vorrei sottolineare che questa soluzione potrebbe non essere sempre la scelta ottimale. Come suggerisco, credo che ciò dipenderà dal contesto di utilizzo esatto dello sviluppatore. Se hai già un int?e vuoi operare in modo condizionale sul suo valore if-and-only-se il valore assegnato non è nullo (questa è l'unica volta in cui è sicuro convertire un nullable in un int normale senza perdere informazioni), quindi la corrispondenza dei modelli è forse uno dei modi più concisi per farlo.

Assegnerà il valore di v1a v2se non è null, altrimenti prenderà un valore predefinito come zero.

v2=v1??0

O sotto c'è l'altro modo di scriverlo.

v2 = v1.HasValue?v1:0

In C # 7.1 e versioni successive, il tipo può essere dedotto usando il valore defaultletterale anziché l' defaultoperatore in modo che possa essere scritto come di seguito:

v2 = v1 ?? default;

 int v2= Int32.Parse(v1.ToString());