Thay đổi app.config mặc định trong thời gian chạy

Tôi có một vấn đề sau:
Chúng tôi có một ứng dụng tải các mô-đun (tiện ích bổ sung). Các mô-đun này có thể cần các mục trong app.config (ví dụ: cấu hình WCF). Vì các mô-đun được tải động, tôi không muốn có các mục này trong tệp app.config trong ứng dụng của mình.
Những gì tôi muốn làm là như sau:

• Tạo một app.config mới trong bộ nhớ kết hợp các phần cấu hình từ các mô-đun
• Nói với ứng dụng của tôi để sử dụng app.config mới đó

Lưu ý: Tôi không muốn ghi đè lên app.config mặc định!

Nó nên hoạt động trong suốt, ví dụ như ConfigurationManager.AppSettingssử dụng tệp mới đó.

Trong quá trình đánh giá vấn đề này, tôi đã đưa ra giải pháp tương tự như được cung cấp ở đây: Tải lại app.config bằng nunit .
Thật không may, nó dường như không làm gì cả, vì tôi vẫn nhận được dữ liệu từ app.config bình thường.

Tôi đã sử dụng mã này để kiểm tra nó:

Console.WriteLine(ConfigurationManager.AppSettings["SettingA"]);
Console.WriteLine(Settings.Default.Setting);

var combinedConfig = string.Format(CONFIG2, CONFIG);
var tempFileName = Path.GetTempFileName();
using (var writer = new StreamWriter(tempFileName))
{
    writer.Write(combinedConfig);
}

using(AppConfig.Change(tempFileName))
{
    Console.WriteLine(ConfigurationManager.AppSettings["SettingA"]);
    Console.WriteLine(Settings.Default.Setting);
}

Nó in cùng hai giá trị, mặc dù combinedConfigchứa các giá trị khác với app.config bình thường.

Việc hack trong câu hỏi được liên kết hoạt động nếu nó được sử dụng trước khi hệ thống cấu hình được sử dụng lần đầu tiên. Sau đó, nó không hoạt động nữa.
Lý do:
Tồn tại một lớp ClientConfigPathslưu trữ các đường dẫn. Vì vậy, ngay cả sau khi thay đổi đường dẫn với SetData, nó không được đọc lại, bởi vì đã tồn tại các giá trị được lưu trữ. Giải pháp là cũng loại bỏ những thứ này:

using System;
using System.Configuration;
using System.Linq;
using System.Reflection;

public abstract class AppConfig : IDisposable
{
    public static AppConfig Change(string path)
    {
        return new ChangeAppConfig(path);
    }

    public abstract void Dispose();

    private class ChangeAppConfig : AppConfig
    {
        private readonly string oldConfig =
            AppDomain.CurrentDomain.GetData("APP_CONFIG_FILE").ToString();

        private bool disposedValue;

        public ChangeAppConfig(string path)
        {
            AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", path);
            ResetConfigMechanism();
        }

        public override void Dispose()
        {
            if (!disposedValue)
            {
                AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", oldConfig);
                ResetConfigMechanism();


                disposedValue = true;
            }
            GC.SuppressFinalize(this);
        }

        private static void ResetConfigMechanism()
        {
            typeof(ConfigurationManager)
                .GetField("s_initState", BindingFlags.NonPublic | 
                                         BindingFlags.Static)
                .SetValue(null, 0);

            typeof(ConfigurationManager)
                .GetField("s_configSystem", BindingFlags.NonPublic | 
                                            BindingFlags.Static)
                .SetValue(null, null);

            typeof(ConfigurationManager)
                .Assembly.GetTypes()
                .Where(x => x.FullName == 
                            "System.Configuration.ClientConfigPaths")
                .First()
                .GetField("s_current", BindingFlags.NonPublic | 
                                       BindingFlags.Static)
                .SetValue(null, null);
        }
    }
}

Cách sử dụng là như thế này:

// the default app.config is used.
using(AppConfig.Change(tempFileName))
{
    // the app.config in tempFileName is used
}
// the default app.config is used.

Nếu bạn muốn thay đổi app.config đã sử dụng cho toàn bộ thời gian chạy của ứng dụng, chỉ cần đặt AppConfig.Change(tempFileName)mà không sử dụng ở đâu đó khi bắt đầu ứng dụng của bạn.

Bạn có thể thử sử dụng Cấu hình và Thêm Cấu hình trong thời gian chạy

Configuration applicationConfiguration = ConfigurationManager.OpenMappedExeConfiguration(
                        new ExeConfigurationFileMap(){ExeConfigFilename = path_to_your_config,
                        ConfigurationUserLevel.None
                        );

applicationConfiguration.Sections.Add("section",new YourSection())
applicationConfiguration.Save(ConfigurationSaveMode.Full,true);

EDIT: Đây là giải pháp dựa trên sự phản chiếu (mặc dù không đẹp lắm)

Tạo lớp bắt nguồn từ IInternalConfigSystem

public class ConfigeSystem: IInternalConfigSystem
{
    public NameValueCollection Settings = new NameValueCollection();
    #region Implementation of IInternalConfigSystem

    public object GetSection(string configKey)
    {
        return Settings;
    }

    public void RefreshConfig(string sectionName)
    {
        //throw new NotImplementedException();
    }

    public bool SupportsUserConfig { get; private set; }

    #endregion
}

sau đó thông qua sự phản chiếu đặt nó vào trường riêng trong ConfigurationManager

        ConfigeSystem configSystem = new ConfigeSystem();
        configSystem.Settings.Add("s1","S");

        Type type = typeof(ConfigurationManager);
        FieldInfo info = type.GetField("s_configSystem", BindingFlags.NonPublic | BindingFlags.Static);
        info.SetValue(null, configSystem);

        bool res = ConfigurationManager.AppSettings["s1"] == "S"; // return true

Giải pháp @Daniel hoạt động tốt. Một giải pháp tương tự với nhiều lời giải thích hơn là ở góc c-sharp. Để hoàn thiện, tôi muốn chia sẻ phiên bản của mình: với usingvà các cờ bit được viết tắt.

using System;//AppDomain
using System.Linq;//Where
using System.Configuration;//app.config
using System.Reflection;//BindingFlags

    /// <summary>
    /// Use your own App.Config file instead of the default.
    /// </summary>
    /// <param name="NewAppConfigFullPathName"></param>
    public static void ChangeAppConfig(string NewAppConfigFullPathName)
    {
        AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", NewAppConfigFullPathName);
        ResetConfigMechanism();
        return;
    }

    /// <summary>
    /// Remove cached values from ClientConfigPaths.
    /// Call this after changing path to App.Config.
    /// </summary>
    private static void ResetConfigMechanism()
    {
        BindingFlags Flags = BindingFlags.NonPublic | BindingFlags.Static;
        typeof(ConfigurationManager)
            .GetField("s_initState", Flags)
            .SetValue(null, 0);

        typeof(ConfigurationManager)
            .GetField("s_configSystem", Flags)
            .SetValue(null, null);

        typeof(ConfigurationManager)
            .Assembly.GetTypes()
            .Where(x => x.FullName == "System.Configuration.ClientConfigPaths")
            .First()
            .GetField("s_current", Flags)
            .SetValue(null, null);
        return;
    }

Nếu có ai quan tâm, đây là một phương pháp hoạt động trên Mono.

string configFilePath = ".../App";
System.Configuration.Configuration newConfiguration = ConfigurationManager.OpenExeConfiguration(configFilePath);
FieldInfo configSystemField = typeof(ConfigurationManager).GetField("configSystem", BindingFlags.NonPublic | BindingFlags.Static);
object configSystem = configSystemField.GetValue(null);
FieldInfo cfgField = configSystem.GetType().GetField("cfg", BindingFlags.Instance | BindingFlags.NonPublic);
cfgField.SetValue(configSystem, newConfiguration);

Giải pháp của Daniel dường như hoạt động ngay cả đối với các hội đồng xuôi dòng mà tôi đã sử dụng AppDomain.SetData trước đây, nhưng không biết làm thế nào để thiết lập lại các cờ cấu hình bên trong

Chuyển đổi sang C ++ / CLI cho những ai quan tâm

/// <summary>
/// Remove cached values from ClientConfigPaths.
/// Call this after changing path to App.Config.
/// </summary>
void ResetConfigMechanism()
{
    BindingFlags Flags = BindingFlags::NonPublic | BindingFlags::Static;
    Type ^cfgType = ConfigurationManager::typeid;

    Int32 ^zero = gcnew Int32(0);
    cfgType->GetField("s_initState", Flags)
        ->SetValue(nullptr, zero);

    cfgType->GetField("s_configSystem", Flags)
        ->SetValue(nullptr, nullptr);

    for each(System::Type ^t in cfgType->Assembly->GetTypes())
    {
        if (t->FullName == "System.Configuration.ClientConfigPaths")
        {
            t->GetField("s_current", Flags)->SetValue(nullptr, nullptr);
        }
    }

    return;
}

/// <summary>
/// Use your own App.Config file instead of the default.
/// </summary>
/// <param name="NewAppConfigFullPathName"></param>
void ChangeAppConfig(String ^NewAppConfigFullPathName)
{
    AppDomain::CurrentDomain->SetData(L"APP_CONFIG_FILE", NewAppConfigFullPathName);
    ResetConfigMechanism();
    return;
}

Nếu tệp cấu hình của bạn chỉ được ghi bằng khóa / giá trị trong "cài đặt ứng dụng", thì bạn có thể đọc một tệp khác có mã như vậy:

System.Configuration.ExeConfigurationFileMap configFileMap = new ExeConfigurationFileMap();
configFileMap.ExeConfigFilename = configFilePath;

System.Configuration.Configuration configuration = ConfigurationManager.OpenMappedExeConfiguration(configFileMap, ConfigurationUserLevel.None);
AppSettingsSection section = (AppSettingsSection)configuration.GetSection("appSettings");

Sau đó, bạn có thể đọc phần. Cài đặt dưới dạng bộ sưu tập KeyValueConfigurationEuity.

Thảo luận tuyệt vời, tôi đã thêm nhiều bình luận vào phương thức ResetConfigMechanism để hiểu được điều kỳ diệu đằng sau câu lệnh / cuộc gọi trong phương thức. Ngoài ra kiểm tra đường dẫn tập tin tồn tại

using System;//AppDomain
using System.Linq;//Where
using System.Configuration;//app.config
using System.Reflection;//BindingFlags
using System.Io;

/// <summary>
/// Use your own App.Config file instead of the default.
/// </summary>
/// <param name="NewAppConfigFullPathName"></param>
public static void ChangeAppConfig(string NewAppConfigFullPathName)
{
    if(File.Exists(NewAppConfigFullPathName)
    {
      AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", 
      NewAppConfigFullPathName);
      ResetConfigMechanism();
      return;
    }
}

/// <summary>
/// Remove cached values from ClientConfigPaths.
/// Call this after changing path to App.Config.
/// </summary>
private static void ResetConfigMechanism()
{
    BindingFlags Flags = BindingFlags.NonPublic | BindingFlags.Static;
      /* s_initState holds one of the four internal configuration state.
          0 - Not Started, 1 - Started, 2 - Usable, 3- Complete

         Setting to 0 indicates the configuration is not started, this will 
         hint the AppDomain to reaload the most recent config file set thru 
         .SetData call
         More [here][1]

      */
    typeof(ConfigurationManager)
        .GetField("s_initState", Flags)
        .SetValue(null, 0);


    /*s_configSystem holds the configuration section, this needs to be set 
        as null to enable reload*/
    typeof(ConfigurationManager)
        .GetField("s_configSystem", Flags)
        .SetValue(null, null);

      /*s_current holds the cached configuration file path, this needs to be 
         made null to fetch the latest file from the path provided 
        */
    typeof(ConfigurationManager)
        .Assembly.GetTypes()
        .Where(x => x.FullName == "System.Configuration.ClientConfigPaths")
        .First()
        .GetField("s_current", Flags)
        .SetValue(null, null);
    return;
}

Daniel, nếu có thể hãy thử sử dụng các cơ chế cấu hình khác. Chúng tôi đã đi qua tuyến đường này nơi chúng tôi có các tệp cấu hình tĩnh / động khác nhau tùy thuộc vào môi trường / hồ sơ / nhóm và cuối cùng nó trở nên khá lộn xộn.

bạn có thể thử một số loại Dịch vụ Web hồ sơ trong đó bạn chỉ chỉ định một URL Dịch vụ web từ máy khách và tùy thuộc vào chi tiết của Khách hàng (bạn có thể ghi đè cấp Nhóm / Người dùng), nó tải lên tất cả cấu hình cần thiết. Chúng tôi cũng đã sử dụng Thư viện MS Enterprise cho một số phần của nó.

đó là bạn không triển khai cấu hình với máy khách của mình và bạn có thể quản lý nó riêng biệt với máy khách của mình