Home > Articles > Programming > Windows Programming

  • Print
  • + Share This
This chapter is from the book

Persistent Storage

There are many techniques from which to choose. The following is a list of a number of them, although the list is not exhaustive:

  • Using the usual database
  • Using the Registry
  • Using Active Directory
  • Using Object Construction (OC)
  • Using a .config file

Let's discuss each of these techniques a little further. When you read this discussion, please keep in mind that it's not my intention that the persistent storage should be hit each time the configuration data is needed; rather, it should be only hit once or at least infrequently. (The second part of the solution, how to access the configuration data in transient storage, will further explain this.)

Using the Usual Database

The first technique, using the usual database for holding configuration data, might seem a bit strange, but this is often a really good idea. The good thing about it is that you have one centralized place for the stored configuration data, even if you have a cluster of application servers. You also have the protection of transactions if that is a requirement for you in this case. One drawback could be that you waste some scarce resources when you have to hit the database for fetching configuration data, too. This is not usually a problem because you will rarely hit persistent storage for configuration data, but it's still something to think about.

I know, I know. Storing connection strings in the database is not a good solution, at least not if the connection strings describe how to reach the database.

Using the Registry

I have to confess that I used .ini files long after the Registry was introduced, but after a while I started to like the solution that the Registry represents. (Sure, I see the problems with it, too, but I still like it.) As you know, Microsoft has now more or less put the Registry on the legacy list, and you're not supposed to use it anymore, mainly because it creates a more difficult deployment situation compared to using .config files instead, for example.

You will normally use the Registry class in the Microsoft.Win32 namespace as the entry point when working with the Registry in .NET.

Using Active Directory

You can think of Active Directory as the "Registry," but it spans all the machines in your network and all the information found on all machines. For many developers, it has become a popular place for storing connection strings and similar items.

It was hard to work with Active Directory (or, rather, ADSI) from VB6, but it's now much easier in .NET. You start by using the DirectoryEntry class of the System.DirectoryServices namespace for finding information in the Active Directory.

Using Object Construction (OC)

COM+ 1.0 made it possible to store a string in the COM+ catalog for a specific component and then retrieve that value when an object of the component was activated. This is still a useful and viable solution for serviced components. As you will see in the next section, I see OC both as a solution for the persistent storage and also as an access mechanism. However, you can also use it just as a persistent storage mechanism so that when you find that you need to read the value from persistent storage, you instantiate an object of the component that is using OC, grab the value, and store it in transient storage.

Listing 1 shows code that illustrates how OC can be used for serviced components. As you can see there, I override the Construct() method, and the parameter called constructString is the string that can be changed in the Component Services Explorer.

Listing 1: Example Showing How to Use OC in a Serviced Component

Imports System.EnterpriseServices
(Default:="Hello world")> _
Public Class OcTest
  Inherits ServicedComponent
  Private m_Data As String

  Protected Overrides Sub Construct _
  (ByVal constructString As String)
    m_Data = constructString
  End Sub

  'And some more methods...

End Class

Using a .config File

.config files are files in XML format for holding configuration data. They were introduced in .NET as a solution for helping with XCOPY deployment. (With XCOPY deployment, a single XCOPY command deploys an application at another server. There are no Registry settings that have to be written, no registrations of DLLs, and so on.)

.config files can be used for configuring the built-in tracing solution in .NET, as well as your own tracing solution.

Unfortunately, .config files don't work so well with serviced components. .config files are for EXEs rather than DLLs, and that is pretty natural. Consider a DLL that is shared by several EXEs. It should probably be possible to use different settings for each EXE. So far, so good.

The problem is that COM+ server applications are executed by the surrogate EXE called Dllhost, and there is only one EXE for all COM+ applications, so it's problematic to use the settings for, say, built-in tracing in the .config file. It's also the case that Dllhost isn't written in managed code, and it doesn't know that it should load a .config at all. This is why it's also problematic to use the System.Configuration namespace. Finally, you will have to keep the .config file in the same directory as the Dllhost EXE, and it's located in your system32 directory. So much for XCOPY deployment.


Yet another problem with using .config files is that the built-in tracing solution won't refresh the values found in the .config file. Instead, the .config file is read only once for the process. This is not a big problem for a Windows Forms application, but it might be a huge problem for a COM+ application.

Instead, I have decided to use a custom approach for reading .config files from COM+ applications. I use the format of .config files, but I give them the name of the DLL to which they belong (same value as for AssemblyGlobal.exeOrDllName constant). First I thought about having the .config files together with the DLLs, but the GAC creates a problem for this. Therefore, I decided that the .config files will be stored in one specific directory. I have decided to use c:\complusapps. Then I use custom code for parsing the .config files, so this approach is quite easy after all.


An interesting white paper that is not only related to adding support for debugging but also about configuration data is Amitabh Srivastava and Edward Jezierski's "Monitoring in .NET Distributed Application Design." The paper discusses Windows Management Instrumentation (WMI) and how it can be used for updating .config files, which is just another advantage of the technique of .config files.

  • + Share This
  • 🔖 Save To Your Account