¿Cuál es el propósito de un signo de interrogación después de un tipo (por ejemplo: int? MyVariable)?

Por lo general, el uso principal del signo de interrogación es para el condicional x ? "yes" : "no",.

Pero he visto otro uso para él, pero no puedo encontrar una explicación de este uso del ?operador, por ejemplo.

public int? myProperty
{
   get;
   set;
}

Significa que el tipo de valor en cuestión es un tipo anulable

Los tipos anulables son instancias de la estructura System.Nullable. Un tipo anulable puede representar el rango correcto de valores para su tipo de valor subyacente, más un valor nulo adicional. Por ejemplo, a un Nullable<Int32>, pronunciado "Anulable de Int32", se le puede asignar cualquier valor de -2147483648 a 2147483647, o se le puede asignar el valor nulo. A Nullable<bool>se le pueden asignar los valores verdadero, falso o nulo. La capacidad de asignar nulos a tipos numéricos y booleanos es especialmente útil cuando se trata de bases de datos y otros tipos de datos que contienen elementos a los que no se les puede asignar un valor. Por ejemplo, un campo booleano en una base de datos puede almacenar los valores verdadero o falso, o puede ser indefinido.

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

Es una abreviatura de Nullable<int>. Nullable<T>se usa para permitir que se establezca un tipo de valor null. Los tipos de valor generalmente no pueden ser nulos .

En

x ? "yes" : "no"

el ? declara una oración if . Aquí: x representa la condición booleana; La parte anterior a : es la oración then y la parte posterior es la oración else .

En, por ejemplo,

int?

el ? declara un tipo anulable y significa que el tipo anterior puede tener un valor nulo.

Tipos anulables

Los tipos anulables son instancias de la estructura System.Nullable. Un tipo anulable puede representar el rango normal de valores para su tipo de valor subyacente, más un valor nulo adicional . Por ejemplo, a [ Nullable<Int32>], pronunciado "Anulable de Int32", se le puede asignar cualquier valor de -2147483648 a 2147483647, o se le puede asignar el valor nulo. A [ Nullable<bool>] se le pueden asignar los valores verdadero o falso, o nulo. La capacidad de asignar nulos a tipos numéricos y booleanos es particularmente útil cuando se trata de bases de datos y otros tipos de datos que contienen elementos a los que no se les puede asignar un valor. Por ejemplo, un campo booleano en una base de datos puede almacenar los valores verdadero o falso, o puede ser indefinido.

declara que el tipo es anulable.

uso práctico:

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

  return someFunctionThatHandlesIntAndReturnsString(value);
}

Para agregar a las respuestas anteriores, aquí hay un ejemplo de código

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

Esto daría un error de compilación:

Error 12 No se puede convertir nulo a 'Prueba' porque es un tipo de valor no anulable

Tenga en cuenta que no hay error de compilación para NullableTest. (tenga en cuenta el? en la declaración de t2)

int?es la abreviatura Nullable<int>. Las dos formas son intercambiables.

Nullable<T>es un operador que puede usar con un tipo de valor Tpara que acepte null.

En caso de que no lo sepa: Valor tipos son tipos que acepta valores como int, bool, charetc ...

No pueden aceptar referencias a valores: generarían un error en tiempo de compilación si les asigna un null, a diferencia de los tipos de referencia , que obviamente pueden aceptarlo.

¿Por qué necesitarías esto? Porque a veces sus variables de tipo de valor podrían recibir referencias nulas devueltas por algo que no funcionó muy bien, como una variable faltante o indefinida devuelta de una base de datos.

Le sugiero que lea la Documentación de Microsoft porque cubre el tema bastante bien.