如何组合派生类及其基类中命名相似的嵌套类

Question

我正在从事一个小项目，我在该项目中为系统创建了附加组件的标准实现。这些标准实现将以统一的方式设置日志记录、配置等。所有这些都考虑到了可维护性和可重用性。

现在我正在努力解决的问题是如何处理设置名称。在我总是创建一个嵌套类 Settings 之前，我声明了一些 const 字符串值，例如

public const string BananaSetting = "BananaSetting";

所以我几乎再也不会拼错设置的名称了。

然而，我有一个基类，它应该有一个名为 DEBUG 的设置，用作通用调试启用设置；还有附加组件特定的设置，这些设置只存在于那个特定的附加组件中。 看到我将每个派生类都基于具有 DEBUG 设置嵌套类的类，任何试图声明类似嵌套类的派生类称为Settings 将触发编译器警告：

DerivedClass.Settings 隐藏继承的成员“BaseClass.Settings”。如果要隐藏，请使用 new 关键字。

但我不想隐藏它。我真正想做的是将两个设置类合二为一。有没有办法做到这一点，或者是否有某种现有的设计模式可以正确地做到这一点？

public abstract class BaseClass
{
    public class Settings
    {
        public const string BananaSetting = "BananaSetting";
    }

    public abstract void BaseAbstractMethod();
    public void BaseMethod()
    {
        // intended use
        var settingValue = settingsDictionary[Settings.BananaSetting];
    }
}

public class DerivedClass : BaseClass
{
    public class Settings
    {
        public const string DerivedBananaSetting = "DerivedBananaSetting";
    }

    public override void BaseAbstractMethod()
    {
        // intended use
        var settingValue = settingsDictionary[Settings.BananaSetting];
        var subSettingValue = settingsDictionary[Settings.DerivedBananaSetting];
    }
}

Answer 1

您需要在派生类new 中创建设置类，因为它与基类中的名称相同。为了能够访问派生类中的基本设置，您还需要继承嵌套设置类：

public class DerivedClass : BaseClass
{
    public new class Settings : BaseClass.Settings
    {
        public const string DerivedBananaSetting = "DerivedBananaSetting";
    }
// etc..

你的代码的其余部分没有改变。

Answer 2

怎么样。像这样：

public abstract class SettingBase
{
     public abstract string GetSettingName();

     public abstract SettingBase GetSetting();

     //Shared Properties and Stuff here:
}

public class BananaSetting : SettingBase
{
     public override string GetSettingName()
     {
         return nameof(BananaSetting);
     }

     public override SettingBase GetSetting()
     {
         return this;
     }

     //Banana-Specific Settings go here
}

public class DEBUGSetting : SettingBase
{
     public override string GetSettingName()
     {
         return nameof(DEBUGSetting);
     }

     public override SettingBase GetSetting()
     {
         return this;
     }

     //DEBUG-Specific Settings go here
}


public class Program
{
     public void Demo()
     {
         var settings = LoadSettings();
         foreach(var setting in settings)
         {
             var implementation = setting.GetSetting();
             if(implementation is DEBUGSetting dbg)
             {
                 //access dbg.Properties here
             }
             [...]
         }
     }
}

Answer 3

如果我理解正确，您想通过更多设置扩展基类：

public class SettingBase
{
     public SettingDerived()
     {
         _settingNamesWithValues.Add("BananaSetting", new object());
     }

    private Dictionairy<string, object> _settingNamesWithValues = new Dictionairy<string, object>();

    public Dictionairy<string, object>() SettingNamesWithValues
    {
         get
         { 
            return _settingNameWithValue;
         }
    }
}

派生类：

public class SettingDerived : SettingBase
{
     public SettingDerived()
     {
         _settingNamesWithValues.Add("DerivedBananaSetting", new object());
     }

     private Dictionairy<string, object> _settingNamesWithValues = new Dictionairy<string, object>(); 

     //Hide the base SettingNamesWithValues, as we add the values to the derived collection anyways
     public new Dictionairy<string, object>() SettingNamesWithValues
     {
         get
         { 
            foreach(var keyValue in base.SettingNamesWithValues)
            {
                 _settingNameWithValue.Add(keyValue.Key, keyValue.Value);
            }                  
            return _settingNameWithValue;
         }
     }
}

然后您可以使用他们的名字访问所有设置。

var derived = new SettingsDerived();
var derivedBanana = derived.SettingNamesWithValues["DerivedBananaSetting"];
var banana = derived.SettingNamesWithValues["BananaSetting"];

Answer 4

是否需要将它们放在子类中？您可以通过以下方式轻松实现目标：

public abstract class BaseClass
{
    public const string BananaSetting = "BananaSetting";

    public abstract void BaseAbstractMethod();
    public void BaseMethod()
    {
    }
}

public class DerivedClass : BaseClass
{
    public const string DerivedBananaSetting = "DerivedBananaSetting";

    public override void BaseAbstractMethod()
    {
    }
}