Detectar excepciones con "catch, when"

Encontré esta nueva característica en C # que permite que se ejecute un controlador de captura cuando se cumple una condición específica.

int i = 0;
try
{
    throw new ArgumentNullException(nameof(i));
}
catch (ArgumentNullException e)
when (i == 1)
{
    Console.WriteLine("Caught Argument Null Exception");
}

Estoy tratando de entender cuándo esto puede ser útil.

Un escenario podría ser algo como esto:

try
{
    DatabaseUpdate()
}
catch (SQLException e)
when (driver == "MySQL")
{
    //MySQL specific error handling and wrapping up the exception
}
catch (SQLException e)
when (driver == "Oracle")
{
    //Oracle specific error handling and wrapping up of exception
}
..

pero esto es nuevamente algo que puedo hacer dentro del mismo controlador y delegar a diferentes métodos dependiendo del tipo de controlador. ¿Esto hace que el código sea más fácil de entender? Podría decirse que no.

Otro escenario en el que puedo pensar es algo como:

try
{
    SomeOperation();
}
catch(SomeException e)
when (Condition == true)
{
    //some specific error handling that this layer can handle
}
catch (Exception e) //catchall
{
    throw;
}

De nuevo, esto es algo que puedo hacer como:

try
{
    SomeOperation();
}
catch(SomeException e)
{
    if (condition == true)
    {
        //some specific error handling that this layer can handle
    }
    else
        throw;
}

¿El uso de la función 'atrapar, cuando' hace que el manejo de excepciones sea más rápido porque el controlador se omite como tal y el desenrollado de la pila puede ocurrir mucho antes en comparación con el manejo de casos de uso específicos dentro del controlador? ¿Existen casos de uso específicos que se ajusten mejor a esta función y que las personas puedan adoptar como una buena práctica?

Los bloques de captura ya le permiten filtrar por el tipo de excepción:

catch (SomeSpecificExceptionType e) {...}

La whencláusula le permite extender este filtro a expresiones genéricas.

Por lo tanto, usa la whencláusula para los casos en los que el tipo de excepción no es lo suficientemente distinto para determinar si la excepción debe manejarse aquí o no.

Un caso de uso común son los tipos de excepción, que en realidad son un contenedor para múltiples tipos de errores diferentes.

Aquí hay un caso que realmente he usado (en VB, que ya tiene esta función durante bastante tiempo):

try
{
    SomeLegacyComOperation();
}
catch (COMException e) when (e.ErrorCode == 0x1234)
{
    // Handle the *specific* error I was expecting. 
}

Lo mismo para SqlException, que también tiene una ErrorCodepropiedad. La alternativa sería algo así:

try
{
    SomeLegacyComOperation();
}
catch (COMException e)
{
    if (e.ErrorCode == 0x1234)
    {
        // Handle error
    }
    else
    {
        throw;
    }
}

que es posiblemente menos elegante y rompe ligeramente el rastro de la pila .

Además, puede mencionar el mismo tipo de excepción dos veces en el mismo bloque try-catch:

try
{
    SomeLegacyComOperation();
}
catch (COMException e) when (e.ErrorCode == 0x1234)
{
    ...
}
catch (COMException e) when (e.ErrorCode == 0x5678)
{
    ...
}

lo que no sería posible sin la whencondición.

De la wiki de Roslyn (el énfasis es mío):

Los filtros de excepción son preferibles a la captura y el relanzamiento porque dejan la pila ilesa . Si la excepción hace que la pila se vuelque más tarde, puede ver de dónde vino originalmente, en lugar de solo el último lugar donde se volvió a lanzar.

También es una forma común y aceptada de "abuso" utilizar filtros de excepción para los efectos secundarios; por ejemplo, tala. Pueden inspeccionar una excepción "volando" sin interceptar su curso . En esos casos, el filtro a menudo será una llamada a una función auxiliar de retorno falso que ejecuta los efectos secundarios:

private static bool Log(Exception e) { /* log it */ ; return false; }

… try { … } catch (Exception e) when (Log(e)) { }

Vale la pena demostrar el primer punto.

static class Program
{
    static void Main(string[] args)
    {
        A(1);
    }

    private static void A(int i)
    {
        try
        {
            B(i + 1);
        }
        catch (Exception ex)
        {
            if (ex.Message != "!")
                Console.WriteLine(ex);
            else throw;
        }
    }

    private static void B(int i)
    {
        throw new Exception("!");
    }
}

Si ejecutamos esto en WinDbg hasta que se alcance la excepción, e imprimimos la pila usando !clrstack -i -a, veremos solo el marco de A:

003eef10 00a7050d [DEFAULT] Void App.Program.A(I4)

PARAMETERS:
  + int i  = 1

LOCALS:
  + System.Exception ex @ 0x23e3178
  + (Error 0x80004005 retrieving local variable 'local_1')

Sin embargo, si cambiamos el programa para usar when:

catch (Exception ex) when (ex.Message != "!")
{
    Console.WriteLine(ex);
}

Veremos que la pila también contiene Bel marco de:

001af2b4 01fb05aa [DEFAULT] Void App.Program.B(I4)

PARAMETERS:
  + int i  = 2

LOCALS: (none)

001af2c8 01fb04c1 [DEFAULT] Void App.Program.A(I4)

PARAMETERS:
  + int i  = 1

LOCALS:
  + System.Exception ex @ 0x2213178
  + (Error 0x80004005 retrieving local variable 'local_1')

Esa información puede ser muy útil al depurar volcados por caída.

Cuando se lanza una excepción, el primer paso del manejo de excepciones identifica dónde se detectará la excepción antes de desenrollar la pila; si / cuando se identifica la ubicación "captura", todos los bloques "finalmente" se ejecutan (tenga en cuenta que si una excepción escapa de un bloque "finalmente", el procesamiento de la excepción anterior puede abandonarse). Una vez que eso suceda, el código reanudará la ejecución en la "captura".

Si hay un punto de interrupción dentro de una función que se evalúa como parte de un "cuándo", ese punto de interrupción suspenderá la ejecución antes de que ocurra cualquier desenrollado de la pila; por el contrario, un punto de interrupción en una "captura" solo suspenderá la ejecución después de que se finallyhayan ejecutado todos los controladores.

Finalmente, si las líneas 23 y 27 de la foollamada bar, y la llamada en la línea 23 arroja una excepción que se foodetecta dentro y se vuelve a lanzar en la línea 57, el seguimiento de la pila sugerirá que la excepción ocurrió mientras se llamaba bardesde la línea 57 [ubicación de la repetición] , destruyendo cualquier información sobre si la excepción ocurrió en la llamada de la línea 23 o la línea 27. Usar whenpara evitar detectar una excepción en primer lugar evita tal perturbación.

Por cierto, un patrón útil que es molestamente incómodo tanto en C # como en VB.NET es usar una llamada de función dentro de una whencláusula para establecer una variable que se puede usar dentro de una finallycláusula para determinar si la función se completó normalmente, para manejar casos en los que una función no tiene esperanzas de "resolver" ninguna excepción que se produzca, pero, no obstante, debe tomar medidas basadas en ella. Por ejemplo, si se lanza una excepción dentro de un método de fábrica que se supone que devuelve un objeto que encapsula recursos, cualquier recurso que se adquirió deberá liberarse, pero la excepción subyacente debería filtrarse hasta el llamador. La forma más limpia de manejar eso semánticamente (aunque no sintácticamente) es tener unfinallybloquear compruebe si se produjo una excepción y, de ser así, libere todos los recursos adquiridos en nombre del objeto que ya no se devolverá. Dado que el código de limpieza no tiene ninguna esperanza de resolver la condición que causó la excepción, realmente no debería catchhacerlo, solo necesita saber qué sucedió. Llamar a una función como:

bool CopySecondArgumentToFirstAndReturnFalse<T>(ref T first, T second)
{
  first = second;
  return false;
}

dentro de una whencláusula hará posible que la función de fábrica sepa que sucedió algo.