如何在同一命名空间下扩展C#类以实现同类复用？

It sounds like you want to simplify access to your configuration and configDatabase variables so you can call them directly from anywhere in the same namespace (or beyond) without jumping through extra function hoops. Let's break down the cleanest ways to achieve this in C#.

1. Expose Configs as Public Static Properties (Most Straightforward) #

The simplest approach is to wrap your existing global variables in public static properties with private setters. This keeps your configs immutable after initialization (a best practice for configuration data) while making them accessible directly via the class name.

Example Implementation: #

namespace Habbo_Hotel.assets
{
    public class ConfigurationManager
    {
        // Backing fields (replace with your existing variable types)
        private static IConfiguration _generalConfig;
        private static IConfiguration _databaseConfig;

        // Public static properties for direct access
        public static IConfiguration GeneralConfig 
        { 
            get 
            {
                // Optional: Add a guard clause to ensure initialization
                if (_generalConfig == null)
                    throw new InvalidOperationException("General configuration not initialized. Call ConfigurationManager.Initialize() first.");
                return _generalConfig;
            }
            private set => _generalConfig = value;
        }

        public static IConfiguration DatabaseConfig 
        { 
            get 
            {
                if (_databaseConfig == null)
                    throw new InvalidOperationException("Database configuration not initialized. Call ConfigurationManager.Initialize() first.");
                return _databaseConfig;
            }
            private set => _databaseConfig = value;
        }

        // Initialization method (replace with your existing setup logic)
        public static void Initialize()
        {
            GeneralConfig = LoadGeneralConfiguration();
            DatabaseConfig = LoadDatabaseConfiguration();
        }

        // Private helper methods to load config data (your existing code)
        private static IConfiguration LoadGeneralConfiguration()
        {
            // Your logic to load general config (e.g., from appsettings.json)
            return new ConfigurationBuilder()
                .AddJsonFile("appsettings.json")
                .Build();
        }

        private static IConfiguration LoadDatabaseConfiguration()
        {
            // Your logic to load database config (e.g., from a separate file or section)
            return new ConfigurationBuilder()
                .AddJsonFile("database.json")
                .Build();
        }
    }
}

How to Use It: #

In your Program class (or any other class in the same namespace), initialize once at startup, then call the properties directly:

// At app startup (e.g., Program.cs)
ConfigurationManager.Initialize();

// Later, anywhere in your code
var apiKey = ConfigurationManager.GeneralConfig["ApiKey"];
var dbConnString = ConfigurationManager.DatabaseConfig["ConnectionStrings:Default"];

2. Lazy Initialization (Load Configs Only When Needed) #

If loading your configs is resource-intensive and you don't want to initialize them at app startup, use Lazy<T> to load them on first access. This ensures configs are only loaded when someone actually uses them.

Example Implementation: #

namespace Habbo_Hotel.assets
{
    public class ConfigurationManager
    {
        // Lazy-loaded config instances
        private static readonly Lazy<IConfiguration> _lazyGeneralConfig = 
            new Lazy<IConfiguration>(LoadGeneralConfiguration);
        
        private static readonly Lazy<IConfiguration> _lazyDatabaseConfig = 
            new Lazy<IConfiguration>(LoadDatabaseConfiguration);

        // Public properties that trigger lazy loading
        public static IConfiguration GeneralConfig => _lazyGeneralConfig.Value;
        public static IConfiguration DatabaseConfig => _lazyDatabaseConfig.Value;

        // Private helper methods (same as before)
        private static IConfiguration LoadGeneralConfiguration()
        {
            // Your config loading logic
        }

        private static IConfiguration LoadDatabaseConfiguration()
        {
            // Your database config loading logic
        }
    }
}

How to Use It: #

No explicit initialization needed—just call the properties directly, and they'll load automatically on first use:

// First access triggers loading
var maxUsers = ConfigurationManager.GeneralConfig["MaxConcurrentUsers"];

3. Static Imports (Even Cleaner Access) #

If you want to avoid typing ConfigurationManager. every time, use a static import at the top of your files. This lets you reference the properties directly by name.

Example: #

Add this line to the top of any file where you want to use the configs:

using static Habbo_Hotel.assets.ConfigurationManager;

Then you can call:

var dbUsername = DatabaseConfig["DbUsername"];

Key Notes: #

• Immutability: Keeping setters private ensures your configs can't be modified after initialization, which prevents unexpected bugs.
• Initialization Order: If using the first approach, make sure you call Initialize() before accessing the properties (e.g., in your app's startup code).
• Type Safety: Replace IConfiguration with your actual config type (e.g., a strongly-typed class) if you're using one—this gives you compile-time checks and IntelliSense.

内容的提问来源于stack exchange，提问作者Luicy