À quoi sert un point d'interrogation après un type (par exemple: int? MyVariable)?

En règle générale l'utilisation principale de la marque est question pour le conditionnel, x ? "yes" : "no".

Mais j'ai vu une autre utilisation, mais je ne trouve pas d'explication sur cette utilisation de l' ?opérateur, par exemple.

public int? myProperty
{
   get;
   set;
}

Cela signifie que le type de valeur en question est un type nullable

Les types nullables sont des instances de la structure System.Nullable. Un type nullable peut représenter la plage de valeurs correcte pour son type de valeur sous-jacent, plus une valeur null supplémentaire. Par exemple, une valeur Nullable<Int32>prononcée «Nullable of Int32» peut être affectée à n'importe quelle valeur comprise entre -2147483648 et 2147483647, ou à la valeur null. A Nullable<bool>peut être affecté des valeurs true, false ou null. La possibilité d'attribuer null à des types numériques et booléens est particulièrement utile lorsque vous traitez avec des bases de données et d'autres types de données qui contiennent des éléments auxquels aucune valeur ne peut être affectée. Par exemple, un champ booléen dans une base de données peut stocker les valeurs true ou false, ou il peut être indéfini.

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

C'est un raccourci pour Nullable<int>. Nullable<T>est utilisé pour permettre à un type de valeur d'être défini sur null. Les types de valeurs ne peuvent généralement pas être nuls .

Dans

x ? "yes" : "no"

le ? déclare une phrase if . Ici: x représente la condition booléenne; La partie avant le : est la phrase alors et la partie après est la phrase else .

Dans, par exemple,

int?

le ? déclare un type nullable et signifie que le type avant lui peut avoir une valeur nulle.

Types nullables

Les types nullables sont des instances de la structure System.Nullable. Un type nullable peut représenter la plage normale de valeurs pour son type de valeur sous-jacent, plus une valeur null supplémentaire . Par exemple, un [ Nullable<Int32>], prononcé "Nullable of Int32", peut être affecté à n'importe quelle valeur comprise entre -2147483648 et 2147483647, ou à la valeur null. Un [ Nullable<bool>] peut être affecté des valeurs true ou false, ou null. La possibilité d'attribuer null à des types numériques et booléens est particulièrement utile lorsque vous traitez des bases de données et d'autres types de données contenant des éléments auxquels aucune valeur ne peut être affectée. Par exemple, un champ booléen dans une base de données peut stocker les valeurs true ou false, ou il peut être indéfini.

il déclare que le type est nullable.

utilisation pratique:

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

  return someFunctionThatHandlesIntAndReturnsString(value);
}

Pour compléter les réponses ci-dessus, voici un exemple de code

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

Cela donnerait une erreur de compilation:

Erreur 12 Impossible de convertir null en «Test» car il s'agit d'un type de valeur non nullable

Notez qu'il n'y a pas d'erreur de compilation pour NullableTest. (notez le? dans la déclaration de t2)

int?est un raccourci pour Nullable<int>. Les deux formes sont interchangeables.

Nullable<T>est un opérateur que vous pouvez utiliser avec un type de valeur Tpour le faire accepternull .

Si vous ne savez pas: types valeur sont des types qui accepte les valeurs comme int, bool, charetc ...

Ils ne peuvent pas accepter les références aux valeurs: ils généreraient une erreur au moment de la compilation si vous leur affectiez un null, contrairement aux types de référence , qui peuvent évidemment l'accepter.

Pourquoi auriez-vous besoin de ça? Parce que parfois, vos variables de type valeur peuvent recevoir des références nulles renvoyées par quelque chose qui ne fonctionne pas très bien, comme une variable manquante ou non définie renvoyée par une base de données.

Je vous suggère de lire la documentation Microsoft car elle couvre assez bien le sujet.