Frage Nullable vs. int? - Gibt es einen Unterschied?


Anscheinend Nullable<int> und int? sind gleichwertig. Gibt es Gründe, sich für eines zu entscheiden?

Nullable<int> a = null;
int? b = null;
a == b; // this is true

76
2017-10-26 23:14


Ursprung


Antworten:


Kein Unterschied.

int? ist nur Kurzschrift für Nullable<int>, die selbst abgekürzt ist Nullable<Int32>.

Kompilierter Code ist genau derselbe, den Sie verwenden möchten.


113
2017-10-26 23:16



Das ? Form ist nur eine Kurzform für den vollständigen Typ. Persönliche Präferenz ist der einzige Grund, sich gegenseitig zu wählen.

Alle Einzelheiten Hier.

Die Syntax T? ist Kurzschrift für    Nullable<T>, woher T ist ein Werttyp.   Die zwei Formen sind austauschbar.


20
2017-10-26 23:17



Obwohl ich völlig übereinstimme, dass sie in den meisten Fällen dieselben sind, bin ich kürzlich auf eine Situation gestoßen, als ich dort war ist ein Unterschied zwischen diesen beiden. Für die blutigen Details siehe diese Frage, aber um Ihnen ein schnelles Beispiel zu geben:

void Test<T>(T a, bool b)
{
    var test = a is int? & b;              // does not compile
    var test2 = a is Nullable<int> & b;    // does compile
}

Die erste Zeile enthält die folgenden Fehlermeldungen:

error CS1003: Syntax error, ':' expected 
error CS1525: Invalid expression term ';'

Wenn Sie über den genauen Grund dafür neugierig sind, empfehle ich Ihnen wirklich, das schon zu überprüfen verknüpfte Frage, aber das grundlegende Problem ist, dass in der Parsing - Phase nach einem is (oder ein as) operator, wenn wir auf eine ? Token überprüfen wir, ob die Nächster Zeichen kann als unärer Operator interpretiert werden (& Könnte einer sein) und wenn ja: Der Parser kümmert sich nicht um die Möglichkeit der ? Token ist ein Typmodifizierer, es verwendet einfach den Typ davor und analysiert den Rest als ob der ? Token waren ein ternärer Operator (daher wird das Parsen fehlschlagen).

Also, während im Allgemeinen int? und Nullable<int> sind austauschbar, gibt es einige Eckfälle, wenn sie völlig unterschiedliche Ergebnisse erzeugen, weil der Parser Ihren Code sieht.


15
2017-07-14 14:03



Es gibt anscheinend einen Unterschied zwischen den beiden, wenn Code-First Entity Framework (EF) Generation verwendet wird:

Wenn Ihre Entität eine Eigenschaft enthält, die wie folgt deklariert ist:

public class MyEntity
{
    public Nullable<int> MyNullableInt { get; set; } 
}

EF wird keine Nullable-Eigenschaft generieren und Sie müssen den Generator zwingen, die Nullable-Eigenschaft wie folgt zu machen:

public class YourContext : DbContext
{
    public DbSet<MyEntity> MyEntities{ get; set; }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Entity<MyEntity>().Property(x => x.MyNullableInt).IsOptional();
    }
}

Auf der anderen Seite, wenn Sie Ihre Entität wie folgt deklarieren:

public class MyEntity
{
     public int? MyNullableInt { get; set; }
}

Die EF-Generatoreigenschaft generiert eine Nullable-Eigenschaft mit einem Nullable-Feld in der entsprechenden Datenbanktabelle.


4
2018-06-05 14:06



Nullable ist ein generischer Typ, aber int? ist nicht.

Es gibt einige Szenarien, in denen Nullable sollte über verwendet werden int?

für zB: hier kann man nicht ersetzen Nullable mit int? 

Wie können Sie den untenstehenden Code ändern, ohne zu verwenden? Nullable?

class LazyValue<T> where T : struct
{
   private Nullable<T> val;
   private Func<T> getValue;

   // Constructor.
   public LazyValue(Func<T> func)
   {
      val = null;
      getValue = func;
   }

   public T Value
   {
      get
      {
         if (val == null)
            // Execute the delegate.
            val = getValue();
         return (T)val;
      }
   }
}

1
2017-07-30 23:32