Réponses:
Jusqu'à présent, les autres réponses sont toutes correctes; Je voulais juste en ajouter un de plus légèrement plus propre:
v2 = v1 ?? default(int);
Any Nullable<T>
est implicitement convertible en son T
, à condition que l'expression entière en cours d'évaluation ne puisse jamais entraîner une affectation nulle à un ValueType. Ainsi, l'opérateur de coalescence nulle ??
n'est qu'un sucre de syntaxe pour l'opérateur ternaire:
v2 = v1 == null ? default(int) : v1;
... qui est à son tour du sucre de syntaxe pour un if / else:
if(v1==null)
v2 = default(int);
else
v2 = v1;
En outre, à partir de .NET 4.0, Nullable<T>
a une méthode "GetValueOrDefault ()", qui est un getter sans danger qui effectue essentiellement la fusion nulle illustrée ci-dessus, donc cela fonctionne aussi:
v2 = v1.GetValueOrDefault();
default(int)
vraiment nécessaire? Quel est le problème avec un simple 0
?
default
cas échéant. Zéro n'est pas toujours valide en tant que valeur, encore moins la valeur par défaut, donc si vous remplacez int
par un générique, T
vous trouverez que mon code fonctionne tandis que zéro ne fonctionne pas. Dans une future version du framework, default
peut également devenir surchargeable; si et quand cela se produit, le code utilisant la valeur par défaut pourra facilement en profiter, tandis que les affectations explicites nulles ou nulles devront être modifiées.
Comme ça,
if(v1.HasValue)
v2=v1.Value
Vous pouvez utiliser la propriété Value pour l'affectation.
v2 = v1.Value;
v1.HasValue
abord.
Si vous savez que cela v1
a une valeur, vous pouvez utiliser la Value
propriété:
v2 = v1.Value;
L'utilisation de la GetValueOrDefault
méthode affectera la valeur s'il y en a une, sinon la valeur par défaut pour le type ou une valeur par défaut que vous spécifiez:
v2 = v1.GetValueOrDefault(); // assigns zero if v1 has no value
v2 = v1.GetValueOrDefault(-1); // assigns -1 if v1 has no value
Vous pouvez utiliser la HasValue
propriété pour vérifier si v1
a une valeur:
if (v1.HasValue) {
v2 = v1.Value;
}
Il existe également un support linguistique pour la GetValueOrDefault(T)
méthode:
v2 = v1 ?? -1;
Vous ne pouvez pas le faire si v1 est null, mais vous pouvez vérifier avec un opérateur.
v2 = v1 ?? 0;
GetValueOrDefault()
récupère la valeur de l'objet. S'il est nul, il renvoie la valeur par défaut de int, qui est 0.
Exemple:
v2= v1.GetValueOrDefault();
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 valeur par défaut différente 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 que la valeur soit retournée (que la méthode échoue ou non):
v2 = v1.GetValueOrDefault();
.NET 4.7.2.: Renvoie GetValueOrDefault()
la valeur du champ sans aucune vérification.
En ce qui me concerne, la meilleure solution consiste à utiliser la GetValueOrDefault()
méthode.
v2 = v1.GetValueOrDefault();
La conversion int nullable en int peut être effectuée comme suit:
v2=(int)v1;
c'est possible avec v2 = Convert.ToInt32(v1);
Vous pourriez faire
v2 = v1.HasValue ? v1.Value : v2;
Une conversion simple entre v1
et v2
n'est pas possible car v1
a un domaine de valeurs plus grand que v2
. C'est tout ce qui v1
peut contenir plus l' null
État. Pour convertir, vous devez indiquer explicitement quelle valeur int
sera utilisée pour mapper l' null
état. La façon la plus simple de le faire est l' ??
opérateur
v2 = v1 ?? 0; // maps null of v1 to 0
Cela peut également être fait sous forme longue
int v2;
if (v1.HasValue) {
v2 = v1.Value;
} else {
v2 = 0;
}
En fonction de votre contexte d'utilisation, vous pouvez utiliser la fonction de correspondance de modèles de C # 7:
int? v1 = 100;
if (v1 is int v2)
{
Console.WriteLine($"I'm not nullable anymore: {v2}");
}
Étant donné que certaines personnes votent vers le bas sans laisser d'explication, je voudrais ajouter quelques détails pour expliquer la raison pour laquelle cela est considéré comme une solution viable.
La correspondance de motifs de C # 7 nous permet désormais de vérifier le type d'une valeur et de la transposer implicitement. Dans l'extrait ci-dessus, la condition if ne passe que lorsque la valeur stockée dans v1
est compatible avec le type for v2
, ce qui est le cas dans ce cas int
. Il s'ensuit que lorsque la valeur de v1
est null
, la condition if échouera car nul ne peut être affecté à un int
. Plus correctement, null
n'est pas un int
.
Je voudrais souligner que cette solution n'est peut-être pas toujours le choix optimal. Comme je le suggère, je pense que cela dépendra du contexte d'utilisation exact du développeur. Si vous avez déjà un int?
et que vous souhaitez opérer sous condition sur sa valeur si et seulement si la valeur affectée n'est pas nulle (c'est la seule fois où il est sûr de convertir un entier nullable en un entier normal sans perdre d'informations), alors la correspondance de motifs est peut-être l'un des moyens les plus concis de le faire.
HasValue
chèques.
Dans C # 7.1 et versions ultérieures, le type peut être déduit en utilisant le default
littéral au lieu de l' default
opérateur afin qu'il puisse être écrit comme ci-dessous:
v2 = v1 ?? default;
int v2= Int32.Parse(v1.ToString());
v1
estnull
?