Équivalent à 'app.config' pour une bibliothèque (DLL)

Existe-t-il un équivalent à app.configpour les bibliothèques (DLL)? Sinon, quel est le moyen le plus simple de stocker les paramètres de configuration spécifiques à une bibliothèque? Veuillez noter que la bibliothèque peut être utilisée dans différentes applications.

Vous pouvez avoir un fichier de configuration séparé, mais vous devrez le lire "manuellement", le ConfigurationManager.AppSettings["key"]ne lira que la configuration de l'assembly en cours d'exécution.

En supposant que vous utilisez Visual Studio comme IDE, vous pouvez cliquer avec le bouton droit sur le projet souhaité → Ajouter → Nouvel élément → Fichier de configuration de l'application

Cela ajoutera App.configau dossier du projet, mettez vos paramètres là-dedans sous la <appSettings>section. Si vous n'utilisez pas Visual Studio et n'ajoutez pas le fichier manuellement, assurez-vous de lui donner un tel nom: DllName.dll.config , sinon le code ci-dessous ne fonctionnera pas correctement.

Maintenant, pour lire à partir de ce fichier ont une telle fonction:

string GetAppSetting(Configuration config, string key)
{
    KeyValueConfigurationElement element = config.AppSettings.Settings[key];
    if (element != null)
    {
        string value = element.Value;
        if (!string.IsNullOrEmpty(value))
            return value;
    }
    return string.Empty;
}

Et pour l'utiliser:

Configuration config = null;
string exeConfigPath = this.GetType().Assembly.Location;
try
{
    config = ConfigurationManager.OpenExeConfiguration(exeConfigPath);
}
catch (Exception ex)
{
    //handle errror here.. means DLL has no sattelite configuration file.
}

if (config != null)
{
    string myValue = GetAppSetting(config, "myKey");
    ...
}

Vous devrez également ajouter une référence à l'espace de noms System.Configuration pour que la classe ConfigurationManager soit disponible.

Lors de la construction du projet, en plus de la DLL, vous aurez également un DllName.dll.configfichier, c'est le fichier que vous devez publier avec la DLL elle-même.

Ce qui précède est un exemple de code de base, pour ceux qui sont intéressés par un exemple à grande échelle, veuillez vous référer à cette autre réponse .

Malheureusement, vous ne pouvez avoir qu'un seul fichier app.config par exécutable, donc si vous avez des DLL liées à votre application, elles ne peuvent pas avoir leurs propres fichiers app.config.

La solution est la suivante: vous n'avez pas besoin de placer le fichier App.config dans le projet de la bibliothèque de classes.
Vous placez le fichier App.config dans l'application qui fait référence à la DLL de votre bibliothèque de classes.

Par exemple, disons que nous avons une bibliothèque de classes nommée MyClasses.dll qui utilise le fichier app.config comme ceci:

string connect = 
ConfigurationSettings.AppSettings["MyClasses.ConnectionString"];

Maintenant, disons que nous avons une application Windows nommée MyApp.exe qui fait référence à MyClasses.dll. Il contiendrait un App.config avec une entrée telle que:

<appSettings>
    <add key="MyClasses.ConnectionString"
         value="Connection string body goes here" />
</appSettings>

OU

Un fichier xml est le meilleur équivalent pour app.config. Utilisez xml sérialiser / désérialiser si nécessaire. Vous pouvez l'appeler comme vous le souhaitez. Si votre configuration est "statique" et n'a pas besoin d'être modifiée, vous pouvez également l'ajouter au projet en tant que ressource intégrée.

J'espère que ça donne une idée

Les fichiers de configuration sont axés sur l'application et non sur l'assembly. Vous devrez donc mettre les sections de configuration de votre bibliothèque dans le fichier de configuration de chaque application qui utilise votre bibliothèque.

Cela dit, il n'est pas recommandé d'obtenir la configuration à partir du fichier de configuration de l'application, en particulier le appSettings section, dans une bibliothèque de classes. Si votre bibliothèque a besoin de paramètres, ils devraient probablement être passés comme arguments de méthode dans les constructeurs, les méthodes de fabrique, etc. par celui qui appelle votre bibliothèque. Cela empêche les applications appelantes de réutiliser accidentellement les entrées de configuration attendues par la bibliothèque de classes.

Cela dit, les fichiers de configuration XML sont extrêmement pratiques, donc le meilleur compromis que j'ai trouvé consiste à utiliser des sections de configuration personnalisées. Vous obtenez de mettre la configuration de votre bibliothèque dans un fichier XML qui est automatiquement lu et analysé par le framework et vous évitez les accidents potentiels.

Vous pouvez en savoir plus sur les sections de configuration personnalisées sur MSDN et Phil Haack a également un bel article à leur sujet.

public class ConfigMan
{
    #region Members

    string _assemblyLocation;
    Configuration _configuration;

    #endregion Members

    #region Constructors

    /// <summary>
    /// Loads config file settings for libraries that use assembly.dll.config files
    /// </summary>
    /// <param name="assemblyLocation">The full path or UNC location of the loaded file that contains the manifest.</param>
    public ConfigMan(string assemblyLocation)
    {
        _assemblyLocation = assemblyLocation;
    }

    #endregion Constructors

    #region Properties

    Configuration Configuration
    {
        get
        {
            if (_configuration == null)
            {
                try
                {
                    _configuration = ConfigurationManager.OpenExeConfiguration(_assemblyLocation);
                }
                catch (Exception exception)
                {
                }
            }
            return _configuration;
        }
    }

    #endregion Properties

    #region Methods

    public string GetAppSetting(string key)
    {
        string result = string.Empty;
        if (Configuration != null)
        {
            KeyValueConfigurationElement keyValueConfigurationElement = Configuration.AppSettings.Settings[key];
            if (keyValueConfigurationElement != null)
            {
                string value = keyValueConfigurationElement.Value;
                if (!string.IsNullOrEmpty(value)) result = value;
            }
        }
        return result;
    }

    #endregion Methods
}

Juste pour quelque chose à faire, j'ai refactoré la première réponse dans une classe. L'utilisation est quelque chose comme:

ConfigMan configMan = new ConfigMan(this.GetType().Assembly.Location);
var setting = configMan.GetAppSetting("AppSettingsKey");

Si vous ajoutez des paramètres à un projet de bibliothèque de classes dans Visual Studio (propriétés du projet, paramètres), il ajoutera un fichier app.config à votre projet avec les sections userSettings / applicatioNSettings pertinentes et les valeurs par défaut de ces paramètres à partir de vos paramètres. fichier.

Cependant, ce fichier de configuration ne sera pas utilisé lors de l'exécution - à la place, la bibliothèque de classes utilise le fichier de configuration de son application d'hébergement.

Je pense que la principale raison de la génération de ce fichier est que vous puissiez copier / coller les paramètres dans le fichier de configuration de l'application hôte.

Je crée actuellement des plugins pour une marque de logiciels de vente au détail, qui sont en fait des bibliothèques de classes .net. En tant que condition, chaque plugin doit être configuré à l'aide d'un fichier de configuration. Après quelques recherches et tests, j'ai compilé la classe suivante. Il fait parfaitement le travail. Notez que je n'ai pas implémenté la gestion des exceptions locales dans mon cas car j'attrape les exceptions à un niveau supérieur.

Quelques ajustements peuvent être nécessaires pour obtenir le bon point décimal, en cas de décimales et de doubles, mais cela fonctionne bien pour mon CultureInfo ...

static class Settings
{
    static UriBuilder uri = new UriBuilder(Assembly.GetExecutingAssembly().CodeBase);
    static Configuration myDllConfig = ConfigurationManager.OpenExeConfiguration(uri.Path);
    static AppSettingsSection AppSettings = (AppSettingsSection)myDllConfig.GetSection("appSettings");
    static NumberFormatInfo nfi = new NumberFormatInfo() 
    { 
        NumberGroupSeparator = "", 
        CurrencyDecimalSeparator = "." 
    };

    public static T Setting<T>(string name)
    {
        return (T)Convert.ChangeType(AppSettings.Settings[name].Value, typeof(T), nfi);
    }
}

Exemple de fichier App.Config

<add key="Enabled" value="true" />
<add key="ExportPath" value="c:\" />
<add key="Seconds" value="25" />
<add key="Ratio" value="0.14" />

Usage:

  somebooleanvar = Settings.Setting<bool>("Enabled");
  somestringlvar = Settings.Setting<string>("ExportPath");
  someintvar =     Settings.Setting<int>("Seconds");
  somedoublevar =  Settings.Setting<double>("Ratio");

Crédits à Shadow Wizard et MattC

En réponse à la question d'origine, j'ajoute généralement le fichier de configuration dans mon projet de test en tant que lien; vous pouvez ensuite utiliser l'attribut DeploymentItem pour l'ajouter au dossier Out du test.

[TestClass]
[DeploymentItem("MyProject.Cache.dll.config")]
public class CacheTest
{
    .
    .
    .
    .
}

En réponse aux commentaires selon lesquels les assemblys ne peuvent pas être spécifiques à un projet, ils le peuvent et cela offre une grande flexibilité, notamment. lorsque vous travaillez avec des cadres IOC.

J'ai rencontré le même problème et je l'ai résolu en créant une classe statique Parametersaprès avoir ajouté un fichier de configuration d'application au projet:

public static class Parameters
{
    // For a Web Application
    public static string PathConfig { get; private set; } =
        Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "web.config");

    // For a Class Library
    public static string PathConfig { get; private set; } =
        Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin", "LibraryName.dll.config");

    public static string GetParameter(string paramName)
    {
        string paramValue = string.Empty;

        using (Stream stream = File.OpenRead(PathConfig))
        {
            XDocument xdoc = XDocument.Load(stream);

            XElement element = xdoc.Element("configuration").Element("appSettings").Elements().First(a => a.Attribute("key").Value == paramName);
            paramValue = element.Attribute("value").Value;
        }

        return paramValue;
    }
}

Ensuite, obtenez un paramètre comme celui-ci:

Parameters.GetParameter("keyName");

les assemblys n'ont pas leur propre fichier app.config. Ils utilisent le fichier app.config de l'application qui les utilise. Donc, si votre assemblage attend certaines choses dans le fichier de configuration, assurez-vous simplement que le fichier de configuration de votre application contient ces entrées.

Si votre assembly est utilisé par plusieurs applications, chacune de ces applications devra avoir ces entrées dans leur fichier app.config.

Ce que je vous recommande de faire, c'est de définir des propriétés sur les classes de votre assembly pour ces valeurs par exemple

private string ExternalServicesUrl
{
  get
  {
    string externalServiceUrl = ConfigurationManager.AppSettings["ExternalServicesUrl"];
    if (String.IsNullOrEmpty(externalServiceUrl))
      throw new MissingConfigFileAppSettings("The Config file is missing the appSettings entry for: ExternalServicesUrl");
    return externalServiceUrl;
  }
}

Ici, la propriété ExternalServicesUrl obtient sa valeur à partir du fichier de configuration de l'application. Si une application utilisant cet assembly manque ce paramètre dans le fichier de configuration, vous obtiendrez une exception o il est clair que quelque chose a disparu.

MissingConfigFileAppSettings est une exception personnalisée. Vous souhaiterez peut-être lever une exception différente.

Bien sûr, une meilleure conception serait que la méthode de ces classes reçoive ces valeurs en tant que paramètres plutôt que de s'appuyer sur la configuration du fichier de configuration. De cette façon, les applications utilisant ces classes peuvent décider d'où et comment elles fournissent ces valeurs.

Utilisez ajouter un élément existant, sélectionnez la configuration de l'application à partir du projet dll. Avant de cliquer sur Ajouter, utilisez la petite flèche vers le bas sur le côté droit du bouton Ajouter pour "ajouter en tant que lien"

Je fais ça tout le temps dans mon dev.

Préambule : j'utilise NET 2.0;

La solution publiée par Yiannis Leoussis est acceptable mais j'ai eu un problème avec elle.

Tout d'abord, le static AppSettingsSection AppSettings = (AppSettingsSection)myDllConfig.GetSection("appSettings");retourne null. J'ai dû le changer enstatic AppSettingSection = myDllConfig.AppSettings;

Alors le return (T)Convert.ChangeType(AppSettings.Settings[name].Value, typeof(T), nfi);n'a pas de piège pour les exceptions. Alors je l'ai changé

try
{
    return (T)Convert.ChangeType(AppSettings.Settings[name].Value, typeof(T), nfi);
}
catch (Exception ex)
{
    return default(T);
}

Cela fonctionne très bien mais si vous avez une dll différente, vous devez réécrire à chaque fois le code de chaque assembly. Donc, ceci est ma version pour une classe à instancier à chaque fois que vous en avez besoin.

public class Settings
{
    private AppSettingsSection _appSettings;
    private NumberFormatInfo _nfi;

    public Settings(Assembly currentAssembly)
    {
        UriBuilder uri = new UriBuilder(currentAssembly.CodeBase);
        string configPath = Uri.UnescapeDataString(uri.Path);
        Configuration myDllConfig = ConfigurationManager.OpenExeConfiguration(configPath);
        _appSettings = myDllConfig.AppSettings;
        _nfi = new NumberFormatInfo() 
        { 
            NumberGroupSeparator = "", 
            CurrencyDecimalSeparator = "." 
        };
    }


    public T Setting<T>(string name)
    {
        try
        {
            return (T)Convert.ChangeType(_appSettings.Settings[name].Value, typeof(T), _nfi);
        }
        catch (Exception ex)
        {
            return default(T);
        }
    }
}

Pour une config:

<add key="Enabled" value="true" />
<add key="ExportPath" value="c:\" />
<add key="Seconds" value="25" />
<add key="Ratio" value="0.14" />

Utilisez-le comme:

Settings _setting = new Settings(Assembly.GetExecutingAssembly());

somebooleanvar = _settings.Setting<bool>("Enabled");
somestringlvar = _settings.Setting<string>("ExportPath");
someintvar =     _settings.Setting<int>("Seconds");
somedoublevar =  _settings.Setting<double>("Ratio");

Autant que je sache, vous devez copier + coller les sections que vous voulez de la bibliothèque .config dans le fichier .config des applications. Vous n'obtenez qu'un seul app.config par instance d'exécutable.

Pourquoi ne pas utiliser:

• [ProjectNamespace].Properties.Settings.Default.[KeyProperty] pour C #
• My.Settings.[KeyProperty] pour VB.NET

Il vous suffit de mettre à jour visuellement ces propriétés au moment de la conception via:

[Solution Project]->Properties->Settings

l'utilisation à partir de configurations doit être très très simple comme ceci:

var config = new MiniConfig("setting.conf");

config.AddOrUpdate("port", "1580");

if (config.TryGet("port", out int port)) // if config exist
{
    Console.Write(port);
}

pour plus de détails, voir MiniConfig