Como converter C # nullable int para int

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

 int? v1; int v2; 

Quero atribuir o valor da v2 a v2 . v2 = v1; causará um erro. Como faço para converter v1 para v2 ?

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

 v2 = v1 ?? default(int); 

Qualquer Nullable é implicitamente conversível para seu T , contanto que a expressão inteira que está sendo avaliada nunca resulte em uma atribuição nula para um ValueType. Então, o operador coalescente ?? é apenas açúcar sintático para o operador ternário:

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

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

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

Além disso, a partir do .NET 4.0, o Nullable possui um método “GetValueOrDefault ()”, que é um getter nulo que basicamente executa a coalescência de null mostrada acima, então 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(); 

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

 v2 = v1 ?? 0; 

Se você sabe que v1 tem um valor, você pode usar a propriedade Value :

 v2 = v1.Value; 

O uso do método GetValueOrDefault atribuirá o valor se houver um, caso contrário, o padrão para o tipo ou um valor padrão especificado por você:

 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 propriedade HasValue para verificar se a v1 tem um valor:

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

Há também suporte a idiomas para o método GetValueOrDefault(T) :

 v2 = v1 ?? -1; 

GetValueOrDefault()

recupera o valor do object. Se for nulo, retorna o valor padrão de int, que é 0.

Exemplo:

v2= v1.GetValueOrDefault();

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

Int anulável para conversão int pode ser feito da seguinte forma:

 v2=(int)v1; 

Você poderia fazer

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

Uma conversão simples entre v1 e v2 não é possível porque v1 tem um domínio maior de valores que v2 . É tudo que o v1 pode conter mais o estado null . Para converter você precisa declarar explicitamente qual valor em int será usado para mapear o estado null . A maneira mais simples de fazer isso é o ?? operador

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

Isso também pode ser feito em formato longo

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

Até onde eu sei, a melhor solução é usar o método GetValueOrDefault() .

 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ê quiser 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ê quiser 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.

Ele atribuirá valor de v1 a v2 se não for nulo, senão terá um valor padrão como zero.

 v2=v1??0 

Ou abaixo está a outra maneira de escrevê-lo.

 v2 = v1.HasValue?v1: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:

Uma vez que alguns não parecem perceber que esta é uma resposta perfeitamente válida (insinuando-se em votos negativos), adicionarei alguns “detalhes” para explicar a justificativa para include isso como uma solução viável. Normalmente, eu não faria esse tipo de coisa, mas ainda acredito firmemente que o StackOverflow deve ser um recurso de alta qualidade e acredito que as respostas atualizadas também são muito importantes.

  • A correspondência de padrões do C # 7 agora nos permite verificar o tipo de um valor e lançá-lo implicitamente. No trecho acima, a condição if passará somente quando o valor armazenado em v1 for compatível com o tipo do tipo de v2 , que neste caso é int . Segue-se que quando o valor para v1 é null , a condição if falhará, pois nulo não pode ser atribuído a um int . Mais propriamente, null não é um int .

  • Gostaria de destacar que a solução talvez nem sempre seja a melhor escolha. Como sugiro, acredito que isso dependerá do contexto de uso exato do desenvolvedor. Se você já tem um int? e deseja operar condicionalmente em seu valor if-and-only – se o valor designado não for nulo (essa é a única vez em que é seguro converter um int anulável em um int regular sem perder informações), a correspondência de padrões talvez seja um das formas mais concisas de fazer isso.