Fuerza para llamar a un método de la clase padre cuando se invoca el método de la clase infantil - C# .NE

Question

tenemos dos clases decir 'Padre' y 'niño', como se muestra a continuación:

class Parent 
{ 
    parent_AddUser() 
    { 
     // add user code for parent 
    } 

    abstract child_AddUser(); 
} 

// child class 
class Child : Parent 
{ 
    child_AddUser()  // implementing the abstract method 
    { 
    // child addUser code 
    } 
} 

Nos gustaría saber si podemos forzar la invocación del método parent_AddUser() siempre que invoque child_addUser() sin hacer una llamada explícita.

Answer 1

No, no hay forma de hacerlo. Deberá agregar una llamada a parent_AddUser en child_AddUser.

---

Puede hacer algo similar, utilizando el Patrón de método de plantilla.

public abstract class Parent { 
    public void AddUser(User user) { 
     // Do parent stuff 
     AddUserImpl(user); 
     // More parent stuff 
    } 

    protected abstract void AddUserImpl(User user); 
} 

public class Child { 
    protected override void AddUserImpl(User user) 
    { 
     // Do child stuff 
    } 
} 

Answer 2

Por lo que yo sé, esto no es posible. Pero lo que puedes hacer es usar el Template Method pattern.

Answer 3

sí es posible así con arround del trabajo como éste

class Parent { parent_AddUser() { // add user code for parent 

} 

protected virtual child_AddUser(){ 
//does smethins 
} 
} 


class Child: Parent 
{ 
protected override child_AddUser() 
{ 
// does something 
base.child_AddUser(); 
} 
} 

Answer 4

La manera de hacer esto es utilizar el template method pattern lugar:

public abstract class Parent 
{ 
    public void AddUser() 
    { 
     // Preparation goes here 
     AddUserImpl(); 
     // Clean-up goes here 
    } 

    protected abstract void AddUserImpl(); 
} 

public class Child 
{ 
    protected override void AddUserImpl() 
    { 
     // Do stuff here 
    } 
} 

De esa manera nadie que no sea Parent llamadas AddUserImpl - las personas que llaman simplemente usan AddUser que delega en la subclase concreta solo por el bit correcto.

Answer 5

usted tiene que hacer child_Adduser no pública y añadir un tercer método que controla toda la acción complemento de usuario:

class Parent 
{ 
    private void parent_Adduser() 
    { 
     // ... 
    } 

    protected abstract void child_Adduser(); 

    public void Adduser() 
    { 
     parent_Adduser(); 
     child_Adduser(); 
    } 
} 

class Child 
{ 
    protected override void child_Adduser() 
    { 
     // ... 
    } 
} 

esta manera, cuando Adduser() se llama siempre tanto se ejecuta la parte de los padres y el niño.

Answer 6

Si desea aplicar la lógica en la clase de niño, entonces algo así como:

class Parent 
{ 
    public void AddUser() 
    { 
     // pre-logic here 
     AddUserCore(); 
     // post-logic here 
    } 

    protected abstract void AddUserCore(); 
} 

// child class 
class Child : Parent 
{ 
    protected override void AddUserCore() 
    { 
    // child addUser code 
    } 
} 

Entonces no hay necesidad de llamar a los métodos de los padres; ya realizado en "pre-lógica" y "post-lógica"

Answer 7

Se podría hacer algo como:

class Parent 
{ 
    parent_AddUser() 
    {  // add user code for parent }  

    public child_AddUser() 
    { 
     this.parent_AddUser(); 
     this.doChildAddUser(); 
    } 

    protected abstract doChildAddUser(); 
} 

// child class 
class Child : Parent 
{ 
    doChildAddUser()  // implementing the abstract method 
    {  // child addUser code  } 
}