Un App.Config peut-il être chargé à partir d'une chaîne ou d'un flux de mémoire?

Question

Je sais que je peux charger un fichier app.config à partir d'un emplacement différent à l'aide de la ligne de code suivante:

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

où ConfigFile est un emplacement de chemin complet. Ce que j'aimerais cependant, c'est pouvoir charger un fichier crypté pour le fichier app.config. Idéalement, j'aimerais pouvoir charger le fichier, le déchiffrer, le charger dans une chaîne ou dans un flux de mémoire et le transmettre à l'application comme s'il s'agissait du fichier app.config. Je sais que je pourrais simplement charger toutes les valeurs et y accéder manuellement, mais j'aimerais pouvoir y accéder à l'aide de la fonctionnalité intégrée de .NET. Existe-t-il un moyen d'indiquer à l'application d'utiliser le fichier de configuration à partir d'un fichier autre qu'un fichier?

L’autre option consiste à ouvrir le fichier, à le déchiffrer, à l’écrire dans un fichier temporaire, puis à utiliser le code ci-dessus pour le référencer de cette façon, mais s’il existait un moyen plus simple, idéalement, j'aimerais le trouver, pour éviter de traiter des fichiers supplémentaires.

Answer 1

Bien que je n’aie jamais pu obtenir de réponse à cette question jusqu’à présent, j’ai dû trouver une solution de rechange. Ce n'est peut-être pas la meilleure solution, mais cela fonctionne. Fondamentalement, nous avons encrypté notre fichier app.config et lui avons attribué un nouveau nom. Lorsque l'application démarre, le fichier encrypté est récupéré, décyrpti et écrit dans un fichier temporaire Windows. Cela garantit que le fichier est un nom aléatoire unique que personne ne peut trouver, et nous n'avons pas à gérer les fichiers, car Windows le supprimera automatiquement pour nous. De cette façon, chaque relancement nous permet de réécrire un nouveau fichier et de l'utiliser. Voici les extraits de code de base pour ceux qui sont intéressés.

Cette première méthode, LoadFileAppConfig () , chargera le fichier. Dans ce cas, puisqu'il s'agit de services, nous devons charger le chemin d'exécution et le transmettre à la méthode appropriée. Nous récupérons le chemin du fichier app.config déchiffré, puis nous utilisons la méthode SetData () pour le définir comme chemin 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;
    }
}

Dans cette méthode, nous obtenons le chemin du fichier, le transmettons pour qu'il soit déchiffré et renvoyé sous forme de chaîne, puis nous écrivons ce fichier dans notre fichier temporaire 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;
    }
}

Cette dernière méthode prend en compte le chemin du fichier app.config chiffré, utilise notre outil de déchiffrement pour déchiffrer le fichier (en nous assurant que nous pouvons le déchiffrer et qu'il s'agit du bon type de fichier), puis renvoyer le contenu déchiffré sous forme de fichier. chaîne à la méthode ci-dessus.

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