Question

我们有两个班级说'父母'和'孩子'，如下所示：

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

我们想知道无论何时调用child_addUser（）而不进行显式调用，我们是否都可以强制调用parent_AddUser（）方法。

Answer 1

执行此操作的方法是使用template method pattern代替：

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

除了Parent调用AddUserImpl之外没有其他人 - 调用者只使用AddUser代表具体的子类来获得正确的位。

Answer 2

不，没有办法做到这一点。您需要在child_AddUser中添加对parent_AddUser的调用。

您可以使用模板方法模式执行类似操作。

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 3

据我所知，这是不可能的。但你可以做的是使用Template Method pattern。

Answer 4

是的，像这样可以解决这个问题

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 5

您必须使child_Adduser非公开，并添加第三个控制整个添加用户操作的方法：

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

这样，当调用Adduser()时，父元素和子元素都将被执行。

Answer 6

如果要在子类中强制执行逻辑，那么类似：

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

然后无需调用父方法;已经在“预逻辑”和“后逻辑”中完成了

Answer 7

您可以执行以下操作：

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

调用子类方法时强制调用父类方法 - C＃.NE

7 个答案: