Como converter int n anulável em int

Como faço para converter um anulável intem um int? Suponha que eu tenha 2 tipos de int como abaixo:

int? v1;  
int v2; 

Eu quero atribuir v1o valor de v2. v2 = v1;causará um erro. Como faço v1para converter para v2?

As outras respostas até agora estão todas corretas; Eu só queria adicionar mais um pouco mais limpo:

v2 = v1 ?? default(int);

Qualquer um Nullable<T>é implicitamente conversível T, desde que a expressão inteira que está sendo avaliada nunca possa resultar em uma atribuição nula a um ValueType. Portanto, o operador coalescente nulo ??é apenas açúcar de sintaxe para o operador ternário:

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

... que por sua vez é açúcar de sintaxe para um if / else:

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

Além disso, a partir do .NET 4.0, Nullable<T>possui um método "GetValueOrDefault ()", que é um getter com segurança nula que basicamente executa a coalescência nula mostrada acima, portanto, isso também funciona:

v2 = v1.GetValueOrDefault();

Como isso,

if(v1.HasValue)
   v2=v1.Value

Você pode usar a propriedade Value para atribuição.

v2 = v1.Value;

Tudo o que você precisa é..

v2= v1.GetValueOrDefault();

Se você sabe que v1tem um valor, pode usar a Valuepropriedade:

v2 = v1.Value;

O uso do GetValueOrDefaultmétodo atribuirá o valor se houver um, caso contrário, o padrão para o tipo ou um valor padrão que você especificar:

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

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

Você pode usar a HasValuepropriedade para verificar se v1tem um valor:

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

Também há suporte ao idioma para o GetValueOrDefault(T)método:

v2 = v1 ?? -1;

Você não pode fazer isso se a v1 for nula, mas você pode verificar com um operador.

v2 = v1 ?? 0;

GetValueOrDefault()

recupera o valor do objeto. Se for nulo, ele retornará o valor padrão de int, que é 0.

Exemplo:

v2= v1.GetValueOrDefault();

Se o valor padrão para um determinado tipo for um resultado aceitável:

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

Se você desejar um valor padrão diferente quando o resultado for indefinido:

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

Se você deseja apenas o valor retornado (não importa se o método falhou ou não):

v2 = v1.GetValueOrDefault();

.NET 4.7.2 .: GetValueOrDefault()retorna o valor do campo sem nenhuma verificação.

Para mim, a melhor solução é usar o GetValueOrDefault()método

v2 = v1.GetValueOrDefault();

A conversão int anulável em int pode ser feita da seguinte maneira:

v2=(int)v1;

é possível com v2 = Convert.ToInt32(v1);

Você poderia fazer

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

Uma conversão simples entre v1e v2não é possível porque v1possui um domínio de valores maior que v2. É tudo o que v1pode aguentar mais o nullestado. Para converter, você precisa declarar explicitamente em que valor intserá usado para mapear o nullestado. A maneira mais simples de fazer isso é o ??operador

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

Isso também pode ser feito de forma longa

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

Dependendo do contexto de uso, você pode usar o recurso de correspondência de padrões do C # 7:

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

EDITAR:

Como algumas pessoas estão votando sem deixar uma explicação, eu gostaria de adicionar alguns detalhes para explicar a lógica de incluir isso como uma solução viável.

• A correspondência de padrões do C # 7 agora nos permite verificar o tipo de um valor e convertê-lo implicitamente. No snippet acima, a condição if somente passará quando o valor armazenado v1for compatível com o tipo do tipo for v2, que nesse caso é int. Daqui resulta que, quando o valor for v1for null, a condição if falhará, pois null não pode ser atribuído a um int. Mais corretamente, nullnão é um int.

• Gostaria de destacar que o fato de que essa solução nem sempre é a melhor opção. Como sugiro, acredito que isso dependerá do contexto de uso exato do desenvolvedor. Se você já possui um int?e deseja operar condicionalmente em seu valor se e somente se o valor atribuído não for nulo (este é o único momento em que é seguro converter um int nulo em um int regular sem perder informações), a correspondência de padrões é talvez uma das maneiras mais concisas de fazer isso.

Ele atribuirá o valor de v1a v2se não for nulo, caso contrário, o valor padrão será zero.

v2=v1??0

Ou abaixo é a outra maneira de escrevê-lo.

v2 = v1.HasValue?v1:0

No C # 7.1 e posterior, o tipo pode ser inferido usando o defaultliteral em vez do defaultoperador, para que possa ser escrito da seguinte maneira:

v2 = v1 ?? default;

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