C# - ¿Es posible reemplazar un método en una clase base dentro de la misma clase (NO una clase derivada)?

Question

Según tengo entendido, es posible anular un método (marcado como Virtual) en una clase base de una clase derivada utilizando las palabras clave override.

¿Pero qué hay sobre anulando un método en la misma clase?

En mi caso específico tengo una clase x con 2 métodos. El método a tiene un comportamiento común con b, y b agrega funcionalidad al método a.

En el pasado he duplicado el código de a en b y he agregado la nueva funcionalidad en b.

Me gustaría saber si hay un mejor enfoque para poder centralizar el comportamiento del método a.

public class x 
    { 
     public static void a() {} 
     public static void b() {}   
    } 

Gracias por su tiempo :-)!

Answer 1

Simplemente puede llamar a su método a() desde su método b(). No es necesario (y no hay forma) de anular un método.

public class x 
{ 
    private static int _i = 0; 

    public static void a() { 
     _i = 1; 
    } 
    public static void b() { 
     a(); 
     // here is _i = 1; 
    }   
} 

Por otra parte usted podría tener sobrecargas de parámetros para su método.

public class x 
{ 
    private static int _i = 0; 

    public static void a() { 
     a(1); 
    } 
    public static void a(int i) { 
     _i = t; 
     // common code which can use _i 
    }   
} 

En este caso se puede llamar a(1) o a() con el mismo resultado.

Answer 2

No puede anular en la misma clase, solo lo hace en la clase derivada. Puede poner el comportamiento común de su método en el método a y luego llamarlo desde el método b.

public static void a() 
{ 
// some common functionality 
} 

public static void b() 
{ 
// do something 
a(); //call a 
//do something else 
} 

Usted es libre de llamar a desde dentro de b tantas veces como sea necesario.

Answer 3

Divide la parte común en un tercer método compartido pero privado.

Answer 4

¿Por qué no simplemente llama al a() desde b()?

public static void b() 
{ 
    // Do some stuff 
    a(); // Do the common stuff 
    // Do more stuff 
} 

Answer 5

Si entiendo correctamente su problema es que el método b tiene el mismo código que el método a más un poco más de código.Algo así como

public class x 
{ 
    public void a() 
    { 
     // a code 
    } 

    public void b() 
    { 
     // a code 

     // b code 
    } 
} 

si ese es el caso, se podría llamar el método A del método B de la siguiente

class x 
{ 
    public void a() 
    { 
     // a code 
    } 

    public void b() 
    { 
     a(); 

     // b code 
    } 
} 

El otro caso es que tiene código común a ambos métodos:

class x 
{ 
    public void a() 
    { 
     // common code 

     // a exclusive code 
    } 

    public void b() 
    { 
     // common code 

     // b exclusive code 
    } 
} 

Luego puede extraer ese código a otro método como este:

class x 
{ 
    public void a() 
    { 
     CommonMethod(); 

     // a exclusive code 
    } 

    public void b() 
    { 
     CommonMethod(); 

     // b exclusive code 
    } 

    private void CommonMethod() 
    { 
     // common code 
    } 
} 

Y sobre reemplazar un método en la misma clase. Se llama method overloading pero funciona, lo que le permite crear varios métodos con el mismo nombre que difieren entre sí en términos del tipo de entrada.

gusta esta

class x 
{ 
    public string a(int i) 
    { 
    } 

    public string a(string s) 
    { 
    } 
} 

La única restricción es que los métodos deben tener el mismo tipo de retorno (cadena en este ejemplo).

Answer 6

Para mi comprensión, es posible Anular un método (marcado como Virtual) en una clase base de una clase derivada utilizando la sustitución de palabras clave. Pero, ¿qué pasa con el mismo método anulado en la misma clase?

No puede hacer esto. Los métodos virtuales son para Polymorphism, que es una forma elegante de decir:

Si escribe un método que toma una clase base, y le pasa una clase derivada, y ese método llama a un método en la clase base, será En realidad, llama a la implementación derivada.

class A 
{ 
    public virtual void DoSomething() { Console.WriteLine("From A"); } 
} 

class B : A 
{ 
    public override void DoSomething() { Console.WriteLine("From B"); } 
} 

class C 
{ 
    public void DoSomethingMagic(A someClassInstance) 
    { 
     someClassInstance.DoSomething(); 
    } 
} 

class Program 
{ 
    public static void Main(string[] args) 
    { 
     A a = new A(); 
     B b = new B(); 
     C c = new C(); 
     c.DoSomethingMagic(a); // Prints "From A" 
     c.DoSomethingMagic(b); // Prints "From B", even though it takes an A 

     A bIsAnA = new B(); 
     c.DoSomethingMagic(bIsAnA); // Prints "From B", because B is also an A 
    } 
} 

Con esa definición, no tiene sentido tratar de "anular" un método dentro de la misma clase.

En mi caso específico tengo una Clase x con 2 métodos, el método a como un comportamiento común con b, y b agrega funcionalidad al método a.

Sólo tiene que llamar a() de b():

public class x 
{ 
    public static void a() 
    { 
     // "base" implementation here 
    } 

    public static void b() 
    { 
     a(); 
     // extra implementation here 
    } 
}