Heikki Ritvanen https://docs.microsoft.com/archive/blogs/heikkiri/feed.xml Collection Of Things That Keep Me Going At Night Time While Everyone Else Is A Sleep. Wed, 17 Apr 2019 03:48:48 GMT en-US hourly 1 Second Attempt On Blogging https://docs.microsoft.com/archive/blogs/heikkiri/second-attempt-on-blogging Tue, 17 Jul 2012 15:48:33 GMT https://blogs.msdn.microsoft.com/heikkiri/2012/07/17/second-attempt-on-blogging/ I have never been confused with Shakespeare, rather been known for my Finglish with car analogies. So, I am sure that you will encounter few of them if you read my posts. I think that one of my main reasons for this is that I have worked in support over 10 years. Most of the time, I have spent in the server world debugging various application. Microsoft or custom. Before joining the Microsoft support, I worked as a software developer and I truly enjoy it. So, over the years I have come up with various ways to either accomplish a task or just to prove a point that it can be done. Now, as getting older I don't seem to remember those things anymore as I used to; but if you ask when I change my last diaper. I can probably tell it to you to the minute.
 
But, I have also come to realizing the knowledge is power. Not as much the knowledge that you hold, but the knowledge that you can enpower others to be successful in their journey. I think that is the primary reason why I have decided to give this 'blogging' a second try. Maybe, the information this will save one persons time of going around and losing hair like I have.

]]> Converting Hex String To Corresponding Byte Array Using C# https://docs.microsoft.com/archive/blogs/heikkiri/converting-hex-string-to-corresponding-byte-array-using-c Tue, 17 Jul 2012 15:32:00 GMT https://blogs.msdn.microsoft.com/heikkiri/2012/07/17/converting-hex-string-to-corresponding-byte-array-using-c/ I came across an issue where I needed to convert a string representing HEX value into corresponding byte array. I know that there are various solutions that all accomplish the same task: Take A String And Convert It To Equivalent Byte Array.

For example a string value: 0x0123456789ABCDEF would be 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD and 0xEF represented in a byte array. The basic .NET functions would give you the byte array of the actualy ASCII characters, and not the binary value that they represent. There was all kind of solutions out there. Some declared to be faster than other, or simply the fastest. I am sure the solution that I came up with is not prettiest or the most effcient. But, it is my solution that I came up with. I am sure that it has been thought before but have not seen any post that are quite a like it. I think that it is pretty good solution for what I wanted to accomplish. That said. I love learning. So, if you find a problem or have an idea to improve it. Please! All feedback is welcomed: The Good, The Bad and The Ugly.

The Problem

Convert a string it to a byte array representing the actual text values of each byte.

Considerations

I spent some time thinking about different things that I would have to take into consideration when doing the conversion of the string to the byte array.

Special Cases: Input is valid, and expected but it creates special handling conditions.

  1. Is the input string null or empty
  2. The string starts with the HEX indicator string '0x'.
  3. Is the leading '0' dropped from the string.
  4. The casing of the letter, they can be upper, lower or mixed casing.

Error Checking: We live in a World where we can't trust any, not even our input string. So, I need to have some type of validation in place for the input.

  1. Does the string contain characters that are not valid alphanumeric values: 0-9 and A-F.

Approach

Taking into account the factors that I came up with, I came up with the following approach.

To handle the case of null or empty input, I would return an empty array. To avoid, unnecessary allocations I created a static, readonly empty byte array that I would return to the caller.

private static readonly byte[] Empty = new byte[0];

Once I have determined that I actually have some type of string. I would handle rest of conditions during the conversion, except the 'dropped' leading zero ('0') which I would handle before the actual conversion.

For the actual conversion I decided to take a forked solution: reading 2 characters at a time. The upper and lower nibble, which I would the convert individual to the equivalent byte value. This would be the time to validate that the received character is actually an alphanumeric character.

My Solution

Now to the fun part. Coding. I would break my solution into 2 distinct functions: ConvertToByteArray and FromCharacterToByte.

ConvertToByteArray: This function would be the public function exposed to the caller. It would be responsible for doing basic input validation, handle the items 1, 2 and 3 from the special cases that I had identified as well as constructing the byte array to be returned to the caller.

        public static byte[] ConvertToByteArray(string value)
        {
            byte[] bytes = null;
            if (String.IsNullOrEmpty(value))
                bytes = Empty;
            else
            {
                int string_length = value.Length;
                int character_index = (value.StartsWith("0x", StringComparison.Ordinal)) ? 2 : 0; // Does the string define leading HEX indicator '0x'. Adjust starting index accordingly.               
                int number_of_characters = string_length - character_index;

                bool add_leading_zero = false;
                if (0 != (number_of_characters % 2))
                {
                    add_leading_zero = true;

                    number_of_characters += 1;  // Leading '0' has been striped from the string presentation.
                }

                bytes = new byte[number_of_characters / 2]; // Initialize our byte array to hold the converted string.

                int write_index = 0;
                if (add_leading_zero)
                {
                    bytes[write_index++] = FromCharacterToByte(value[character_index], character_index);
                    character_index += 1;
                }

                for (int read_index = character_index; read_index < value.Length; read_index += 2)
                {
                    byte upper = FromCharacterToByte(value[read_index], read_index, 4);
                    byte lower = FromCharacterToByte(value[read_index + 1], read_index + 1);

                    bytes[write_index++] = (byte)(upper | lower);
                }
            }

            return bytes;
        }

FromCharacterToByte: This function would be the private work horse function. The main responsiblity would be the convert the character in hand to the equivalent byte value. In case of non-numeric value, this function would handle the casing and validation of the character. Now, to reuse this code the function would have to take into account the nibble order and shift the value accordingly.

        private static byte FromCharacterToByte(char character, int index, int shift = 0)
        {
            byte value = (byte)character;
            if (((0x40 < value) && (0x47 > value)) || ((0x60 < value) && (0x67 > value)))
            {
                if (0x40 == (0x40 & value))
                {
                    if (0x20 == (0x20 & value))
                        value = (byte)(((value + 0xA) - 0x61) << shift);
                    else
                        value = (byte)(((value + 0xA) - 0x41) << shift);
                }
            }
            else if ((0x29 < value) && (0x40 > value))
                value = (byte)((value - 0x30) << shift);
            else
                throw new InvalidOperationException(String.Format("Character '{0}' at index '{1}' is not valid alphanumeric character.", character, index));

            return value;
        }

Now, I understand that this function take a simple string as input. For now this will do the trick and/if the time comes for me to read the value from a file. Support for stream is easy to add.

Usage

The calling this function is very simple. I created a class named 'StringConverter' to hold them.

byte[] bytes = StringConverter.ConvertToByteArray("0x0123456789AbCdEf");

Performance

As always, I am curious how it works with large string. I created a text file and repeated the value '0123456789AbCdEf' over and over and over again. So many times that I ended up with a 18.5MB file. Due to the lack of support for reading a stream, I simply load the file and read the whole string into memory using StreamReader. Then simply pass it to the function.

I was actually suprised with the performance results that I received.

Including the reading the content of the file, the conversion completed in just about 500ms (0.5 seconds). Not bad.

Now, if I moved the read outside the timer code. Read the massive string into a variable variable and passed it into the conversion function. The total time taken dropped to consistently to around 190ms (0.19 seconds).

Conclussion

The results are suprising, and not too bad for about an hours worth of work. Converting a 18.5MB string into equivalent byte array using .NET in less than 200ms.

 

 

 

 

 

]]> So you think that your ServicePoint is out of connections??? https://docs.microsoft.com/archive/blogs/heikkiri/so-you-think-that-your-servicepoint-is-out-of-connections Fri, 11 Nov 2005 11:23:00 GMT https://blogs.msdn.microsoft.com/heikkiri/2005/11/11/so-you-think-that-your-servicepoint-is-out-of-connections/ It seems to be an issue that many people keep hitting: running out of connections. I have seen cases where the <maxConnections> value is just pumped up randomly the values per KB821268. Wouldn't it be nice to actually be able to tell if that is truly the case?? :) It is actually easier than many think, the tools that you need to do this are all available on the web (Debugging Tools For Windows) and SOS.dll which ships with the .NET framework and is located in the framework folder (%WinDir%\Microsoft.Net\Framework\v1.1.4322).

So, how do I do it then? First you need to have the debugging tools install on your machine. Then you will need to generate a hang dump of the process that you think is running out of connection. You can use the ADPLUS.vbs script which is shipped with debugging tools that you just installed. So, to get hang dump of the process just do the following:

1) Open command prompt and navigate to the folder that you installed the tools to.

2) To generate hang dump run one the following command which ever suites you the best: adplus.vbs -quiet -hang -p <PID of the process> or adplus.vbs -quiet -hang -pn <Process Name>

This will generate a hang mode folder for you which contains the dump file of your process. Now in the same command prompt type windbg.exe - which will launch the UI debugger. In the file menu select to 'Open Crash Dump...' and select the .dmp file which was created in step 2 above.

So now you have the dump open - GREAT, so far so good!

First of all we can fix the symbol path simply running !symfix - you can specify folder after this if you prefer to store the symbols to specific location otherwise they will be stored to the folder of the debugger.

Now when you have the hang dump open, we need to load the SOS.dll which allows us to exam the manage threads and what is going on them. To load sos.dll you need to execute the following command.

.load c:\windows\microsoft.net\framework\v1.1.4322\sos.dll

I find the following command to be the easiest way to get a glance of the processes managed threads and what they are doing. You may agree or disagree ... make you pick!

~*e !ClrStack

This will give you output of all the managed stack in the process. With a quick look I can tell that ie the thread below has a connection and is just waiting a response from the server.

ESP       EIP    
033dfab4  7c90eb94 [FRAME: ECallMethodFrame] [DEFAULT] Boolean System.Threading.WaitHandle.WaitOneNative(I,UI4,Boolean)
033dfac8  799e4811 [DEFAULT] [hasThis] Boolean System.Threading.WaitHandle.WaitOne(I4,Boolean)
033dfafc  7b259381 [DEFAULT] [hasThis] Class System.Net.WebResponse System.Net.HttpWebRequest.GetResponse()
033dfb24  02ee6769 [DEFAULT] [hasThis] Class System.Net.WebResponse System.Web.Services.Protocols.WebClientProtocol.GetWebResponse(Class System.Net.WebRequest)
033dfb54  02ee6726 [DEFAULT] [hasThis] Class System.Net.WebResponse System.Web.Services.Protocols.HttpWebClientProtocol.GetWebResponse(Class System.Net.WebRequest)
033dfb58  02ee4ff0 [DEFAULT] [hasThis] SZArray Object System.Web.Services.Protocols.SoapHttpClientProtocol.Invoke(String,SZArray Object)
033dfba0  02ee4ef9 [DEFAULT] [hasThis] String Demo.HelloWorld(String) at [+0x49] [+0x0]
033dfbc8  02ee0116 [DEFAULT] Void DotNetDelete.Class1.CallWebService(Object) at [+0x4e] [+0x11]

But the point of this blog is to figure out if I am running out of connections. So, I found another thread from the output which looked like this:

ESP       EIP    
0448f268  7c90eb94 [FRAME: ECallMethodFrame] [DEFAULT] Boolean System.Threading.WaitHandle.WaitOneNative(I,UI4,Boolean)
0448f27c  799e4811 [DEFAULT] [hasThis] Boolean System.Threading.WaitHandle.WaitOne(I4,Boolean)
0448f2b0  7b258b88 [DEFAULT] [hasThis] Class System.IO.Stream System.Net.HttpWebRequest.GetRequestStream()
0448f2d8  02f14fa2 [DEFAULT] [hasThis] SZArray Object System.Web.Services.Protocols.SoapHttpClientProtocol.Invoke(String,SZArray Object)
0448f320  02f14ef9 [DEFAULT] [hasThis] String Demo.HelloWorld(String) at [+0x49] [+0x0]
0448f348  02f10116 [DEFAULT] Void DotNetDelete.Class1.CallWebService(Object)

If you see many thread in you dump file - then you are most likely running out of connections as this thread is trying to obtain a connection to the target web service.

So, lets take a look at the thread which is blocked ... you can switch to this thread by running command: ~<Thread Number>s

So, this is simple a sync request to a some backend web service. Hence, you should be able to find the corresponding System.Net.HttpWebRequest on the stack. To do this you can run a simple command from the sos.dll called DumpStackObjects. So write !DumpStackObjects on the command window and press enter. This will show you all the objects which are found on the stack, note that some of them can be the same object. Below is a simple sample (removed some lines for clarity)

0:023> !DumpStackObjects
ESP/REG  Object   Name
044df134 00b35688 System.String    -
044df220 00ca9314 System.Net.LazyAsyncResult
044df224 00b4672c System.String    Heikki
044df234 00ca9314 System.Net.LazyAsyncResult
044df25c 00ca941c System.Threading.ManualResetEvent
044df260 00b4672c System.String    Heikki
044df27c 00b4672c System.String    Heikki
044df280 00ca8b24 System.Net.HttpWebRequest
044df284 00ca9314 System.Net.LazyAsyncResult

So from the output above I can see that my HttpWebRequest object is located at 0x00ca8b24. To look at this object run command !DumpObj with the address of your request object.

This will show you the whole System.Net.HttpWebRequest object and all of its members and values.

0:023> !DumpObj 00ca8b24
Name: System.Net.HttpWebRequest
MethodTable 0x7b349a6c
EEClass 0x7b349d50
Size 204(0xcc) bytes
mdToken: 020001fa  (c:\windows\assembly\gac\system\1.0.5000.0__b77a5c561934e089\system.dll)
FieldDesc*: 7b349db4
      MT    Field   Offset                 Type       Attr    Value Name
79b95814  40000b6        4                CLASS   instance 00000000 __identity
7b348524  4000f0c       b4                CLASS     static 00c2e8f8 s_PrefixList
7b349a6c  4000f30       10                CLASS   instance 00ca9314 _WriteAResult
7b349a6c  4000f31       14                CLASS   instance 00000000 _ReadAResult
7b349a6c  4000f32       18                CLASS   instance 00000000 _ContinueDelegate
7b349a6c  4000f33       1c                CLASS   instance 00c95558 _ServicePoint
7b349a6c  4000f34       20                CLASS   instance 00ca93dc _WriteEvent
7b349a6c  4000f35       24                CLASS   instance 00000000 _WriteInProgressEvent
7b349a6c  4000f36       b4       System.Boolean   instance        0 _HaveResponse
7b349a6c  4000f37       b5       System.Boolean   instance        0 _OnceFailed
7b349a6c  4000f38       b6       System.Boolean   instance        0 _WriteNotifed
7b349a6c  4000f39       28                CLASS   instance 00000000 _HttpResponse
7b349a6c  4000f3a       2c                CLASS   instance 00000000 _ResponseException
7b349a6c  4000f3b       30                CLASS   instance 00000000 _CoreResponse
7b349a6c  4000f3e       34                CLASS   instance 00c794d4 _Verb
7b349a6c  4000f3f       38                CLASS   instance 00c794d4 _OriginVerb
7b349a6c  4000f40       3c                CLASS   instance 00ca8bfc _HttpRequestHeaders
7b349a6c  4000f41       40                CLASS   instance 00000000 _WriteBuffer
7b349a6c  4000f42       94         System.Int32   instance        2 _HttpWriteMode
7b349a6c  4000f43       b7       System.Boolean   instance        0 _AllowAutoRedirect
7b349a6c  4000f44       44                CLASS   instance 00ca8530 _Uri
7b349a6c  4000f45       48                CLASS   instance 00ca8530 _OriginUri
7b349a6c  4000f46       4c                CLASS   instance 00000000 _ChallengedUri
7b349a6c  4000f47       50                CLASS   instance 00000000 _ChallengedSpn
7b349a6c  4000f48       54                CLASS   instance 00000000 _MediaType
7b349a6c  4000f49        8         System.Int64   instance -1 _ContentLength
7b349a6c  4000f4a       58                CLASS   instance 00c573c4 _Version
7b349a6c  4000f4b       5c                CLASS   instance 00000000 _DestinationVersion
7b349a6c  4000f4c       b8       System.Boolean   instance        0 _ProxyUserSet
7b349a6c  4000f4d       60                CLASS   instance 00c6d994 _Proxy
7b349a6c  4000f4e       64                CLASS   instance 00000000 _ConnectionGroupName
7b349a6c  4000f4f       b9       System.Boolean   instance        0 _PreAuthenticate
7b349a6c  4000f50       68                CLASS   instance 00ca8ec4 _ProxyAuthenticationState
7b349a6c  4000f51       6c                CLASS   instance 00ca8edc _ServerAuthenticationState
7b349a6c  4000f52       70                CLASS   instance 00000000 _CurrentAuthenticationState
7b349a6c  4000f53       74                CLASS   instance 00000000 _AuthInfo
7b349a6c  4000f54       ba       System.Boolean   instance        1 _RequestSubmitted
7b349a6c  4000f55       78                CLASS   instance 00c96a3c _AbortDelegate
7b349a6c  4000f56       bb       System.Boolean   instance        0 _Abort
7b349a6c  4000f57       bc       System.Boolean   instance        1 _ExpectContinue
7b349a6c  4000f58       bd       System.Boolean   instance        1 _KeepAlive
7b349a6c  4000f59       be       System.Boolean   instance        1 _Pipelined
7b349a6c  4000f5a       7c                CLASS   instance 00000000 _SubmitWriteStream
7b349a6c  4000f5b       80                CLASS   instance 00000000 _OldSubmitWriteStream
7b349a6c  4000f5c       bf       System.Boolean   instance        1 _AllowWriteStreamBuffering
7b349a6c  4000f5d       c0       System.Boolean   instance        1 _WriteStreamRetrieved
7b349a6c  4000f5e       98         System.Int32   instance       50 _MaximumAllowedRedirections
7b349a6c  4000f5f       9c         System.Int32   instance        0 _AutoRedirects
7b349a6c  4000f60       c1       System.Boolean   instance        0 _Saw100Continue
7b349a6c  4000f61       c2       System.Boolean   instance        0 _AcceptContinue
7b349a6c  4000f62       a0         System.Int32   instance        0 _RerequestCount
7b349a6c  4000f63       a4         System.Int32   instance   100000 _Timeout
7b349a6c  4000f64       a8         System.Int32   instance   300000 _ReadWriteTimeout
7b349a6c  4000f65       84                CLASS   instance 00ca8bf0 _ClientCertificates
7b349a6c  4000f66       88                CLASS   instance 00000000 _CookieContainer
7b349a6c  4000f67       c3       System.Boolean   instance        0 _LockConnection
7b349a6c  4000f69       ac         System.Int32   instance       64 _MaximumResponseHeadersLength
7b349a6c  4000f6b       8c                CLASS   instance 00000000 _UnlockDelegate
7b349a6c  4000f6c       90                CLASS   instance 00000000 m_DelegationFix
7b349a6c  4000f6d       c4       System.Boolean   instance        0 _UnsafeAuthenticatedConnectionSharing
7b349a6c  4000f6e       c5       System.Boolean   instance        0 _WriteInProgress
7b349a6c  4000f6f       b0         System.Int32   instance        0 m_HashCode
7b349a6c  4000f70       c6       System.Boolean   instance        0 m_ComputedHashCode
7b349a6c  4000f3c      2a4                CLASS     static 00c3a640 HttpBytes
7b349a6c  4000f3d      2a8                CLASS     static 00c3a654 m_EndWriteHeaders_Part2Callback
7b349a6c  4000f68      2b0         System.Int32     static 00000040 _DefaultMaximumResponseHeadersLength
7b349a6c  4000f6a      2ac                CLASS     static 00c4ba24 s_NetConfig

It is does not require rocket science to figure that your ServicePoint is stored in the _ServicePoint member. So, run the same !DumpObj for that object and you get information about the ServicePoint.

0:023> !DumpObj 00c95558
Name: System.Net.ServicePoint
MethodTable 0x7b352ca4
EEClass 0x7b352db4
Size 92(0x5c) bytes
mdToken: 02000247  (c:\windows\assembly\gac\system\1.0.5000.0__b77a5c561934e089\system.dll)
FieldDesc*: 7b352e18
      MT    Field   Offset                 Type       Attr    Value Name
7b352ca4  400112d       48       System.Boolean   instance        0 m_ProxyServicePoint
7b352ca4  400112e       49       System.Boolean   instance        0 m_UserChangedLimit
7b352ca4  400112f       2c         System.Int32   instance        2 m_ConnectionLimit
7b352ca4  4001130       30         System.Int32   instance        2 m_ConnectionMode
7b352ca4  4001131       4a       System.Boolean   instance        0 m_SupportsPipelining
7b352ca4  4001132        4                CLASS   instance 00c955b4 m_ConnectionGroupList
7b352ca4  4001133        8                CLASS   instance 00c1d97c m_Address
7b352ca4  4001134       34         System.Int32   instance   900000 m_MaxIdleTime
7b352ca4  4001135       50            VALUETYPE   instance start at 00c955a8 m_ExpiresAt
7b352ca4  4001136        c                CLASS   instance 00c1d9e4 m_ConnectionName
7b352ca4  4001137       10                CLASS   instance 00cac0e0 m_IPHostEntryInfos
7b352ca4  4001138       38         System.Int32   instance        0 m_CurrentAddressInfoIndex
7b352ca4  4001139       3c         System.Int32   instance        2 m_ConnectionsSinceDns
7b352ca4  400113a       40         System.Int32   instance        2 m_CurrentConnections
7b352ca4  400113b       14                CLASS   instance 00000000 m_ServerCertificate
7b352ca4  400113c       18                CLASS   instance 00000000 m_ClientCertificate
7b352ca4  400113d       4b       System.Boolean   instance        1 m_UseNagleAlgorithm
7b352ca4  400113e       4c       System.Boolean   instance        1 m_Expect100Continue
7b352ca4  400113f       1c                CLASS   instance 00c7a1b8 m_LookupString
7b352ca4  4001140       20                CLASS   instance 00cac0ac m_CachedRemoteIPAddressInfo
7b352ca4  4001141       24                CLASS   instance 00000000 m_Version
7b352ca4  4001142       4d       System.Boolean   instance        1 m_Understands100Continue
7b352ca4  4001143       28                CLASS   instance 00c956c0 DnsLock
7b352ca4  4001144       44         System.Int32   instance        0 m_HashCode
7b352ca4  4001145       4e       System.Boolean   instance        0 m_ComputedHashCode

Couple things about this that I would like point out. The value which you have defined for <maxConnections> can be found from the m_ConnectionLimit value. In the sample above it is 2, so there can be only 2 threads connected to the defined host for this ServicePoint. Well, this can be a problem as there are 2 connection (m_CurrentConnections) though this does not mean that 2 are active, but you should not be able to find from all the stacks 2 threads which are executing request and others are waiting for the connection.

Why is this important? Well you MAY think that you are going to your target at http://myserver/Service.asmx, but that may NOT be the case as the connection is defined by the service point. If you have a proxy defined on the client your request can be assigned a proxy service point (Boolean value m_ProxyServicePoint 1 = true / 0 = false). So, if you define your <maxConnections> to specifically for your endpoint and you get assigned a proxy service point you can still see bottleneck getting connection!!!! Therefore, no matter how high your maxConnection value for your endpoint is, but if your proxy has 2 and your request gets routed through the proxy - you will bottleneck!

I hope this will help you to troubleshoot your web service performance issues with connections!!!

Happy Debugging !!!

 

]]> Custom App.Config file for ServicedComponent https://docs.microsoft.com/archive/blogs/heikkiri/custom-app-config-file-for-servicedcomponent Thu, 10 Nov 2005 17:33:00 GMT https://blogs.msdn.microsoft.com/heikkiri/2005/11/10/custom-app-config-file-for-servicedcomponent/ I have come across this question few times this week so I though to start this whole 'blogging' with. Developers want to take advantage of the app.config file for the COM+ applications, but they are not available for dll? What now? Well as the hosting process is dllhost.exe, one could create app.config file for dllhost and put it in the %windir%\System32. Not really good solution is it? What is now you install something on the machine and someone thought about the same thing and they copy there app.config file there. Your application breaks...

Windows XP and 2003 provides a nice solution for this using the 'Application Base Directory' property of the COM+ Application.

So how to use it now? First step is to create an application.manifest file and copy it to the folder that you want to use as the base for your application. The content of the file is very simple, just copy the text from below to a notepad and save it as 'application.manifest'.

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"/>

Now, create your app.config file for example something like below.

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
 <appSettings>
  <add key="ConfigData" value="My Custom AppSetting!" />
 </appSettings>
</configuration>

Save this file to the same folder as the manifest file, NOTE the name of this file needs to be application.config!!!!

Now you are ready to configure your COM+ application. So, open you Component Services MMC and find your application.

After you have located your COM+ application, right click the application and go to 'Properties' and 'Activation' Tab.

At the bottom of this tab, you should be able to find an option for 'Application Root Directory'. Browse or copy paste the path that you saved the 2 files created earlier, click Apply, click OK and you are done!

Note: If you application is running you need to stop it for the change to take place and the AppDomain of the components BaseDirectory will return you this value!

Now, in your serviced component you can access the application specific configuration file by simply using System.Configuration.ConfigurationSettings.AppSettings["ConfigData"].

]]>