Cómo convertir C # nullable int a int

¿Cómo convierto un nulo inten un int? Supongamos que tengo 2 tipos de int como a continuación:

int? v1;  
int v2; 

Quiero asignarle v1el valor v2. v2 = v1;provocará un error ¿Cómo convierto v1a v2?

Las otras respuestas hasta ahora son todas correctas; Solo quería agregar uno más que sea un poco más limpio:

v2 = v1 ?? default(int);

Cualquiera Nullable<T>es implícitamente convertible a su T, SIEMPRE que la expresión completa que se evalúa nunca puede dar como resultado una asignación nula a un ValueType. Entonces, el operador de fusión nula ??es solo azúcar de sintaxis para el operador ternario:

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

... que a su vez es sintaxis de azúcar para un if / else:

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

Además, a partir de .NET 4.0, Nullable<T>tiene un método "GetValueOrDefault ()", que es un getter nulo seguro que básicamente realiza la fusión nula que se muestra arriba, por lo que esto también funciona:

v2 = v1.GetValueOrDefault();

Me gusta esto,

if(v1.HasValue)
   v2=v1.Value

Puede usar la propiedad Value para la asignación.

v2 = v1.Value;

Todo lo que necesitas es..

v2= v1.GetValueOrDefault();

Si sabe que v1tiene un valor, puede usar la Valuepropiedad:

v2 = v1.Value;

El uso del GetValueOrDefaultmétodo asignará el valor si hay uno; de lo contrario, el valor predeterminado para el tipo o el valor predeterminado que especifique:

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

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

Puede usar la HasValuepropiedad para verificar si v1tiene un valor:

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

También hay soporte de idioma para el GetValueOrDefault(T)método:

v2 = v1 ?? -1;

No puede hacerlo si v1 es nulo, pero puede verificarlo con un operador.

v2 = v1 ?? 0;

GetValueOrDefault()

recupera el valor del objeto. Si es nulo, devuelve el valor predeterminado de int, que es 0.

Ejemplo:

v2= v1.GetValueOrDefault();

Si el valor predeterminado para un tipo dado es un resultado aceptable:

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

Si desea un valor predeterminado diferente cuando el resultado no está definido:

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

Si solo desea que se devuelva el valor (no importa si el método falló o no):

v2 = v1.GetValueOrDefault();

.NET 4.7.2 .: GetValueOrDefault()devuelve el valor del campo sin ninguna comprobación.

En lo que a mí respecta, la mejor solución es usar el GetValueOrDefault()método.

v2 = v1.GetValueOrDefault();

La conversión de int nullable a int se puede hacer así:

v2=(int)v1;

es posible con v2 = Convert.ToInt32(v1);

Podrías hacerlo

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

Una conversión simple entre v1y v2no es posible porque v1tiene un dominio de valores mayor que v2. Es todo lo que v1puede aguantar más el nullestado. Para realizar la conversión, debe indicar explícitamente qué valor intse utilizará para asignar el nullestado. La forma más simple de hacer esto es el ??operador

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

Esto también se puede hacer en forma larga

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

Dependiendo de su contexto de uso, puede usar la función de coincidencia de patrones de C # 7:

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

EDITAR:

Dado que algunas personas están votando sin dejar una explicación, me gustaría agregar algunos detalles para explicar la justificación para incluir esto como una solución viable.

• La coincidencia de patrones de C # 7 ahora nos permite verificar el tipo de un valor y emitirlo implícitamente. En el fragmento anterior, la condición if solo pasará cuando el valor almacenado v1sea ​​compatible con el tipo para el tipo v2, que en este caso lo es int. Se deduce que cuando el valor para v1es null, la condición if fallará ya que nulo no puede asignarse a un int. Más adecuadamente, nullno es un int.

• Me gustaría destacar que esta solución puede no ser siempre la mejor opción. Como sugiero, creo que esto dependerá del contexto de uso exacto del desarrollador. Si ya tiene un int?y desea operar condicionalmente en su valor si y solo si el valor asignado no es nulo (este es el único momento en que es seguro convertir un int anulable en un int regular sin perder información), entonces La coincidencia de patrones es quizás una de las formas más concisas de hacer esto.

Asignará el valor de v1a v2si no es nulo, de lo contrario tomará un valor predeterminado como cero.

v2=v1??0

O debajo está la otra forma de escribirlo.

v2 = v1.HasValue?v1:0

En C # 7.1 y versiones posteriores, se puede inferir el tipo usando el defaultliteral en lugar del defaultoperador para que se pueda escribir de la siguiente manera:

v2 = v1 ?? default;

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