Comment convertir le C# nullable int int

Comment puis-je convertir des nullable int à un int? Supposons que j'ai 2 type de int en tant que ci-dessous:

int? v1;  
int v2;

Je veux attribuer v1's de la valeur à v2. v2 = v1; provoquera une erreur. Comment puis-je convertir des v1 à v2?

InformationsquelleAutor KentZhou | 2011-05-13

c#nullable

572

Les autres réponses sont tout à fait correct; je voulais juste ajouter un peu de nettoyant:
```
v2 = v1 ?? default(int);
```
Tout Nullable<T> est implicitement convertible son T, à la CONDITION que l'expression soit évaluée ne peut jamais résulter en une valeur null à l'affectation à un ValueType. Ainsi, le null-coalescence de l'opérateur ?? est juste la syntaxe de sucre pour l'opérateur ternaire:
```
v2 = v1 == null ? default(int) : v1;
```
...qui est à son tour de la syntaxe de sucre pour un if/else:
```
if(v1==null)
   v2 = default(int);
else
   v2 = v1;
```
Aussi, comme de .NET 4.0, Nullable<T> a un "GetValueOrDefault()" la méthode, qui est un null-safe getter que, fondamentalement, effectue les nuls-la coalescence indiqué ci-dessus, de sorte que cela fonctionne aussi:
```
v2 = v1.GetValueOrDefault();
```
- Merci. Je ne savais pas à propos de la GetValueOrDefault()...
- Est default(int) vraiment nécessaire? Quel est le problème avec un simple 0?
- Il serait travailler pour cet exemple, mais dans le cas général, il est recommandé d'utiliser default le cas échéant. Zéro n'est pas toujours valide en tant que valeur, beaucoup moins la valeur par défaut, donc si vous remplacez int avec un générique T vous trouverez mon code fonctionne alors que nul ne l'est pas. Dans un avenir framework version, default peuvent aussi devenir overloadable; si et quand cela arrive, le code à l'aide de la valeur par défaut sera facilement en mesure de profiter, tout en explicite la valeur null ou zéro affectations devront être modifiées.
- Ce chiffre devrait atteindre le haut: .NET 4.0, Nullable<T> a une "GetValueOrDefault()"
- Merci pour le retour de l'éditer avec GetValueOrDefault!
- Vous voudrez peut-être prudent avec DateTime lorsque vous utilisez par défaut. Cela peut insérer la date par défaut à la place du vide.
InformationsquelleAutor KeithS
148

Comme ça,
```
if(v1.HasValue)
   v2=v1.Value
```
InformationsquelleAutor Srinivas Reddy Thatiparthy
81

Vous pouvez utiliser la propriété Value de cession.
```
v2 = v1.Value;
```
- Si vous n'êtes pas sûr si v1 contient null, vous pouvez utiliser la valeur null-coalescence opérateur de définir une valeur de repli. E. g. v2 = v1 ?? 0;
- Et assurez-vous de vérifier v1.HasValue premier.
- MSDN dit, que cela va lever une exception si le v1 est null. À mon avis, ce n'est pas une réponse correcte.
- Je pense que c'est souhaitable comportement -- je suis surpris de nombreux autres réponses sont ok avec silencieusement la conversion d'une valeur nulle à 0. Si vous êtes à l'affectation d'un type nullable à un non-type nullable, vous devez être sûr que la valeur n'est pas null. L'OP n'a pas dit "je veux attribuer v1 à v2, ou 0 si v1 est nul", mais c'est ce que tout le monde semblait supposer
InformationsquelleAutor e36M3
72

Tous vous avez besoin est..
```
v2= v1.GetValueOrDefault();
```
InformationsquelleAutor thestar
45

Si vous savez que v1 a une valeur, vous pouvez utiliser le Value propriété:
```
v2 = v1.Value;
```
À l'aide de la GetValueOrDefault méthode affectez la valeur si il y en a un, sinon la valeur par défaut pour le type, ou une valeur par défaut que vous indiquez:
```
v2 = v1.GetValueOrDefault(); //assigns zero if v1 has no value

v2 = v1.GetValueOrDefault(-1); //assigns -1 if v1 has no value
```
Vous pouvez utiliser le HasValue propriété pour vérifier si v1 a une valeur:
```
if (v1.HasValue) {
  v2 = v1.Value;
}
```
Il est également le support de la langue pour la GetValueOrDefault(T) méthode:
```
v2 = v1 ?? -1;
```
- Vous ne devez pas utiliser la valeur sans vérifier d'abord pour voir si il y a une valeur. Utiliser l' ?? opérateur à la place.
InformationsquelleAutor Guffa
42

Vous ne pouvez pas le faire si v1 est nulle, mais vous pouvez vérifier avec un opérateur.
```
v2 = v1 ?? 0;
```
InformationsquelleAutor Arturo Martinez
27

GetValueOrDefault()

récupère la valeur de l'objet. Si elle est nulle, elle renvoie la valeur par défaut de type int , qui est 0.

Exemple:

v2= v1.GetValueOrDefault();

InformationsquelleAutor Aniket Sharma
12

Int nullable à l'int de la conversion peut être fait comme suit:
```
v2=(int)v1;
```
- Si v1 est null, ce qui va causer une exception InvalidOperationException.
InformationsquelleAutor Krishna shidnekoppa
11

c'est possible avec v2 = Convert.ToInt32(v1);

InformationsquelleAutor Rev
11

Autant que je suis concerné, la meilleure solution est d'utiliser GetValueOrDefault() méthode.
```
v2 = v1.GetValueOrDefault();
```
- c'était la meilleure utile pour moi
InformationsquelleAutor Masoud Darvishian
10

Si la valeur par défaut pour un type donné est un résultat acceptable:
```
if (v1.HasValue)
    v2 = v1.GetValueOrDefault();
```
Si vous souhaitez une autre valeur par défaut lorsque le résultat n'est pas défini:
```
v2 = v1.GetValueOrDefault(255);    //or any valid value for int in place of 255
```
Si vous voulez juste la valeur retournée (peu importe si la méthode a échoué ou pas):
```
v2 = v1.GetValueOrDefault();
```
.NET 4.7.2.: .GetValueOrDefault()">GetValueOrDefault() retourne la valeur du champ sans aucune vérification.

InformationsquelleAutor GrzegorzF
9

Vous pourriez faire
```
v2 = v1.HasValue ? v1.Value : v2;
```
InformationsquelleAutor FIre Panda
9

Une simple conversion entre v1 et v2 n'est pas possible parce que v1 a un domaine plus vaste de valeurs que v2. C'est tout v1 peut contenir en plus de la null état. Pour convertir, vous devez explicitement la valeur qu'en int sera utilisé pour cartographier les null état. Le moyen le plus simple pour ce faire est la ?? opérateur
```
v2 = v1 ?? 0;  //maps null of v1 to 0
```
Cela peut aussi être fait en forme longue
```
int v2;
if (v1.HasValue) {
  v2 = v1.Value;
} else {
  v2 = 0;
}
```
InformationsquelleAutor JaredPar
3

En fonction de votre utilisation, vous pouvez utiliser le C# 7 du pattern-matching fonctionnalité:
```
int? v1 = 100;
if (v1 is int v2)
{
    Console.WriteLine($"I'm not nullable anymore: {v2}");
}
```
EDIT:

Puisque certaines personnes sont downvoting sans laisser d'explication, je tiens à ajouter quelques détails pour expliquer le bien-fondé de l'inclusion de cette comme une solution viable.
- C# 7 du pattern matching nous permet aujourd'hui de vérifier le type d'une valeur, et de le jeter implicitement. Dans l'extrait ci-dessus, si la condition ne passe lorsque la valeur stockée dans v1 est de type compatible avec le type de v2, qui dans ce cas est int. Il en résulte que, lorsque la valeur de v1 est null, si la condition échoue, car nul ne peut être attribué à un int. Plus correctement, null n'est pas un int.
- Je tiens à souligner que la que cette solution peut ne pas toujours être le choix optimal. Comme je le suggère, je crois que cela dépendra de ce que le développeur d'utilisation précises contexte. Si vous avez déjà un int? et souhaitez conditionnellement fonctionner sur sa valeur si-et-seulement-si la valeur assignée n'est pas null (c'est le seul moment où il est sûr de convertir un nullable int vers un int, sans perte d'information), puis le pattern matching est peut-être le plus concis de façons de le faire.
- if (v1 is int v2) ne semble pas juste pour moi...
- oui non.... la v2 juste jette tout. désolé
- La nécessité de l'introduction d'un nouveau nom de variable est malheureux, mais c'est le meilleur (le plus sûr) de la solution si il n'y a pas de valeur par défaut, car il n'y a pas de risque de accidentellement refactoring loin de votre HasValue contrôles.
InformationsquelleAutor Nick Miller
2

Il va affecter la valeur de v1 à v2 si elle n'est pas null, sinon il va prendre une valeur par défaut à zéro.
```
v2=v1??0
```
Ou ci-dessous est l'autre façon de l'écrire.
```
v2 = v1.HasValue?v1:0
```
InformationsquelleAutor sagar

Vous devez vous connecter pour publier un commentaire.

EDIT: