Conversion implicite de Nullable à la normale, des idées?

Question

Je veux une idée de comment implicitement convertir nullable "?" variables aux districts.

donné cet exemple

int? x = 5; 

int y = x; //this gonna fail, !!! 

i besoin d'un moyen de passer outre = paramètre, mais malheureusement le paramètre = n'est pas surchargeable ... suggestions

J'utilise C#

Answer 1

Il est possible de mettre en œuvre un implicit cast operator, mais seulement ou de types que vous définissez. Par exemple, faire quelque chose comme ça ..

public class NullableExtensions 
{ 
    public static implicit operator int(int? value) 
    { 
     return value ?? default(int); 
    } 
} 

.. renverra une erreur de compilation CS0556 parce que la distribution ne comprend pas le type défini par l'utilisateur.

Le plus proche que vous pouvez faire est de définir votre propre type Nullable qui ne contient un opérateur de cast implicite:

public struct ImplicitNullable<T> where T: struct 
{ 
    public bool HasValue { get { return this._value.HasValue; } } 
    public T Value { get { return this._value.Value; } } 

    public ImplicitNullable(T value) : this() { this._value = value; } 
    public ImplicitNullable(Nullable<T> value) : this() { this._value = value; } 

    public static implicit operator ImplicitNullable<T>(T value) { return new ImplicitNullable<T>(value); } 
    public static implicit operator ImplicitNullable<T>(Nullable<T> value) { return new ImplicitNullable<T>(value); } 

    public static implicit operator T(ImplicitNullable<T> value) { return value._value ?? default(T); } 
    public static implicit operator Nullable<T>(ImplicitNullable<T> value) { return value._value; } 

    private Nullable<T> _value { get; set; } 

    // Should define other Nullable<T> members, especially 
    // Equals and GetHashCode to avoid boxing 
} 

Notez que bien qu'il soit possible d'écrire ce code, il sera probablement conduire à difficile à suivre les bogues. Je recommanderais d'utiliser une conversion explicite ou de lancer une exception lorsque la valeur est null.

Ensuite, vous pouvez lancer à partir et comme prévu:

static void Main() 
{ 
    int myInt = 1; 
    int? nullableInt = 2; 

    ImplicitNullable<int> implicitInt; 

    // Convert from int or int? 
    implicitInt = myInt; 
    implicitInt = nullableInt; 

    // Convert to int or int? 
    myInt = implicitInt; 
    nullableInt = implicitInt; 
} 

Answer 2

Vous avoir deux options, accéder à la valeur directement (si vous savez avec certitude que ce n'est pas nul):

int y = x.Value; 

ou, utilisez l'opérateur coalescent null:

int y = x ?? 0; // 0 if null... 

Answer 3

Je présume que c'est C#.

Vous devez CAST, ou utilisez .value:

int? x = 5; 
int y; 

if(x.HasValue) 
    y = x.Value; 
else 
    throw new//... handle error or something 

Answer 4

Attendez, je suis tellement confus ...

Pourquoi ne pas utiliser juste GetValueOrDefault?