He leído algunas de las otras preguntas sobre las prácticas de manejo de excepciones de C #, pero ninguna parece preguntarme qué estoy buscando.

Si implemento mi propia excepción personalizada para una clase particular o un conjunto de clases. ¿Deberían encapsularse todos los errores relacionados con esas clases en mi excepción usando una excepción interna o debería dejarlos caer?

Estaba pensando que sería mejor detectar todas las excepciones para que la excepción pueda ser reconocida de inmediato por mi fuente. Todavía estoy pasando la excepción original como una excepción interna. Por otro lado, estaba pensando que sería redundante volver a lanzar la excepción.

Excepción:

class FooException : Exception
{
    //...
}

Opción 1: Foo encapsula todas las excepciones:

class Foo
{
    DoSomething(int param)
    {
        try 
        {
             if (/*Something Bad*/)
             {  
                 //violates business logic etc... 
                 throw new FooException("Reason...");
             }
             //... 
             //something that might throw an exception
        }
        catch (FooException ex)
        {
             throw;
        }
        catch (Exception ex)
        {
             throw new FooException("Inner Exception", ex);
        }
    }
}

Opción 2: Foo arroja FooExceptions específicas, pero permite que otras Excepciones caigan:

class Foo
{
    DoSomething(int param)
    {
        if  (/*Something Bad*/)
        {
             //violates business logic etc... 
             throw new FooException("Reason...");
        }
        //... 
        //something that might throw an exception and not caught
    }
}