Siła wywołać metodę klasy nadrzędnej, gdy metoda klasy dziecko jest wywoływana - C# .NE

Question

Mamy dwie klasy powiedzieć „macierzystego” i „dziecko”, jak pokazano poniżej:

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 
    } 
} 

Chcielibyśmy wiedzieć, czy możemy wymusić wywołanie metody parent_AddUser() za każdym razem, gdy wywoływana jest funkcja child_addUser() bez wywoływania jawnego.

Answer 1

Nie, nie ma sposobu, aby to zrobić. Będziesz musiał dodać połączenie do parent_AddUser w child_AddUser.

---

Możesz zrobić coś podobnego, używając Wzorca metody szablonów.

Answer 2

O ile mi wiadomo, nie jest to możliwe. Ale możesz zrobić to za pomocą Template Method pattern.

Answer 3

tak jest to możliwe jak to z pracą arround jak ten

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

Sposobem na to jest użycie template method pattern Zamiast:

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 
    } 
} 

ten sposób nikt inny niż Parent połączeń AddUserImpl - wywołujący po prostu używają AddUser, który deleguje do konkretnej podklasy tylko na właściwy bit.

Answer 5

Trzeba dokonać child_Adduser niepubliczne i dodać trzeci sposób, który steruje całą akcję add-user:

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() 
    { 
     // ... 
    } 
} 

ten sposób, gdy Adduser() nazywany jest zawsze zarówno rodzic i dziecko część jest wykonana.

Answer 6

Jeśli chcesz wymusić logikę w klasie dziecko, to coś jak:

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 
    } 
} 

to nie trzeba zadzwonić metody nadrzędnej; już zrobione w „pre-Logic” i „post-Logic”

Answer 7

Można zrobić coś takiego:

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  } 
}