在构造函数中构造派生类属性而不调用虚拟成员

Question

我有一些嵌套类BaseOuter 和BaseInner，以及子类DerivedOuter 和DerivedInner。 BaseOuter 具有属性BaseInner baseInner;，当我实例化DerivedOuter 时，我希望baseInner 属性的运行时类型为DerivedInner。

我首先像下面这样解决了这个问题，使用虚拟初始化程序来实例化baseInner，它在DerivedOuter 中被覆盖。这使我可以在各自的初始化程序中执行 baseInner = new BaseInner(); 和 baseInner = new DerivedInner();。

在注意到Resharper warning 并执行little more reading 之后，我决定应该更改它...但是如何更改？

我想到了几件事。我可以在调用构造函数后调用初始化器，需要调用代码来做var baseOuter = new BaseOuter(); baseOuter.Initialize();。我可能可以使用工厂，但我必须考虑一下。最后，也许我想做的类嵌套存在设计缺陷？

值得指出的是，做new BaseInner(); 的成本很高，我不想简单地创建它并扔掉它。

using System;

public class Program
{
    public static void Main()
    {
        Console.WriteLine("new BaseOuter");
        var baseOuter = new BaseOuter();
        Console.WriteLine("\nnew DerivedOuter");
        var derivedOuter = new DerivedOuter();
    }

    class BaseOuter{
        protected BaseInner baseInner;
        public BaseOuter(){
            Console.WriteLine("BaseOuter Constructor");
            /*  lots of stuff I want in derived class */

            // This is an anti-pattern I want to avoid
            //https://www.jetbrains.com/help/resharper/2018.2/VirtualMemberCallInConstructor.html
            InitializeInner();
        }

        protected virtual void InitializeInner(){
            Console.WriteLine("    BaseOuter Initialize BaseInner");
            baseInner = new BaseInner();
        }

        protected class BaseInner{
            public int x;
            public BaseInner(){
                /* stuff that is needed in DerivedInner too */
                Console.WriteLine("        BaseInner Constructor");
                x = 2;
            }
        }       
    }

    class DerivedOuter : BaseOuter {
        public DerivedOuter() {
            Console.WriteLine("DerivedOuter Constructor (finished)");
        }

        protected override void InitializeInner(){
            Console.WriteLine("    DerivedOuter Initialize DerivedInner");
            baseInner = new DerivedInner();
        }

        protected class DerivedInner : BaseInner {
            public double y;
            public DerivedInner(){
            Console.WriteLine("        DerivedInner Constructor");
                y = 2d;
            }
        }
    }
}

输出

new BaseOuter
BaseOuter Constructor
    BaseOuter Initialize BaseInner
        BaseInner Constructor

new DerivedOuter
BaseOuter Constructor
    DerivedOuter Initialize DerivedInner
        BaseInner Constructor
        DerivedInner Constructor
DerivedOuter Constructor (finished)

所有代码都可以在这个.NET Fiddle中找到。

Answer 1

这是一种方法。

它在做同样的事情。区别在于派生类如何“覆盖”BaseInner 的实现。它通过向构造函数提供实现来实现。

internal class BaseOuter
{
    protected BaseInner baseInner;

    protected internal BaseOuter(BaseInner inner = null)
    {
        baseInner = inner ?? new BaseInner();
        Console.WriteLine("BaseOuter Constructor");
        /*  lots of stuff I want in derived class */

        // This is an anti-pattern I want to avoid
        //https://www.jetbrains.com/help/resharper/2018.2/VirtualMemberCallInConstructor.html

    }

    protected internal class BaseInner
    {
        public int x;

        public BaseInner()
        {
            /* stuff that is needed in DerivedInner too */
            Console.WriteLine("        BaseInner Constructor");
            x = 2;
        }
    }
}

internal class DerivedOuter : BaseOuter
{
    protected internal DerivedOuter()
     :base(new DerivedInner())
    {
        Console.WriteLine("DerivedOuter Constructor (finished)");
    }

    protected internal class DerivedInner : BaseInner
    {
        public double y;

        public DerivedInner()
        {
            Console.WriteLine("        DerivedInner Constructor");
            y = 2d;
        }
    }
}

如果你想进行全面的依赖注入，你可以从

中删除默认值

protected internal BaseOuter(BaseInner inner = null)

这意味着BaseOuter 将与BaseInner 的任何实现完全解耦。

其他一些建议：

• 除非有非常强烈的需要，否则我不会将类相互嵌套。它没有被大量使用，因此乍一看可能会让人感到困惑。
• 如果应该只在调用构造函数时设置baseInner，则将其标记为readonly。 （ReSharper 可能会建议这样做。）