Qual é o objetivo de um ponto de interrogação após um tipo (por exemplo: int? MyVariable)?

Normalmente, o principal uso do ponto de interrogação é para o condicional x ? "yes" : "no",.

Mas vi outro uso para ele, mas não consigo encontrar uma explicação sobre esse uso do ?operador, por exemplo.

public int? myProperty
{
   get;
   set;
}

Isso significa que o tipo de valor em questão é um tipo anulável

Tipos anuláveis ​​são instâncias da estrutura System.Nullable. Um tipo anulável pode representar o intervalo correto de valores para seu tipo de valor subjacente, além de um valor nulo adicional. Por exemplo, um Nullable<Int32>, pronunciado "Anulável de Int32", pode ser atribuído a qualquer valor de -2147483648 a 2147483647, ou o valor nulo. A Nullable<bool>pode ser atribuído aos valores true, false ou null. A capacidade de atribuir nulo a tipos numéricos e booleanos é especialmente útil quando você está lidando com bancos de dados e outros tipos de dados que contêm elementos aos quais não pode ser atribuído um valor. Por exemplo, um campo booleano em um banco de dados pode armazenar os valores verdadeiro ou falso, ou pode 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);
      }
  }
}

É uma abreviação de Nullable<int>. Nullable<T>é usado para permitir que um tipo de valor seja definido como null. Tipos de valor geralmente não podem ser nulos .

No

x ? "yes" : "no"

o ? declara uma sentença if . Aqui: x representa a condição booleana; A parte antes de : é a sentença then e a parte depois é a sentença else .

Por exemplo,

int?

o ? declara um tipo anulável e significa que o tipo anterior a ele pode ter um valor nulo.

Tipos Anuláveis

Tipos anuláveis ​​são instâncias da estrutura System.Nullable. Um tipo anulável pode representar o intervalo normal de valores para seu tipo de valor subjacente, além de um valor nulo adicional . Por exemplo, um [ Nullable<Int32>], pronunciado "Anulável de Int32", pode ser atribuído a qualquer valor de -2147483648 a 2147483647 ou pode ser atribuído ao valor nulo. A [ Nullable<bool>] pode ser atribuído aos valores verdadeiro ou falso ou nulo. A capacidade de atribuir nulo a tipos numéricos e booleanos é particularmente útil ao lidar com bancos de dados e outros tipos de dados que contêm elementos que podem não ter um valor atribuído. Por exemplo, um campo booleano em um banco de dados pode armazenar os valores verdadeiro ou falso, ou pode ser indefinido.

declara que o tipo é anulável.

uso prático:

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

  return someFunctionThatHandlesIntAndReturnsString(value);
}

Para adicionar as respostas acima, aqui está um exemplo 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;
    }
}

Isso daria um erro de compilação:

Erro 12 Não é possível converter nulo em 'Teste' porque é um tipo de valor não anulável

Observe que não há erro de compilação para NullableTest. (observe o? na declaração de t2)

int?é uma abreviação de Nullable<int>. As duas formas são intercambiáveis.

Nullable<T>é um operador que você pode usar com um tipo de valor Tpara fazê-lo aceitar null.

No caso de você não sabe: valor tipos são tipos que aceita valores como int, bool, charetc ...

Eles não podem aceitar referências a valores: eles gerariam um erro em tempo de compilação se você atribuir a eles um null, em oposição aos tipos de referência , que obviamente podem aceitá-lo.

Por que você precisaria disso? Às vezes, suas variáveis ​​de tipo de valor podem receber referências nulas retornadas por algo que não funcionou muito bem, como uma variável ausente ou indefinida retornada de um banco de dados.

Eu sugiro que você leia a documentação da Microsoft, pois cobre muito bem o assunto.