.NET 3.5 DLL using its own config file

Question

I need to have a .NET 3.5 DLL have its own config file. This DLL could be called from many different apps so the information (like connection strings) stored in the config file needed to be kept in a config file that the DLL can reference. What I want is when the DLL is used, I need to "switch" the config file that is used to reference information to be the DLLs config file. Then when the DLL is done with using the configuration information, the switch is made back to the default one. The DLL is written using .NET 3.5. I have been searching for how to do this and what I keep finding is how to merge information with an exe's app.config file. In my case, I don't know how where this DLL will be used to modify any exe's app.config files out there. This solution needs to be stand alone. However, my base classes used to create the DLL (which contain business objects) are expecting to lookup the connection string and other information in a config file so that is why I need to "switch" to my DLL config file at the time when it is accessed and then switch it back so I don't mess up the exe app that called the DLL.

Answer 1

The .NET 2.0 and up configuration system gives you capabilities - you can e.g. load a specific config file on demand. It's a bit more work - but it works.

You'd have to do something like this:

// set up a exe configuration map - specify the file name of the DLL's config file
ExeConfigurationFileMap map = new ExeConfigurationFileMap();
map.ExeConfigFilename = "ConfigLibrary.config";

// now grab the configuration from the ConfigManager
Configuration cfg = ConfigurationManager
                   .OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);

// now grab the section you're interested in from the opened config - 
// as a sample, I'm grabbing the <appSettings> section
AppSettingsSection section = (cfg.GetSection("appSettings") as AppSettingsSection);

// check for null to be safe, and then get settings from the section
if(section != null)
{
   string value = section.Settings["Test"].Value;
}

You also need to make sure that the config for the class library DLL is being built and copied to a location where you can get at it. Worst case you need to specify a specific config file and make sure it gets copied to the output directory by setting its "Copy To Output Directory" property in the Visual Studio properties window.

You should also check out Jon Rista's three-part series on .NET 2.0 configuration up on CodeProject.

• Unraveling the mysteries of .NET 2.0 configuration
• Decoding the mysteries of .NET 2.0 configuration
• Cracking the mysteries of .NET 2.0 configuration

Highly recommended, well written and extremely helpful!

Marc

Answer 2

Generally when you have settings at the application level, you need to generate those settings at the application level, and then percolate them through your libraries. It adds a few more lines of code to your initialization to inject dependencies, but you are essentially trying to do that anyway.

You are going to run into way more problems than its worth if you try to include a config file for just the dll side by side with every deployment of your library, and it just doesn't make a lot of sense semantically.

Take System.Data for example...when you create a connection, you specify the connection string, not create a separate config file for just the connection string to deploy side by side with the System.Data library. [and that would cause tons of problems since it likely resides in the GAC on your system anyway]