Kann eine App.Config aus einem String oder Speicher-Stream geladen werden?

Question

Ich weiß, dass ich eine app.config-Datei von einem anderen Ort laden kann die folgende Zeile von Code verwendet:

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

wo ConfigFile ist eine vollständige Pfad Lage. Was ich möchte, obwohl zu tun ist in der Lage sein, eine Datei zu laden, die für die app.config verschlüsselt wurden. Im Idealfall würde Ich mag Lage sein, die Datei zu laden, entschlüsseln, und es in einen String oder Speicher-Stream zu laden und an die App übergeben, als ob es die app.config waren. Ich weiß, ich könnte nur alle Werte von ihm laden und sie manuell zugreifen, aber ich möchte in der Lage sein, auf sie zuzugreifen die eingebaute Funktionalität von .NET. Gibt es eine Möglichkeit, die App zu sagen, die Konfigurationsdatei von etwas anderes als eine Datei zu verwenden?

Die andere Option ist, um die Datei zu öffnen, entschlüsseln, schreiben Sie es auf eine temporäre Datei, und dann den obigen Code verwenden, es auf diese Weise zu verweisen, aber wenn es ein einfacherer Weg war, im Idealfall, ich mag finden sie es, haben zu vermeiden, mit zusätzlichen Dateien handelt.

Answer 1

Während ich nie in der Lage war, für diese eine Antwort zu bekommen, so weit, ich hatte mit einem Work-around zu kommen. Dies kann nicht die beste Lösung, aber es funktioniert. Im Grunde, was wir getan haben, ist unsere app.config Datei verschlüsselt gespeichert, und ihm einen neuen Namen gegeben. Wenn die App gestartet wird, wird die Datei verschlüsselt gespeichert nehmen, decyrpt es, und schreiben Sie es auf einem Windows-Temp-Datei. Dadurch wird sichergestellt, dass die Datei einige einzigartige zufälligen Namen ist, dass niemand zu finden, ist wahrscheinlich, und wir müssen nicht die Dateien verwalten, da Windows sie automatisch für uns gelöscht. Auf diese Weise jede Neubelebung wir sind in der Lage, eine neue Datei neu zu schreiben und nutzen. Hier ist der grundlegenden Code-Schnipsel für jeden, der interessiert ist.

Dieses erste Verfahren, LoadFileAppConfig(), wird die Datei laden. In diesem Fall, da sie Dienste sind, müssen wir die Ausführung Pfad laden, und es an der entsprechenden Methode übergeben. Wir bekommen den Pfad der entschlüsselten app.config zurück, und verwenden Sie dann die SetData() Methode es zum Einstellen der app.config Weg sein.

/// <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;
    }
}

Bei dieser Methode bekommen wir den Pfad der Datei, vorbei, dass entschlüsselt werden abfeilen und kehrten als String, und dann diese Datei auf unsere Windows-Temp-Datei zu schreiben.

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;
    }
}

Diese letzte Methode in dem Pfad der verschlüsselten app.config nimmt, nutzt unsere Entschlüsselungs-Tool die Datei zu entschlüsseln (um sicherzustellen, dass wir sie entschlüsseln kann, und dass es die richtige Dateityp) und dann die entschlüsselten Inhalte als eine Rückkehr String an die Methode oben.

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;
}