C＃如何在对象构造后执行代码（后构造）

Question

正如您在下面的代码中看到的，DoStuff（）方法在构造一个Child对象期间在Init（）之前被调用。

我现在处于一个有许多孩子班的情况。因此，在每个子的构造函数中直接在Init（）之后重复调用DoStuff（）方法并不是一个优雅的解决方案。

有没有什么办法可以在父类中创建某种类型的构造函数，并在子构造函数之后执行？这样，我可以在那里调用DoStuff（）方法。

如果您有任何其他的设计理念可以解决我的问题，我也想听听！

abstract class Parent 
{ 
    public Parent() 
    { 
     DoStuff(); 
    } 

    protected abstract void DoStuff(); 
} 

class Child : Parent 
{ 
    public Child() 
    // DoStuff is called here before Init 
    // because of the preconstruction 
    { 
     Init(); 
    } 

    private void Init() 
    { 
     // needs to be called before doing stuff 
    } 

    protected override void DoStuff() 
    { 
     // stuff 
    } 
} 

Answer 1

如何：

abstract class Parent 
{ 
    public Parent() 
    { 
     Init(); 
     DoStuff(); 
    } 

    protected abstract void DoStuff(); 
    protected abstract void Init(); 
} 

class Child : Parent 
{ 
    public Child() 
    { 
    } 

    protected override void Init() 
    { 
     // needs to be called before doing stuff 
    } 

    protected override void DoStuff() 
    { 
     // stuff 
    } 
} 

Answer 2

如果您对您构建一个对象复杂的逻辑，然后再考虑FactoryMethod模式。

在你的情况我会实现它作为一个简单的

public static Parent Construct(someParam) 

方法需要一些参数，并在此基础上决定实例化哪个子类。 您可以从构造函数中删除DoStuff()方法调用，并在新实例的Construct()中调用它。

此外，您应该避免在构造函数中调用虚拟/抽象方法。看到这个问题的更多细节：Virtual member call in a constructor

Answer 3

更正：每this answer作为，你不能确定建设的子类时的基类的构造函数被调用时。

E.g.这不起作用：

所以，是的，正如其他人所指出的，如果事件的顺序很重要，那么基类需要能够通过声明，以抽象的方式，或以适应（更好的）通过让子类实现DoStuff代表事件序列：

protected override void DoStuff() 
{ 
    Init(); 
    base.DoStuff(); 
} 

Answer 4

DoStuff是抽象的。只需调用DoStuff顶部的Init即可。

Answer 5

而不是使用abstract方法，它会要求你实现所有子类的方法，你可以尝试：

public class Parent 
{ 
    public Parent() 
    { 
     PostConstructor(); 
    } 


    protected virtual void PostConstructor() 
    { 
    } 
} 

public class Child : Parent 
{ 
    protected override void PostConstructor() 
    { 
     base.PostConstructor(); 

     /// do whatever initialization here that you require 
    } 
} 

public class ChildWithoutOverride 
{ 
    /// not necessary to override PostConstructor 
} 

Answer 6

我会强烈建议使用工厂像一个模式。

如果这是可能的：

。将所有孩子和抽象类别推入单独的程序集。

。像内部方法一样声明孩子的名字，所以没有人可以通过调用ctor来构造它们。

。实现Factory类来构造调用者指定的对象类型，在实际创建一个对象之后，但在将它返回给调用者之前，这种类型将会抽象调用抽象的DoStuff（）方法。

好东西关于这个：它会给你更多的抽象层次，所以如果将来你需要一些更多的函数调用或任何其他类型的逻辑复杂度，你将需要的只是将它们添加到您的Factory类中。

也就是说。

问候

Answer 7

在WPF应用程序，你可以用Dispatcher帮助推迟DoStuff()的invokation：

abstract class Parent 
{ 
    public Parent() 
    { 
     Dispatcher.CurrentDispatcher.BeginInvoke(new Action(this.DoStuff)); 
    } 

    private void DoStuff() 
    { 
     // stuff, could also be abstract or virtual 
    } 
} 

但是，它不能保证DoStuff()将构造后立即调用。

Answer 8

正如其他人所说，你应该使用工厂模式。

public class Parent 
{ 
    public Parent() 
    {    
    } 

    public virtual void PostConstructor() 
    { 
    } 
} 

public class Child : Parent 
{ 
    public override void PostConstructor() 
    { 
     base.PostConstructor(); 

     // Your code here 
    } 
} 

public void FactoryMethod<T>() where T : Parent 
{ 
    T newobject = new T(); 
    newobject.PostConstructor(); 
} 

Answer 9

让我来介绍一个使用一些C＃特性的通用解决方案。请注意，此解决方案不需要在构造对象后使用工厂模式或调用任何模式，并且它仅适用于任何类，只需使用单一方法实现接口即可。 首先声明我们的类将有一个接口来实现：

public interface IInitialize { 
    void OnInitialize(); 
} 

接下来我们添加静态扩展类此接口，并添加初始化方法：

public static class InitializeExtensions 
{ 
    public static void Initialize<T>(this T obj) where T: IInitialize 
    { 
     if (obj.GetType() == typeof(T))  
      obj.OnInitialize(); 
    } 
} 

现在，如果我们需要一个类及其所有后代在对象完全构建后立即调用初始化方法，我们需要做的就是执行IInitialize并在构造函数中追加一行：

public class Parent : IInitialize 
{ 
    public virtual void OnInitialize() 
    { 
     Console.WriteLine("Parent"); 
    } 

    public Parent() 
    { 
     this.Initialize(); 
    } 
} 

public class Child : Parent 
{ 
    public Child() 
    { 
     this.Initialize(); 
    } 

    public override void OnInitialize() 
    { 
     Console.WriteLine("Child"); 
    } 
} 

public class GrandChild : Child 
{ 
    public GrandChild() 
    { 
     this.Initialize(); 
    } 

    public override void OnInitialize() 
    { 
     Console.WriteLine("GrandChild"); 
    } 
} 

诀窍是当一个派生类调用扩展方法Initialize时，这将抑制任何不是来自实际类的调用。