L'équivalent de l'app.config ' pour une bibliothèque (DLL)

y a-t-il un équivalent à app.config pour les bibliothèques (DLLs)? Si ce n'est pas le cas, quelle est la meilleure façon de stocker les paramètres de configuration spécifiques à une bibliothèque? Veuillez considérer que la bibliothèque peut être utilisée dans différentes applications.

124
demandé sur DavidRR 2011-03-04 09:40:01

14 réponses

vous can ont un fichier de configuration séparé, mais vous devrez le lire" manuellement", le ConfigurationManager.AppSettings["key"] Lira seulement la configuration de l'assemblage en cours d'exécution.

si vous utilisez Visual Studio comme IDE, vous pouvez cliquer avec le bouton droit de la souris sur le projet désiré → ajouter → nouvel élément → fichier de Configuration de L'Application

cela ajoutera App.config au dossier du projet, mettez vos paramètres Là sous <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 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 de 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 au système.Espace de noms de Configuration pour que la classe ConfigurationManager soit disponible.

lors de la construction du projet, en plus de la DLL, vous aurez DllName.dll.config fichier ainsi, c'est le fichier que vous devez publier avec la DLL elle-même.

ce qui précède est un code d'échantillon de base, pour ceux qui sont intéressés par un exemple grandeur nature, veuillez vous référer à cette autre réponse .

135
répondu Shadow Wizard 2017-12-10 08:36:30

Malheureusement, vous ne pouvez avoir qu'une seule application.fichier de configuration par exécutable, donc si vous avez des DLL liées à votre application, ils ne peuvent pas avoir leur propre application.les fichiers de configuration.

la Solution est: Tu n'as pas besoin de mettre l'application.fichier de configuration dans le projet de la bibliothèque de classe.

Vous avez mis l'Application.fichier de configuration dans la demande qui fait référence à votre classe la dll de la bibliothèque.

Par exemple, disons que nous avons une bibliothèque de classe appelée MyClasses.dll qui utilise l'application.fichier de configuration comme ceci:

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

maintenant, disons que nous avons une Application Windows nommée MyApp.exe qui références MyClasses.DLL. Il contiendrait une application.config avec une telle entrée as:

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

ou

un fichier xml est le meilleur équivalent pour app.config. Utilisation de xml sérialiser/désérialiser comme nécessaire. Vous pouvez l'appeler ce que vous tous le souhaitez. Si votre configuration est " statique" et n'a pas besoin de changer, vous pouvez aussi l'ajouter au projet comme un ressource incorporée.

Espérons qu'il donne une certaine Idée

26
répondu PawanS 2017-05-12 00:35:48
Les fichiers de Configuration

sont définis en termes d'application et non en termes d'assemblage. 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, ce n'est pas une bonne pratique d'obtenir la configuration à partir du fichier de configuration de l'application, en particulier la section appSettings , dans une bibliothèque de classe. Si votre bibliothèque a besoin de paramètres, ils devraient probablement être passés comme arguments de méthode dans les constructeurs, méthodes d'usine, etc. par celui qui appelle votre bibliothèque. Cela empêche les applications appelant de réutiliser accidentellement les entrées de configuration attendues par la bibliothèque de classe.

cela dit, les fichiers de configuration XML sont extrêmement pratiques, donc le meilleur compromis que j'ai trouvé est d'utiliser des sections de configuration personnalisées. Vous pouvez 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 aussi Phil Haack a un bel article sur eux.

6
répondu madd0 2011-03-04 07:56:29
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 refactorisé la meilleure réponse dans une classe. L'usage est quelque chose comme:

ConfigMan configMan = new ConfigMan(this.GetType().Assembly.Location);
var setting = configMan.GetAppSetting("AppSettingsKey");
5
répondu Firegarden 2018-03-24 00:22:14

si vous ajoutez des paramètres à un projet de bibliothèque de classe dans Visual Studio (Propriétés du projet, Paramètres), il ajoutera une application.fichier de configuration de votre projet avec les sections userSettings/applicatioNSettings pertinentes, et les valeurs par défaut pour ces paramètres à partir de vos paramètres.le fichier de paramètres.

cependant ce fichier de configuration ne sera pas utilisé à l'exécution - la bibliothèque de classe utilise plutôt le fichier de configuration de son application d'hébergement.

I croyez que la raison principale pour générer ce fichier est de sorte que vous pouvez copier/coller les paramètres dans le fichier de configuration de l'application hôte.

2
répondu Joe 2011-03-04 07:47:06

en réponse à la question d'origine, j'ajoute typiquement le fichier de configuration dans mon projet de test comme lien; vous pouvez alors utiliser L'attribut Deplementitem pour ajouter au dossier Out de l'exécution de test.

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

en réponse aux commentaires que les assemblages ne peuvent pas être spécifiques au projet, ils peuvent et cela offre une grande flexibilité esp. en travaillant avec IOC frameworks.

2
répondu Allan Elder 2013-05-30 19:54:24

assemblées n'ont pas leur propre application.fichier de configuration. Ils utilisent l'application.fichier de configuration de l'application qui les utilise. Donc, si votre assemblée s'attend à certaines choses dans le fichier de configuration, assurez-vous que votre demande de fichier de configuration a ces entrées.

si votre ensemble est utilisé par plusieurs applications, alors chacune de ces applications devra avoir ces entrées dans leur application.fichier de configuration.

ce que je voudrais il est recommandé de définir des propriétés sur les classes de votre assemblage 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 obtenir sa valeur à partir du fichier de configuration de l'application. Si une application utilisant cet assemblage manque ce paramètre dans le fichier de configuration, vous obtiendrez une exception o il est clair que quelque chose a disparu.

Missingconfigileappsettings is a custom Exception. Vous pouvez jeter un autre exception.

bien sûr, une meilleure conception serait que la méthode de ces classes soit fournie ces valeurs en tant que paramètres plutôt que de s'en remettre à 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.

1
répondu Shiv Kumar 2011-03-04 07:43:05

utiliser Ajouter l'article existant, sélectionner la config app du projet dll. Avant de cliquer ajouter, utilisez la petite flèche vers le bas sur le côté droit du bouton Ajouter pour "ajouter comme lien "

je fais ça tout le temps dans mon dev.

1
répondu ghostJago 2013-05-16 22:19:56

je suis en train de créer des plugins pour une marque de logiciels de vente au détail, qui sont en fait des bibliothèques de classe .net. Comme une exigence, chaque plugin doit être configuré en utilisant un fichier de configuration. Après un peu de recherche et d'essais, j'ai compilé la classe suivante. Il fait le travail parfaitement. Notez que je n'ai pas mis en place la gestion des exceptions locales dans mon cas parce que, je capte les exceptions à un niveau plus élevé.

quelques retouches peut-être nécessaires pour obtenir le point décimal juste, au cas où des décimales et des doubles, mais ça marche très 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);
    }
}

App.Exemple de fichier de configuration

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

Utilisation:

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

crédits à Shadow Wizard & MattC

1
répondu Yiannis Leoussis 2015-02-11 13:50:03

Preamble : j'utilise NET 2.0;

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

tout d'abord, le static AppSettingsSection AppSettings = (AppSettingsSection)myDllConfig.GetSection("appSettings"); renvoie nul. J'ai dû le changer en static AppSettingSection = myDllConfig.AppSettings;

puis le return (T)Convert.ChangeType(AppSettings.Settings[name].Value, typeof(T), nfi); n'a pas de prise 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 avoir une dll différente vous devez réécrire à chaque fois le code pour chaque assemblée. Donc, c'est ma version pour qu'une classe instancie 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 configuration:

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

utiliser 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");
1
répondu Matteo Gaggiano 2017-05-23 12:34:28

autant que je sache, vous devez copier + coller les sections que vous voulez de la bibliothèque .config dans les applications .fichier de configuration. Vous obtenez seulement 1 app.config par instance exécutable.

0
répondu mike 2011-03-04 06:49:45

j'ai affronté le même problème et je l'ai résolu en créant un paramètre de classe statique aprè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;
    }
}

Puis obtenir un paramètre comme ceci:

Parameters.getParameter("keyName");
0
répondu krlzlx 2017-02-06 11:01:54

pourquoi ne pas utiliser:

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

vous avez juste à mettre à jour visuellement ces propriétés à la conception-temps à travers:

[Solution Project]->Properties->Settings

0
répondu Pedro Mora 2018-05-16 21:39:49

l'utilisation des configurations doit être très facile 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

0
répondu Rahmat Anjirabi 2018-07-17 07:27:44