Recientemente, estaba discutiendo con otro programador la mejor manera de refactorizar un método enorme (1000 líneas) lleno de declaraciones "si".

El código está escrito en Java, pero creo que este problema también podría ocurrir en otros lenguajes como C #.

Para resolver este problema, sugirió usar un patrón de cadena de responsabilidad. Propuso tener una base de "Handler" de clase. Luego, "Handler1", "Handler2", etc. extendería "Handler".
Luego, los manejadores tendrían un método "getSuccessor", que devolvería el valor nulo (si fuera el último de la cadena) o el siguiente manejador de la cadena.
Luego, una función "handleRequest (Request)" trataría con Request, o la pasaría a la siguiente cadena y, si ninguna de las soluciones anteriores funcionaba, solo devolvería un valor nulo o lanzaría una excepción.
Para agregar un nuevo manejador a la cadena, el codificador iría al último elemento de la cadena y le diría que había un nuevo elemento. Para hacer algo, solo llamaría a handleRequest en el primer elemento de la cadena.

Para resolver este problema, sugerí usar un enfoque diferente.
También tendría una clase básica de "Manejador", con "Manejador1", "Manejador2", al igual que el método anterior mencionado.
Sin embargo, no habría ningún método "getSuccessor". En su lugar, tendría una clase de Colección con una lista de controladores (un Vector, un ArrayList, o lo que sea mejor en este caso).
La función handleRequest seguiría existiendo, pero no propagaría la llamada a los siguientes controladores. Simplemente procesaría la solicitud o devolvería el valor nulo.
Para manejar una solicitud, uno usaría

<code>for(Handler handle : handlers){
    result = handle.handleRequest(request);
    if(result!=null) return result;
}
throw new CouldNotParseRequestException(); //just like in the other approach
</code>

O, para evitar la duplicación de código, se puede agregar un método "parseRequest (request)" a la clase de colección. Para agregar un nuevo controlador, uno irá al constructor de la colección (o bloque estático {}, o algo equivalente) y simplemente agregará el código "addHandler (new Handler3 ());".

¿Exactamente qué ventajas de la cadena de responsabilidad estoy perdiendo con este enfoque? ¿Qué método es mejor (asumiendo que hayes un mejor método)? ¿Por qué? ¿Qué posibles errores y problemas pueden causar cada método de diseño?

Para aquellos que necesitan contexto, esto es lo que parecía el código original:

<code>if(x instanceof Type1)
{
//doSomething1
} else if(x instanceof Type2)
{
//doSomething2
}
//etc.
</code>