Cuál es el ?[]? sintaxis en C #?

Mientras estudiaba el delegado, que en realidad es una clase abstracta enDelegate.cs , vi el siguiente método en el que no entiendo

• Por qué se usa el valor de retorno ?aunque ya es una referencia ( clase )
• ?[]? significado en el parámetro

¿Podrías 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;
}

Explicación paso a paso:

params Delegate?[] delegates - Es una matriz de nulos Delegate

params Delegate?[]? delegates - Todo el conjunto puede ser anulable

Dado que cada parámetro es del tipo Delegate?y devuelve un índice de la Delegate?[]?matriz, tiene sentido que el tipo de retorno sea de lo Delegate?contrario el compilador devolvería un error como si estuviera retirándose y intde un método que devuelve una cadena.

Podría cambiar, por ejemplo, su código para devolver un 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 referencia anulables son nuevos en C # 8.0, no existían antes.

Es una cuestión de documentación y de cómo se producen las advertencias en tiempo de compilación.

La excepción "objeto no establecido en una instancia de un objeto" es bastante común. Pero esta es una excepción en tiempo de ejecución, ya se puede descubrir parcialmente en tiempo de compilación.

Para un regular Delegate dsiempre puedes llamar

 d.Invoke();

es decir, puede codificarlo, en el momento de la compilación no sucederá nada. Puede generar excepciones en tiempo de ejecución.

Mientras que para un nuevo Delegate? peste Código

 p.Invoke();

producirá una advertencia del compilador. CS8602: Dereference of a possibly null reference a menos que escribas:

 p?.Invoke();

lo que significa, llamar solo si no es nulo.

Entonces, documentar una variable puede contener nulo o no. Genera advertencias antes y puede evitar múltiples pruebas de nulo. ¿Lo mismo que tienes para int e int ?. Usted sabe con certeza, uno no es nulo, y sabe cómo convertir uno a otro.

En C # 8, uno debe marcar explícitamente los tipos de referencia como anulables.

Por defecto, esos tipos no pueden contener nulos, algo similares a los tipos de valor. Si bien esto no cambia la forma en que funcionan las cosas debajo del capó, el verificador de tipo requerirá que lo haga manualmente.

El código dado se refactoriza para funcionar con C # 8, pero no se beneficia de esta nueva característica.

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

Aquí hay un ejemplo de un código actualizado (que no funciona, solo una idea) que aprovecha esta característica. Nos salvó de una verificación nula y simplificó un poco este 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;
}