web-dev-qa-db-fra.com

Quel est le but d'un point d'interrogation après un type (par exemple: int? MyVariable)?

En règle générale, le point d'interrogation est principalement utilisé pour le conditionnel x ? "yes" : "no".

Mais j’en ai vu un autre usage mais je ne trouve pas d’explication sur cet utilisateur de l’opérateur ?, par exemple.

public int? myProperty
{
   get;
   set;
}
c#asp.net.nettypes
405
GenEric35

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, un Nullable<Int32>, prononcé "Nullable of Int32", peut recevoir une valeur comprise entre -2147483648 et 2147483647, ou la valeur null. Les valeurs true, false ou null peuvent être attribuées à Nullable<bool>. La possibilité d'assigner des valeurs null aux types numérique et booléen est particulièrement utile lorsque vous utilisez 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.

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

C'est un raccourci pour Nullable<int> . _Nullable<T>_ permet de définir un type de valeur sur null. Types de valeur généralement ne peut pas être nul .

112
Klaus Byskov Pedersen

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 suivante est la phrase else.

Dans, par exemple,

int?

? déclare un type nullable et signifie que le type précédent peut avoir une valeur null.

57
eKek0

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-jacente, plus une valeur null supplémentaire . Par exemple, un [Nullable<Int32>], prononcé "Nullable of Int32", peut recevoir une valeur comprise entre -2147483648 et 2147483647, ou la valeur null. Il est possible d'attribuer aux valeurs [Nullable<bool>] les valeurs true ou false ou null. La possibilité d'attribuer des valeurs null aux types numérique et booléen est particulièrement utile lorsqu'il s'agit de 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.

48
Ahmet Kakıcı

il déclare que le type est nullable.

11
Thanos Papathanasiou

utilisation pratique:

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

  return someFunctionThatHandlesIntAndReturnsString(value);
}
6
A.J.Bauer

Pour ajouter aux 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)

3
Sunil Purushothaman

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 T pour le faire accepter null.

Si vous ne le connaissez pas: types de valeur sont des types qui acceptent des valeurs telles que int, bool, char etc ...

Ils ne peuvent pas accepter les références à des valeurs: ils généreraient une erreur de compilation si vous leur affectiez un null, par opposition à types de référence , qui peut évidemment l'accepter.

Pourquoi aurais-tu besoin de ça? Parce que parfois, vos variables de type valeur peuvent recevoir des références NULL 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 le Documentation Microsoft car il couvre assez bien le sujet.

2
Nicola Amadio