Force eine Elternklasse-Methode aufrufen, wenn das Kind Klassenmethode aufgerufen wird - C# .NE

Question

Wir haben zwei Klassen sagen ‚Eltern‘ und ‚Kind‘, wie unten dargestellt:

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

Wir wissen möchten, ob Wir können den Aufruf der Methode parent_AddUser() erzwingen, wenn die Funktion child_addUser() aufgerufen wird, ohne explizit einen Aufruf auszuführen.

Answer 1

Nein, es gibt keine Möglichkeit, dies zu tun. Sie müssen einen Aufruf von parent_AddUser in child_AddUser hinzufügen.

---

Sie können etwas ähnliches tun, indem Sie das Template Method Pattern verwenden.

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

Soweit ich weiß, ist dies nicht möglich. Aber was Sie tun können, ist die Template Method pattern zu verwenden.

Answer 3

ja ist es möglich, wie dies mit der Arbeit nahe wie diese

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

Die Art und Weise, dies zu tun ist, um die template method pattern stattdessen zu verwenden:

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

auf diese Weise niemand anders als Parent Anrufe AddUserImpl - Anrufer verwenden einfach AddUser, die an die konkrete Unterklasse für genau das richtige Bit delegiert.

Answer 5

Sie haben child_Adduser nicht-öffentlich zu machen und eine dritte Methode hinzufügen, die die gesamte Add-Benutzeraktion steuert:

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

diese Weise, wenn Adduser() immer genannt wird, sowohl die Eltern und Kind Teil ausgeführt wird.

Answer 6

Wenn Sie Logik in der untergeordneten Klasse erzwingen, dann so etwas wie:

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

Dann brauchen die Eltern Methoden zu nennen; erfolgt bereits in „Pre-Logik“ und „post-Logik“

Answer 7

Sie etwas tun könnte, wie:

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