código de repetición: Llamar a funciones con un poco diferentes firmas

Question

Supongamos que tengo dos funciones que se parecen a esto:

public static void myFunction1(int a, int b, int c, string d) 
{ 
    //dostuff 
    someoneelsesfunction(c,d); 
    //dostuff2 
} 

public static void myFunction2(int a, int b, int c, Stream d) 
{ 
    //dostuff 
    someoneelsesfunction(c,d); 
    //dostuff2 
} 

¿Cuál sería una buena manera de evitar hacerTarea repetida?

ideas que he pensado, pero no me gustan:

1. que podría hacer d un objeto y fundido en RUNTYPE en función del tipo, pero esto me parece no ser ideales; elimina una comprobación de tipo que estaba ocurriendo previamente en el momento de la compilación.
2. También podría escribir una clase auxiliar privada que tome un objeto y escriba ambas firmas como funciones públicas.
3. Podría reemplazar dostuff y dostuff2 con delegados o llamadas a funciones o algo así.

Answer 1

yo podría hacer algo como esto:

public static void myFunction1(int a, int b, int c, string d) 
{ 
    //dostuff 
    someoneelsesfunction(c, d); 
    //dostuff2 
} 

public static void myFunction2(int a, int b, int c, Stream d) 
{ 
    string str = d.ReadEntireString(); // no such method, but basically 
     // whatever you need to do to read the string out of the stream 
    myFunction1(a, b, c, str);  
} 

... y cambiar el nombre de las dos funciones a MyFunction (para tomar ventaja de la sobrecarga, lo que es lo mismo que está haciendo someoneelsesfunction()

. NOTA: esta solución no sería práctica si la cadena contenida en Stream es descomunal. De ser así, es posible que desee hacerlo al revés: lea la cadena d en una secuencia y llame a la anulación con el parámetro de secuencia

Answer 2

Simplemente refactorice "doStuff" y "doStuff2" en métodos separados.

Obviamente están haciendo "cosas" que están separadas del método "someoneelsesfunction", por lo que deben ser métodos separados de todos modos. Cada método debería tener una tarea, idealmente.

Esto es incluso una refactorización admitida en Visual Studio: simplemente resalte el código en "dostuff", y haga clic con el botón secundario, y elija Refactorizar -> Extraer método.

Answer 3

Comenzaré extrayendo los métodos DoStuff y DoStuff2 y llamándolos desde ambas funciones.

Podrías empezar a obtener funky envolviendo el bloque en otro método y pasando la función de alguien a usar para ese método, pero eso es un paso demasiado lejos. desea que las cosas sean fáciles de leer y cambiar, y que no contengan repetición.

Answer 4

Eventualmente puede crear

public static void myFunction3(int a, int b, int c, Stream d, string e) 

que se llamará a partir function1 y function2 con juego de D o E en nulo. Entonces function3 distinguiría entre llamadas a la función de alguien (c, d). Es una solución posible, pero para desesperados :)

Answer 5

Utilice Action para personalizar lo que hace una función en un lugar específico.

public void myF1(int a, int b, int c, int d) 
{ 
    internalF(a, b, { someelse1(c, d); }); 
} 
public void myF2 (int a, int b, int c, Stream d) 
{ 
    internalF(a, b, { someelse2(c, d); }); 
} 
private void internalF (int a, int b, Action action) 
{ 
    // dostuff 
    action(); 
    // dostuff2 
}