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

Tipicamente 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, per esempio.

public int? myProperty
{
   get;
   set;
}

Significa che il tipo di valore in questione è un tipo nullable

I tipi nullable sono istanze della struttura System.Nullable. Un tipo nullable può rappresentare l'intervallo di valori corretto per il tipo di valore sottostante, oltre a un valore null aggiuntivo. Ad esempio, a Nullable<Int32>, pronunciato "Nullable of Int32", può essere assegnato qualsiasi valore compreso tra -2147483648 e 2147483647 oppure può essere assegnato il valore null. A è Nullable<bool>possibile assegnare i valori true, false o null. La possibilità di assegnare null a tipi numerici e booleani è particolarmente utile quando si ha a che fare con database e altri tipi di dati che contengono elementi a cui potrebbe non essere assegnato un valore. Ad esempio, un campo booleano in un database può archiviare i valori vero o falso oppure potrebbe non essere definito.

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

È una scorciatoia per Nullable<int>. Nullable<T>viene utilizzato per consentire l'impostazione di un tipo di valore null. I tipi di valore in genere non possono essere nulli .

In

x ? "yes" : "no"

il ? dichiara una frase if . Qui: x rappresenta la condizione booleana; La parte prima di : è la frase then e la parte dopo è la frase else .

In, ad esempio,

int?

il ? dichiara un tipo nullable e indica che il tipo prima può avere un valore null.

Tipi nullabili

I tipi nullable sono istanze della struttura System.Nullable. Un tipo nullable può rappresentare l'intervallo normale di valori per il tipo di valore sottostante, oltre a un valore null aggiuntivo . Ad esempio, a [ Nullable<Int32>], pronunciato "Nullable of Int32", può essere assegnato qualsiasi valore compreso tra -2147483648 e 2147483647 oppure può essere assegnato il valore null. A [ Nullable<bool>] possono essere assegnati i valori true o false o null. La possibilità di assegnare null a tipi numerici e booleani è particolarmente utile quando si ha a che fare con database e altri tipi di dati contenenti elementi a cui non può essere assegnato un valore. Ad esempio, un campo booleano in un database può archiviare i valori vero o falso oppure potrebbe non essere definito.

dichiara che il tipo è nullable.

uso pratico:

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

  return someFunctionThatHandlesIntAndReturnsString(value);
}

Per aggiungere le risposte 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;
    }
}

Ciò darebbe un errore di compilazione:

Errore 12 Impossibile convertire null in 'Test' perché è un tipo di valore non annullabile

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

int?è una scorciatoia per Nullable<int>. Le due forme sono intercambiabili.

Nullable<T>è un operatore che è possibile utilizzare con un tipo di valore Tper farlo accettare null.

Nel caso non lo sapessi: il valore tipi sono tipi che accetta valori come int, bool, charecc ...

Non possono accettare riferimenti a valori: genererebbero un errore in fase di compilazione se si assegnasse loro un null, al contrario dei tipi di riferimento , che ovviamente possono accettarlo.

Perché ne avresti bisogno? Perché a volte le variabili del tipo di valore potrebbero ricevere riferimenti null restituiti da qualcosa che non ha funzionato molto bene, come una variabile mancante o indefinita restituita da un database.

Ti consiglio di leggere la Documentazione Microsoft perché tratta abbastanza bene l'argomento.