O que é ?[]? sintaxe em c #?

Enquanto estudava o delegado, que na verdade é uma classe abstrata Delegate.cs, vi o seguinte método no qual não entendo

• Por que o valor de retorno usa, ?embora já seja um tipo de referência ( classe )
• ?[]? significado no parâmetro

Você poderia explicar?

public static Delegate? Combine(params Delegate?[]? delegates)
{
    if (delegates == null || delegates.Length == 0)
        return null;

    Delegate? d = delegates[0];
    for (int i = 1; i < delegates.Length; i++)
        d = Combine(d, delegates[i]);

    return d;
}

Explicação passo a passo:

params Delegate?[] delegates - É uma matriz de anulável Delegate

params Delegate?[]? delegates - A matriz inteira pode ser anulável

Como cada parâmetro é do tipo Delegate?e você retorna um índice da Delegate?[]?matriz, faz sentido que o tipo de retorno seja o Delegate?contrário, o compilador retornaria um erro como se você estivesse pesquisando novamente e intde um método que retorne uma string.

Você pode alterar, por exemplo, seu código para retornar um Delegatetipo como este:

public static Delegate Combine(params Delegate?[]? delegates)
{
    Delegate defaulDelegate = // someDelegate here
    if (delegates == null || delegates.Length == 0)
        return defaulDelegate;

    Delegate d = delegates[0] ?? defaulDelegate;
    for (int i = 1; i < delegates.Length; i++)
        d = Combine(d, delegates[i]);

    return d;
}

Tipos de referência anuláveis são novos no C # 8.0, eles não existem antes.

É uma questão de documentação e como os avisos em tempo de compilação são produzidos.

A exceção "objeto não definido para uma instância de um objeto" é silenciosa e comum. Mas essa é uma exceção de tempo de execução, já pode ser parcialmente descoberta em tempo de compilação.

Para regular Delegate dvocê sempre pode ligar

 d.Invoke();

ou seja, você pode codificá-lo, em tempo de compilação nada acontecerá. Pode gerar exceções em tempo de execução.

Enquanto para um novo Delegate? peste Código

 p.Invoke();

produzirá um aviso do compilador. CS8602: Dereference of a possibly null reference a menos que você escreva:

 p?.Invoke();

o que significa, chame apenas se não for nulo.

Portanto, você documenta uma variável que pode conter nulo ou não. Ele gera avisos mais cedo e pode evitar vários testes para nulo. O mesmo que você tem para int e int ?. Você sabe com certeza que um não é nulo - e sabe como converter um para o outro.

No C # 8, deve-se marcar explicitamente os tipos de referência como nulos.

Por padrão, esses tipos não são capazes de conter nulos, um pouco semelhantes aos tipos de valor. Embora isso não mude o funcionamento das coisas, o verificador de tipos exigirá que você faça isso manualmente.

O código fornecido é refatorado para funcionar com o C # 8, mas não se beneficia desse novo recurso.

public static Delegate? Combine(params Delegate?[]? delegates)
{
    // ...[]? delegates - is not null-safe, so check for null and emptiness
    if (delegates == null || delegates.Length == 0)
        return null;

    // Delegate? d - is not null-safe too
    Delegate? d = delegates[0];
    for (int i = 1; i < delegates.Length; i++)
        d = Combine(d, delegates[i]);

    return d;
}

Aqui está um exemplo de um código atualizado (não funcionando, apenas uma idéia) aproveitando esse recurso. Ele nos salvou de uma verificação nula e simplificou um pouco esse método.

public static Delegate? Combine(params Delegate[] delegates)
{
    // `...[] delegates` - is null-safe, so just check if array is empty
    if (delegates.Length == 0) return null;

    // `d` - is null-safe too, since we know for sure `delegates` is both not null and not empty
    Delegate d = delegates[0];

    for (int i = 1; i < delegates.Length; i++)
        // then here is a problem if `Combine` returns nullable
        // probably, we can add some null-checks here OR mark `d` as nullable
        d = Combine(d, delegates[i]);

    return d;
}