Un App.Config può essere caricato da una stringa o da un flusso di memoria?

Question

So che posso caricare un file app.config da una posizione diversa usando la seguente riga di codice:

AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", ConfigFile);

dove ConfigFile è un percorso completo. Quello che mi piacerebbe fare è poter caricare un file che è stato crittografato per app.config. Idealmente, vorrei essere in grado di caricare il file, decrittografarlo, caricarlo in una stringa o in un flusso di memoria e passarlo all'app come se fosse il file app.config. So che potrei semplicemente caricare tutti i valori da esso e accedervi manualmente, ma mi piacerebbe essere in grado di accedervi utilizzando la funzionalità integrata di .NET. C'è un modo per dire all'app di utilizzare il file di configurazione da qualcosa di diverso da un file?

L'altra opzione è aprire il file, decodificarlo, scriverlo in un file temporaneo e quindi utilizzare il codice sopra riportato per fare riferimento in quel modo, ma se ci fosse un modo più semplice, idealmente, mi piacerebbe trovalo, per evitare di occuparti di file aggiuntivi.

Answer 1

Anche se finora non sono mai stato in grado di ottenere una risposta, ho dovuto escogitare una soluzione. Questa potrebbe non essere la soluzione migliore, ma funziona. Fondamentalmente quello che abbiamo fatto è stato codificare il nostro file app.config e dargli un nuovo nome. All'avvio dell'app, prenderà il file codificato, lo decifrerà e lo scriverà in un file temporaneo di Windows. Ciò garantisce che il file abbia un nome casuale univoco che nessuno è in grado di trovare e che non è necessario gestirlo, poiché Windows lo eliminerà automaticamente per noi. In questo modo ogni riavvio siamo in grado di riscrivere un nuovo file e utilizzarlo. Ecco i frammenti di codice di base per chiunque sia interessato.

Questo primo metodo, LoadFileAppConfig () , caricherà il file. In questo caso, poiché si tratta di servizi, è necessario caricare il percorso di esecuzione e passarlo al metodo appropriato. Ripristiniamo il percorso dell'app.config decrittografato, quindi utilizziamo il metodo SetData () per impostarlo come percorso app.config.

/// <summary>
/// Loads the Local App.Config file, and sets it to be the local app.config file
/// </summary>
/// <param name="p_ConfigFilePath">The path of the config file to load, i.e. \Logs\</param>
public void LoadFileAppConfig(string p_ConfigFilePath)
{
    try
    {
        // The app.config path is the passed in path + Application Name + .config
        m_LocalAppConfigFile = ProcessLocalAppConfig(p_ConfigFilePath + this.ApplicationName + ".config");

        // This sets the service's app.config property
        AppDomain.CurrentDomain.SetData("APP_CONFIG_FILE", m_LocalAppConfigFile);
    }
    catch (Exception ex)
    {
        throw ex;
    }
}

In questo metodo stiamo ottenendo il percorso del file, passando quel file per essere decrittografato e restituito come stringa, e quindi scrivendo quel file nel nostro file temporaneo di Windows.

public string ProcessLocalAppConfig(string p_ConfigFilePath)
{
    try
    {
        string fileName = Path.GetTempFileName();
        string unencryptedConfig = DecryptConfigData(p_ConfigFilePath);

        FileStream fileStream = new FileStream(fileName, FileMode.Create, FileAccess.Write);
        StreamWriter streamWriter = new StreamWriter(fileStream);

        if (!string.IsNullOrEmpty(unencryptedConfig))
        {
            try
            {
                streamWriter.BaseStream.Seek(0, SeekOrigin.End);
                streamWriter.WriteLine(unencryptedConfig);
            }

            catch (IOException ex)
            {
                Debug.Assert(false, ex.ToString());
            }
            finally
            {
                streamWriter.Close();
            }
            return fileName;
        }
        return null;
    }
    catch (Exception)
    {
        throw;
    }
}

Questo metodo finale prende il percorso del file app.config crittografato, utilizza il nostro strumento di decrittografia per decrittografare il file (assicurandoci di poterlo decrittografare e che sia il giusto tipo di file) e quindi restituire i contenuti decrittati come stringa al metodo sopra.

private string DecryptConfigData(string p_AppConfigFile)
{
    string decryptedData = null;
    TMS.Pearl.SystemFramework.CryptographyManager.CryptographyManager cryptManager = new TMS.Pearl.SystemFramework.CryptographyManager.CryptographyManager();
    try
    {
        //Attempt to load the file.
        if (File.Exists(p_AppConfigFile))
        {
            //Load the file's contents and decrypt them if they are encrypted.
            string rawData = File.ReadAllText(p_AppConfigFile);

            if (!string.IsNullOrEmpty(rawData))
            {
                if (!rawData.Contains("<?xml"))  //assuming that all unencrypted config files will start with an xml tag...
                {
                    decryptedData = cryptManager.Decrypt(rawData);
                }
                else
                {
                    decryptedData = rawData;
                }
            }
        }
    }
    catch (Exception)
    {
        throw;
    }

    return decryptedData;
}