Comment convertir C # nullable int en int

Comment convertir un nullable inten un int? Supposons que j'ai 2 types d'int comme ci-dessous:

int? v1;  
int v2; 

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

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();

Comme ça,

if(v1.HasValue)
   v2=v1.Value

Vous pouvez utiliser la propriété Value pour l'affectation.

v2 = v1.Value;

Tout ce dont tu as besoin c'est..

v2= v1.GetValueOrDefault();

Si vous savez que cela v1a une valeur, vous pouvez utiliser la Valuepropriété:

v2 = v1.Value;

L'utilisation de la GetValueOrDefaultmé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 HasValuepropriété pour vérifier si v1a 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 v1et v2n'est pas possible car v1a un domaine de valeurs plus grand que v2. C'est tout ce qui v1peut contenir plus l' nullÉtat. Pour convertir, vous devez indiquer explicitement quelle valeur intsera 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}");
}

ÉDITER:

É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 v1est compatible avec le type for v2, ce qui est le cas dans ce cas int. Il s'ensuit que lorsque la valeur de v1est null, la condition if échouera car nul ne peut être affecté à un int. Plus correctement, nulln'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.

Il affectera la valeur de v1à v2s'il n'est pas nul, sinon il prendra une valeur par défaut comme zéro.

v2=v1??0

Ou ci-dessous est l'autre façon de l'écrire.

v2 = v1.HasValue?v1:0

Dans C # 7.1 et versions ultérieures, le type peut être déduit en utilisant le defaultlittéral au lieu de l' defaultopérateur afin qu'il puisse être écrit comme ci-dessous:

v2 = v1 ?? default;

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