为同一个名称空间扩展C＃类？

Question

How may I easily extend a C# class tohave an additional class for the same use? It may sound a bit weird but consider this:

ConfigurationManager is the main class in the Habbo_Hotel.assets namespace, and I've got two global variables called configuration (general) and configDatabase (database). This is how I'm using the general settings through the Program class:

assets.ConfigurationManager configurationManager = new 
assets.ConfigurationManager();
configurationManager.Init();

configurationManager.debug

Now, this is the simpliest use of the class, now I want to be able to call something like:

configurationManager.database.hostname

Instead of having a function called configurationManager.databaseHostname . If this is possible to do, how can I extend the C# class to have a .database class in its origin? Thanks.

using System;
using System.Xml;
using System.Collections.Generic;

namespace Habbo_Hotel.assets
{
    public class ConfigurationManager
    {
        private static Dictionary<string, string> configuration = new Dictionary<string, string>();
        private static Dictionary<string, string> configDatabase = new Dictionary<string, string>();

        public int debug
        {
            get { return Int32.Parse(configuration["debug"]); }
            set { configuration["debug"] = value.ToString(); }
        }

        public void Init()
        {

            try
            {
                XmlDocument xml = new XmlDocument();
                xml.Load("configuration.xml");

                try
                {
                    //general
                    configuration.Add("debug", xml.SelectSingleNode("settings/general/debug").InnerXml);

                    //database
                    configDatabase.Add("hostname", xml.SelectSingleNode("settings/database/hostname").InnerXml);
                    configDatabase.Add("username", xml.SelectSingleNode("settings/database/username").InnerXml);
                    configDatabase.Add("password", xml.SelectSingleNode("settings/database/password").InnerXml);
                    configDatabase.Add("database", xml.SelectSingleNode("settings/database/database").InnerXml);
                }
                catch (Exception exception)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("Uncaught exception: " + exception.Message);
                    Console.ResetColor();
                }

            }
            catch (Exception exception)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("Uncaught exception: " + exception.Message);
                Console.ResetColor();
            }
        }
    }
}

Answer 1

Ok, so following discussion with you in chat I've established that your request for a 'class' called database is a red herring. You simply want to be able to access the hostname via .database.hostname .

Since you've gone as far as providing us with your implementation now my first response is that you probably shouldn't be saving those properties in dictionaries - this isn't a very object oriented way of doing things. So with that in mind you could:

1. Create a "Database" type (a new class) that encapsulates the database configuration. Instead of saving the settings in the Dictionary during initialisation, instantiate a new "Database" object and save the settings in that. Then simply return the Database object in the property

public class Database {
    public string HostName { get; set; }
    // and the rest
}

public class ConfigurationManager {
    public Database Database { get; private set; }
    public void Init() {
       // The rest of the Init code
       Database = new Database { 
           HostName = xml.SelectSingleNode("settings/database/hostname").InnerXml
       }
    }
}

However, if you really must retain the dictionary implementation you could

2. Implement the HostName property on the ConfigurationManager class, have the ConfigurationManager class implement two different interfaces, have a property called Database that returns this

public interface IConfigurationManager {
    IConfigurableDatabase Database { get; }
    void Init();
}

public interface IConfigurableDatabase {
   string HostName { get; }
   // And the rest
}

public class ConfigurationManager 
    : IConfigurationManager, IConfigurableDatabase  {
    private static Dictionary<string, string> configDatabase = new Dictionary<string, string>();
    IConfigurableDatabase Database => this;

    public HostName {
        get => configDatabase["hostname"];
        set => configDatabase["hostname"] = value
    }
}

However this is needlessly complicated and you really should be using option 1 .

PS:

By the way, in the implementation of your Init method, you only need one try/catch block. If you remove the inner block, the outer one will do the job of the inner one.