调用基构造函数时重用初始值设定项方法

Question

我想使用构造函数初始化派生类中的受保护成员，但由于我正在调用base（），我无法调用this（），这使得我的一些调用"有味道"：

public class ABase
    {
        public object Param1 { get; set; }
        public object Param2 { get; set; }
        protected object Param3 { get; set; }
        public ABase()
            : this(null, null)
        { }
        public ABase(object param1)
            : this(param1, null)
        { }
        public ABase(object param1, object param2)
        {
            Param1 = param1;
            Param2 = param2;
        }
    }
    public class A : ABase
    {
        public A()
        { InitParam3(); }
        public A(object param1)
            : base(param1)
        { InitParam3(); }
        public A(object param1, object param2)
            : base(param1, param2)
        { InitParam3(); }
        private void InitParam3()
        {
            Param3 = "param3";
        }
    }

有没有一种方法可以避免在每个构造函数中调用InitParam3()。我对设计的改变持开放态度。

Answer 1

使用子类的构造函数链，然后调用基类的最完整构造函数。

    public class ABase
        {
            public object Param1 { get; set; }
            public object Param2 { get; set; }
            protected object Param3 { get; set; }
            public ABase()
                : this(null, null)
            { }
            public ABase(object param1)
                : this(param1, null)
            { }
            public ABase(object param1, object param2)
            {
                Param1 = param1;
                Param2 = param2;
            }
        }
        public class A : ABase
        {
            public A() : this(null, null)
            { }
            public A(object param1)
                : this(param1m, null)
            { }
            public A(object param1, object param2)
                : base(param1, param2)
            { InitParam3(); }
            private void InitParam3()
            {
                Param3 = "param3";
            }
        }

UPDATE（删除默认值的重复）:

public abstract class ABase
{
    protected const object DefaultParam1 = null;
    protected const object DefaultParam2 = null;
    public object Param1 {get;set;}
    public object Param2 { get; set; }
    protected object Param3 { get; set; }
    public ABase(object param1 = DefaultParam1, object param2 = DefaultParam2)
    {
        Param1 = param1;
        Param2 = param2;
    }
}
public class A : ABase
{
    public A(object param1 = DefaultParam1, object param2 = DefaultParam2)
        : base(param1, param2)
    {
        Param3 = "param3";
    }       
}

Answer 2

否。

这是一个可以的解决方案。

lazybrezovsky方法的问题在于，派生类对参数的默认值进行了自己的假设，而它不得不将其留给超类。

超级类使用null来初始化，如果您更改决定使用null以外的其他默认值，则必须更改2个位置。

对我来说，决定默认值比微小的重复更重要