Qual è lo scopo di un punto interrogativo dopo un tipo (ad esempio: int? MiaVariabile)?

Question

In genere l'uso principale del punto interrogativo è per il condizionale, x ? "yes" : "no".

Ma ho visto un altro uso per questo ma non riesco a trovare una spiegazione di questo uso dell'operatore ?, ad esempio.

public int? myProperty 
{ 
    get; 
    set; 
} 

Answer 1

significa che il tipo di valore in questione è un nullable type

Nullable types are instances of the System.Nullable struct. A nullable type can represent the correct range of values for its underlying value type, plus an additional null value. For example, a Nullable, pronounced "Nullable of Int32," can be assigned any value from -2147483648 to 2147483647, or it can be assigned the null value. A Nullable can be assigned the values true, false, or null. The ability to assign null to numeric and Boolean types is especially useful when you are dealing with databases and other data types that contain elements that may not be assigned a value. For example, a Boolean field in a database can store the values true or false, or it may be undefined.

class NullableExample 
{ 
    static void Main() 
    { 
     int? num = null; 

     // Is the HasValue property true? 
     if (num.HasValue) 
     { 
      System.Console.WriteLine("num = " + num.Value); 
     } 
     else 
     { 
      System.Console.WriteLine("num = Null"); 
     } 

     // y is set to zero 
     int y = num.GetValueOrDefault(); 

     // num.Value throws an InvalidOperationException if num.HasValue is false 
     try 
     { 
      y = num.Value; 
     } 
     catch (System.InvalidOperationException e) 
     { 
      System.Console.WriteLine(e.Message); 
     } 
    } 
} 

Answer 2

dichiara che il tipo è annullabile.

Answer 3

È una scorciatoia per Nullable<int>. Nullable<T> viene utilizzato con tipi di valori che non possono essere nulli.

Answer 4

Nullable Types

Nullable types are instances of the System.Nullable struct. A nullable type can represent the normal range of values for its underlying value type, plus an additional null value. For example, a [ Nullable<Int32> ], pronounced "Nullable of Int32," can be assigned any value from -2147483648 to 2147483647, or it can be assigned the null value. A [ Nullable<bool> ] can be assigned the values true or false, or null. The ability to assign null to numeric and Boolean types is particularly useful when dealing with databases and other data types containing elements that may not be assigned a value. For example, a Boolean field in a database can store the values true or false, or it may be undefined.

Answer 5

In

x ? "yes" : "no" 

il ? dichiara una frase se. Qui: x rappresenta la condizione booleana; La parte precedente allo : è la quindi la frase e la parte successiva è la altra frase.

In, ad esempio,

int? 

il ? dichiara un tipo annullabile e indica che il tipo che precede potrebbe avere un valore nullo.

Answer 6

utilizzo pratico:

public string someFunctionThatMayBeCalledWithNullAndReturnsString(int? value) 
{ 
    if (value == null) 
    { 
    return "bad value"; 
    } 

    return someFunctionThatHandlesIntAndReturnsString(value); 
} 

Answer 7

di aggiungere alle risposte di cui sopra, ecco un esempio di codice

struct Test 
{ 
    int something; 
} 
struct NullableTest 
{ 
    int something; 
} 
class Example 
{ 
    public void Demo() 
    { 
     Test t = new Test(); 
     t = null; 

     NullableTest? t2 = new NullableTest(); 
     t2 = null; 
    } 
} 

Questo darebbe un errore di compilazione:

Error 12 Cannot convert null to 'Test' because it is a non-nullable value type

Si noti che non vi è alcun errore di compilazione per NullableTest. (notare il? nella dichiarazione di t2)

Answer 8

Per creare un elemento facoltativo, aggiungere un numero ? dopo il tipo che desideri avvolgere. Qualsiasi tipo può essere facoltativo, anche i tuoi tipi personalizzati. Non è possibile avere uno spazio tra il tipo e lo ?.

var name: String? = "Bob" // Create an optional String that contains "Bob" 
var peter: Person? = Person() // An optional "Person" (custom type) 

// A class with a String and an optional String property 
class Car { 
var modelName: String // must exist 
var internalName: String? // may or may not exist 
}