app.config for a class library

Question

I cannot see a app.config file generated for a class library by the VS2008 wizard. In my research I found that in an application only one app.config exists.

Is it a bad thing to add an app.config manually to a class library or are there any other methods which will serve the purpose of an app.config in class library?

I need to store log4net config information inside the app.config file.

Solution 1

You generally should not add an app.config file to a class library project; it won't be used without some painful bending and twisting on your part. It doesn't hurt the library project at all - it just won't do anything at all.

Instead, you configure the application which is using your library; so the configuration information required would go there. Each application that might use your library likely will have different requirements, so this actually makes logical sense, too.

Solution 2

I don't know why this answer hasn't already been given:

Different callers of the same library will, in general, use different configurations. This implies that the configuration must reside in the executable application, and not in the class library.

You may create an app.config within the class library project. It will contain default configurations for items you create within the library. For instance, it will contain connection strings if you create an Entity Framework model within the class library.

However, these settings will not be used by the executable application calling the library. Instead, these settings may be copied from the library.dll.config file into the app.config or web.config of the caller, so that they may be changed to be specific to the caller, and to the environment into which the caller is deployed.

This is how it has been with .NET since Day 1.

Solution 3

Jon, a lot of opinion has been given that didn't correctly answer your question.

I will give MY OPINION and then tell you how to do exactly what you asked for.

I see no reason why an assembly couldn't have its own config file. Why is the first level of atomicy (is that a real word?) be at the application level? Why not at the solution level? It's an arbitrary, best-guess decision and as such, an OPINION. If you were to write a logging library and wanted to include a configuration file for it, that would be used globally, why couldn't you hook into the built-in settings functionality? We've all done it ... tried to provide "powerful" functionality to other developers. How? By making assumptions that inherently translated to restrictions. That's exactly what MS did with the settings framework, so you do have to "fool it" a little.

To directly answer your question, simply add the configuration file manually (xml) and name it to match your library and to include the "config" extension. Example:

MyDomain.Mylibrary.dll.Config

Next, use the ConfigurationManager to load the file and access settings:

string assemblyPath = new Uri(Assembly.GetExecutingAssembly().CodeBase).AbsolutePath;
Configuration cfg = ConfigurationManager.OpenExeConfiguration(assemblyPath);
string result = cfg.AppSettings.Settings["TEST_SETTING"].Value;

Note that this fully supports the machine.config heierarchy, even though you've explicitly chosen the app config file. In other words, if the setting isn't there, it will resolve higher. Settings will also override machine.config entries.

Solution 4

In fact, the class library you are implementing, is retrieving information from app.config inside the application that is consuming it, so, the most correct way to implement configuration for class libraries at .net in VS is to prepare app.config in the application to configure everything it consumes, like libraries configuration.

I have worked a little with log4net, and I found that the one who prepared the application always had a section for log4net configuration inside main app.config.

I hope you find this information useful.

See you, and post comments about the solution you found.

EDIT:

At the next link you have an app.config with the section for log4net:

http://weblogs.asp.net/tgraham/archive/2007/03/15/a-realistic-log4net-config.aspx

Solution 5

If you want to configure your project logging using log4Net, while using a class library, There is no actual need of any config file. You can configure your log4net logger in a class and can use that class as library.

As log4net provides all the options to configure it.

Please find the code below.

public static void SetLogger(string pathName, string pattern)
        {
            Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();

            PatternLayout patternLayout = new PatternLayout();
            patternLayout.ConversionPattern = pattern;
            patternLayout.ActivateOptions();

            RollingFileAppender roller = new RollingFileAppender();
            roller.AppendToFile = false;
            roller.File = pathName;
            roller.Layout = patternLayout;
            roller.MaxSizeRollBackups = 5;
            roller.MaximumFileSize = "1GB";
            roller.RollingStyle = RollingFileAppender.RollingMode.Size;
            roller.StaticLogFileName = true;
            roller.ActivateOptions();
            hierarchy.Root.AddAppender(roller);

            MemoryAppender memory = new MemoryAppender();
            memory.ActivateOptions();
            hierarchy.Root.AddAppender(memory);

            hierarchy.Root.Level = log4net.Core.Level.Info;
            hierarchy.Configured = true;
      }

Now instead of calling XmlConfigurator.Configure(new FileInfo("app.config")) you can directly call SetLogger with desired path and pattern to set the logger in Global.asax application start function.

And use the below code to log the error.

        public static void getLog(string className, string message)
        {
            log4net.ILog iLOG = LogManager.GetLogger(className);
            iLOG.Error(message);    // Info, Fatal, Warn, Debug
        }

By using following code you need not to write a single line neither in application web.config nor inside the app.config of library.

View more solutions

Comments

[Andrew Barber]

+1 Exactly; The app.config is loaded from the actual program that eventually runs... not the individual class libraries. It is frankly a bit confusing how many don't know this very basic fact.

[Andrew Barber]

It doesn't hurt anything to add an app.config to a library project, no. But neither will it be used.

[Amedio]

Maybe people come from Java language and there you have a log4java.properties and a separate properties file for your application.

[Todd Beaulieu]

I should also mention that you could have a post-build event that renamed app.config to the final filename, but unit tests would copy the app.config file instead of the final final and wouldn't see the settings.

[Todd Beaulieu]

Ugh. Sorry so sloppy. One more thing: you should flag the config file as ALWAYS COPY and set it to CONTENT.

[John Saunders]

-1: Your opinion, per se, is not important. Facts would be important. .NET, since Day 1, was created so that the callers of a library determine the configuration of items within the library. It's the only thing that makes actual sense for configuration, as different callers of the library may need different configurations.

[Laserson]

But what should i do if i need to call webserice functionality from the class library? VS created a default app.config but my application crashed when trying to call webservice function - it can not find config entries...

[John Saunders]

You have to copy the elements that were placed in the class library app.config into the app.config or web.config of the caller of the class library. This allows the caller to be in control of the configuration. For instance, the caller now can change the URL of the service that your class library calls, and your class library won't even know about the change.

[MacGyver]

I have a Selenium WebDriver class library that I run from NUnit for all of my test cases. I'd rather not have to worry about setting configuration in NUnit. How can I bend and twist to get this done? :-)

[MacGyver]

Figured it out... If using NUnit, name your app.config file with the same name as your *.nunit project filename. So for example, if you called your project "ClassLibraryA.nunit", then name your class library configuration file "ClassLibraryA.config". They also need to reside in the same folder/directory. NUnit is actually using this as the main configuration file .... add a reference to System.Configuration (in .NET tab) .... and use this code: string settingValue = ConfigurationManager.AppSettings["settingName"];

[Admin]

@John Saunders: "may need" are exactly the right words. So there might be situations where configuration settings differ only per server (e.g. connection strings) and it is more convenient to have the dll have it's own configuration than copy it plenty times around for every assembly that uses the dll. In my opinion Microsofts/.NET preferred usage is not a holy grail. It depends really, what is most convenient in a deployment scenario. There is no need to tell Todd off, his opinion is as important as yours or Microsofts.

[Tomas Jansson]

How would you recommend setting things up when having integration tests? For me it seems logical to have an app.config in that test library with the connection string.

[wired_in]

@JohnSaunders "different callers of the library may need different configurations." Exactly, they "may" need different configurations, and your logic makes perfect sense in all cases where the configuration does depend on the caller. But there are several cases where the configuration is used internally for the class library, and the configuration is exactly the same, no matter what the caller is. If you have 10 applications consuming a library, it has to be worse to copy and paste the exact same configuration into 10 config files.

[nicodemus13]

@ToddBeaulieu: I think the word you want is 'atomicity'.

[crush]

I'm really interested in this solution - it sounds ideal to me. It makes sense that the library would carry default settings, while the application would have the ability to override them. Would you expand on how settings can be propagated from the library's app.config to the executing assembly's app.config, or direct me to a relevant resource?

[John Saunders]

@crush: It's called "copy and paste". The strongly-typed Settings feature of .NET can help a bit, as it bakes default values into the assembly.

[Voltage Spike]

What if you can't configure the application because you don't own it.

[Davatar]

In a plugin architecture, it makes indeed sense if all plugins have their own config file.

[saurav]

i felt this is the best answer...rather than discussing whether configuration file should be allowed for a library...this answer answers the OP's question of using Log4net

[RMuesi]

@wired_in "But there are several cases where the configuration is used internally for the class library, and the configuration is exactly the same, no matter what the caller is." Sounds like this isn't configuration at all. If it never changed, then why does it need to be configured? I'd say make that stuff const or readonly variables, instead of configurations in a config file.

[RMuesi]

@user1531508 As someone who's had to take over "special" code that didn't want to follow Microsoft/.Net "preferred usage" (aka best practices) I'd say no. Following best practices is a holy grail compared to the alternative. And no, Todd's opinion is not as important as Microsoft's.

[wired_in]

@RMuesi Noone said it never changes, just that it doesn't depend on the caller of the library. Config can change depending on whether you are debugging the library versus a production release. It can change depending on the environment you are building for, etc.

[binki]

@AndrewBarber It’ll be used in a test project. See stackoverflow.com/a/31389495

[binki]

@MacGyver When I run unit tests (MSTest), I just add a normal app.config file to my project and it gets copied to bin/$(Configuration)/$(AssemblyName).dll.config. The test runner loads it in such a way that the test runner uses its own config but my own code sees my own config.

[binki]

If you name your file app.config it automatically gets renamed correctly by VS. At least with version 2013 (IIRC) and newer. Did this really not happen in the past?

[binki]

Even though the question used log4net as an example, the actual question is about configs in general. I’d say that answers about log4net are actually irrelevant.

[Justin]

In our use case, having the library use its own .config file makes sense. We have created a C# library that is accessed via COM+ through a legacy ASP application. there is no "app.config" because the application using the library is not .NET. I'm going to give this a try and see if it meets our requirements.

[Mircea Ion]

There's no painful bending and twisting needed to use the app.config of a class library. It can't be use as it is but throughout development it is useful. Plus it doesn't directly answer the question: "adding an app.config manually bad, good are there any ways of doing it in a non manual way?".

[JasonDWilson]

The accepted answer s is totally incorrect. Been using app.config files in class libraries for years.

[blackman]

For another view, sometimes you need to add ".config" or ".runsettings" files into your class libraries like UnitTestClassLibrary. Then, the simplest way is to add a notepad into the Class library folder and Save As in the format you wish. Then add it as an Existing item to the Class Library.

[Spongebob Comrade]

Thanks this is exactly what I wanted. And it is really logical.