Ok, entonces hice otra pregunta sobre el mismo temaaqu y aunque no obtuve una respuesta directa allí, reuní un código que trabajé para hacer lo que quería. La pregunta es, ¿de esta manera se rompe algún principio de OOP?

Lo que querí

Utilice la OOP adecuada para declarar tipos de fallas en un servicio Tenga un bloque de captura en el lado del cliente que pueda manejar múltiples tipos de excepciones lanzadas desde el servicio Tenga un método HandleException por clase de falla que tenga su propia implementaciónEn el lado del cliente, tenga solo un bloque de excepción, comprenda qué excepción se produjo y llame al método HandleException respectivo desde la clase de falla correspondiente

Cómo lo hice funcionar

Declarado un contrato de falla en el servidor para cada tipo de excepción que hereda de un tipo de excepción base

[DataContract]
public class BusinessRuleViolationFault : BaseFault
{
  public BusinessRuleViolationFault(string message)
  : base(message)
        {

        }
}

[DataContract]
public class SomeOtherViolationFault : BaseFault
{
    public SomeOtherViolationFault(string message)
        : base(message)
    {

    }
}

[DataContract]

public abstract class BaseFault

{

public BaseFault(string message)
{
  Message = message;
} 

}

En el lado del cliente, creé clases parciales de los mismos tipos de fallas que el anterior e implementé el método de excepción de manejo en él. Tenía que hacer esto en el lado del cliente, ya que si creaba este método en el lado del servicio, no se serializaría y estaría disponible a través del proxy.

public partial class BusinessRuleViolationFault : BaseFault
{

    public override void HandleException()
    {
        MessageBox.Show("BusinessRuleViolationFault handled");
    }
}



public partial class SomeOtherViolationFault : BaseFault
{

    public override void    HandleException()
    {
        MessageBox.Show("SomeOtherViolationFault handled");
    }
}


public abstract partial class BaseFault
{
    public abstract void HandleException();
}

Entonces creó un método de extensión en la clase faultexception según el código cristiano que marqué como respuesta aceptada en mi publicación anterior. Básicamente, esto utilizó la reflexión para obtener el nombre de la clase de excepción de error que se lanzó.

uego, en mi bloque catch de cliente, usé ese nombre para crear una instancia de la clase parcial creada localmente que tiene el método de excepción de manejo.

Lo que tengo curiosidad por saber es, ¿he roto algún principio de OOP aquí? ¿Es esta POO en absoluto?

No quiero múltiples declaraciones if else en este bloque catch o tener múltiples bloques catch. ¿Cuál es su opinión sobre la compensación de usar un bloque catch para ganar rendimiento y perderlo con la reflexión al tratar de averiguar qué método de clase llamar?

Gracias por su tiempo y paciencia ..