VS2008 / .NET 3.5

QuickTip: Attach the VS Debugger to IIS’s Worker Process in a single keystroke

ChrisD — Fri, 30 Oct 2009 13:45:11 GMT

I’ve been spending a lot of time lately debugging through some web-hosted applications. Some of these applications are hosted by Visual Studio’s own internal web server (Cassini), and others are hosted by my local instance of IIS.

Web projects hosted locally get automatic attached to the VS debugger when you press F5. Projects hosted under IIS do not. In order to debug IIS hosted projects, you must attach the Visual Studio debugger to the IIS worker process (aspnet_wp.exe or w3wp.exe) manually.

Traditionally, you attach by selecting Attach To Process from the Debug menu, scrolling the list of processes until you find the worker process and then clicking “Attach”.

Thanks to this handy macro I found by HologramX at snipplr.com, I’m able to attach with a single keystroke:

To add this macro to your environment, Tools > Macro IDE > Add new item to MyMacros > Select Module, Name 'AttachToWebServer' > Copy/paste code.

Imports System
Imports EnvDTE80
Imports System.Diagnostics

Public Module AttachToWebServer

    Public Sub AttachToWebServer()

        Dim AspNetWp As String = "aspnet_wp.exe"
        Dim W3WP As String = "w3wp.exe"

        If Not (AttachToProcess(AspNetWp)) Then
            If Not AttachToProcess(W3WP) Then
                System.Windows.Forms.MessageBox.Show(String.Format("Process {0} or {1} Cannot Be Found", AspNetWp, W3WP), "Attach To Web Server Macro")
            End If
        End If

    End Sub

    Public Function AttachToProcess(ByVal ProcessName As String) As Boolean

        Dim Processes As EnvDTE.Processes = DTE.Debugger.LocalProcesses
        Dim Process As EnvDTE.Process
        Dim ProcessFound As Boolean = False

        For Each Process In Processes
            If (Process.Name.Substring(Process.Name.LastIndexOf("\") + 1) = ProcessName) Then
                Process.Attach()
                ProcessFound = True
            End If
        Next

        AttachToProcess = ProcessFound

    End Function

End Module

To set as a keyboard shortcut go to Tools > Options > Keyboard, and search for the name of the macro (AttachToWebServer) and then assign a keyboard shortcut.

IIS-Attached Debugging is now one keystroke away.

QuickTip: Did You Know??? Auto-Adding Dictionary entries

ChrisD — Mon, 19 Oct 2009 09:21:52 GMT

When adding an item to a dictionary, I always thought you had to use the Add() method, like this:

string key = "MyKey";
int value = 20;
var myDictionary = new Dictionary<string, int>();
myDictionary.Add(key, value);

Apparently, you can directly reference it in the collection, and if the key doesn’t exist, its auto-added to the collection

string key = "MyKey";
int value = 20;
var myDictionary = new Dictionary<string, int>();
myDictionary[key] = value;

most likely you already knew this. I did not. Its the little things I guess.

Exception & Fault Handling in WCF

ChrisD — Thu, 09 Jul 2009 08:12:00 GMT

I am considering writing a policy based error handler for WCF. The Error handler would be registered with the service host, and would automatically log all exceptions. WCF Services would “opt-in”/register for this error handler by a custom attribute.

Deciding how to handle the unhandled exceptions is the policy part. The policy could state which exception types to convert to handled WCF faults, which exception types to map to different fault/exception types, which exceptions to obfuscate and which ones to allow to return to the caller (faulting the service channel).

I’m thinking the policy would be handled via configuration, so the rules could be changed without requiring code drops.

The policy-driven approach is similar to the enterprise library exception handling approach, but I think I could deliver 90% of the functionality with sufficiently less effort than is required by the entlib approach.

Would anyone find value in this approach and solution?

QuickTip - Flatten strings to a comma delimited list

ChrisD — Tue, 23 Dec 2008 07:03:25 GMT

Ever need to convert a List of strings in a comma delimited list? In the past I'd write a foreach loop. Something like:

public static string FlattenStringList(List<string> items)
     {
         StringBuilder str = new StringBuilder();
         bool firstOne = false;
         foreach (string item in items)
         {
             if (!firstOne)
                 str.Append(",");
             else
                 firstOne = false;
             str.Append(item);
         }
         return str.ToString();
         
     }

Now, thanks to String.Join and Linq, I can compress it to a single expression:

string.Join(",", items.ToArray());

Also useful when the source is IEnumerable<T>, and I want a property of T flattened, consider a list of people, to get a comma delimited list of all the first names is a simple matter of:

var firstNames = string.Join(",", (from person in people select person.FirstName).ToArray());

If you need it a quote qualified, comma delimited list of first names:

var firstNames = string.Join(",", (from person in people select "\""+person.FirstName+"\"").ToArray());

Iterating Static Fields / Properties

ChrisD — Thu, 10 Jul 2008 03:27:50 GMT

Often during development I end up with "Constants" classes, classes of constant or static values that I want design time Visual Studio intellisense support for, and run-time domain checking.

Consider the following class:

public static classConstants
{
       public static classClaimTypes
      {
           internal static stringClaimTypeNameSpace = "http://schemas.wtfsolutions.com/2008/07/claims/profile/";
           public static stringFirstName = ClaimTypeNameSpace + "firstname";
           public static stringLastName = ClaimTypeNameSpace + "lastname";
           public static stringDateOfBirth = ClaimTypeNameSpace + "dateofbirth";
           public static stringFavoriteColor = ClaimTypeNameSpace + "favoritecolor";
       }

   }

This class is handy at design time. When I type "Constants.ClaimTypes." up pops an intellisense list of the valid claim types for my application.

The problem with this list is that you can't iterate through it at runtime, ensuring the value of a variable is in the valid ClaimType domain of values. Ideally I'd like to be able to do this: ** THIS DOES NOT WORK ***

private bool validateClaimType(string claimType)
{
return Constants.ClaimTypes.Contains(claimType);
}

Fortunately, we can use reflection to build a runtime dictionary of the field name and field values

private Dictionary<string, string> staticFieldsToList(Type targetType)
{
    var list = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
    var fields = targetType.GetFields(BindingFlags.Public | BindingFlags.Static);
    foreach (var field in fields)
        list.Add(field.Name, field.GetValue(null) as string);
    return list;
}

and validate our claim type as follows: ** THIS WORKS **

private bool validateClaimType(string claimType)
{
    return staticFieldsToList(typeof(Constants.ClaimTypes)).ContainsValue(claimType);
}
In my real application I store the dictionary to a static field to avoid multiple reflection-based calls, but for the purposes of demonstrating functionality, the above code reflects the static class each call.

The best of both worlds, design-time IDE support and run-time domain validation.

I love it when a plan comes together.

Clean Up WCF Clients : The Right Way

ChrisD — Fri, 23 May 2008 22:12:25 GMT

As I've done more and more WCF work recently, I've noticed an intermittent problem running my unit tests.

The host seemingly hangs for no obvious reason. Eventually the connection times out and produces the following in the service log:

System.ServiceModel.CommunicationObjectAbortedException, System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089

Stopping the host and client and re-running the test allows it to pass without issue.

The problem is related to the way I managed my WCF channels and client proxies. In my code I make use of the ChannelFactory<T> object to create my wcf channels dynamically from my configuration information, like the following:

       #region IdentityService Proxy
        private static IIdentityService _identitySvc;
        private static IIdentityService identitySvc
        {
            get
            {
                if (_identitySvc == null)
                {
                    var factory = new ChannelFactory<IIdentityService>("IdentityService");
                    _identitySvc = factory.CreateChannel();
                }
                return _identitySvc;
            }

        }
        #endregion

The client proxy produced implements the typed interface "IIdentityService" in the above example. It natively supports no operations for channel management and cleanup. However, failing to clean up the client proxy may cause channel timeouts and resource blocking on the server. So channel cleanup is important, but if its not implemented in the client proxy, how do you manage it?

The secret lies in the casting. The transparent proxy produced implements a number of useful interfaces. For our purposes we care about IDisposable and IClientChannel. When we're done with the proxy, we must close the channel and dispose of it. I've seen some examples like this:

using (IClientChannel client = (IClientChannel)channelFactory.CreateChannel())
{
    IIdentityService proxy = (IIdentityService)client;
}

This is Bad. Yes, you are disposing of the channel resource, but you haven't closed the wcf channel, you've only disposed of your handle to it. You must explicitly call close then dispose on the proxy like so:

            if (_identitySvc != null)
             {
                 ((IClientChannel)_identitySvc).Close();
                 ((IDisposable)_identitySvc).Dispose();
                 _identitySvc = null;
             }

Optionally, since IClientChannel implements IDisposable, you could call ((IClientChannel) proxy).Dispose(). If you prefer, and your design allows, you can still use the using statement, just be sure to add try/catch blocks and call the close() method on the casted proxy before the closing brace. I tend to have static references to my proxy classes so I have to explicitly call close() and dispose() when I complete my WCF operation.

Now that I'm properly cleaning up my proxies, my WCF services run all my tests without hanging.

Developing Windows Services

ChrisD — Sat, 10 May 2008 16:48:56 GMT

I've been developing and debugging a windows service for my current project. Working with a Windows service is very much like working with a console app, with the startup and shutdown logic separated into the servicebase's start and stop methods.

Debugging a Windows Service

Unlike a console app, however Visual studio can't run a windows service and automatically attach the debugger (no Run-with-Debugger (F5) support). Not to fear, its easily enough to attach the debugger to the windows service. In my case, my service was starting and stopping right away, with no opportunity to attach the visual studio debugger to the running service. Instead I added this handy dandy line of code to the constructor of the service class:

            #if DEBUG
             Debugger.Launch(); 
            #endif

when the service starts, Windows prompts you to attach a debugger.

Select the debugger of choice and step through your windows service.

Removing and Reinstalling a Windows Service

I ran into a problem attempting to uninstall and reinstall my windows service. I was able to delete the service fine, but when I attempted to reinstall the windows service I received a "The Specified Service has been marked for deletion" exception.

Microsoft recommends rebooting to solve this problem; a solution that is not very conducive to a development cycle. Fortunately I stumbled upon a easier solution.

It seems that when the windows service list is visible (Start->Control Panel->Administrative -> Services), the list of windows services is cached and locked resulting in the "The Specified Service has been marked for deletion" exception. The fix, close the services dialog. With the dialog closed, I was able to re-install the windows service without issue.

I've switched my process to starting and stopping the service using Net Start/ Net Stop batch files.

QuickTip: Case Insensitive Dictionaries

ChrisD — Wed, 30 Apr 2008 20:28:01 GMT

I've often thought about making my own implementation of a Dictionary<K,V> where the key values are case insensitive.

Its been one of those things on my ever-growing to-do list. I usually end up casting the key values to all uppercase and try to encapsulate all my calls the the dictionary with my own logic that performs the case conversion. A case insensitive dictionary would avoid all that nastiness.

Sometimes it's helpful to read the tooltip overloads. As I coded a new dictionary instance today, I stumbled upon the

Dictionary<(Of <(TKey, TValue>)>) Constructor (IEqualityComparer<(Of <(TKey>)>)) overload.

Apparently I can pass my own equality comparer into the constructor which tells the dictionary how to compare key values. Could it really be that easy?

Yep, it exactly that easy. To make my dictionary<string,string> use case insensitive keys, declare the dictionary as follows:

Dictionary<string, string> argList = new Dictionary<string, string>(StringComparer.CurrentCultureIgnoreCase);

Now args["Test"] and args["TEST"] return the same item from my dictionary.

I love it when I can mark things done on my to-do list without actually having to do any work.

QuickTip: Debugging VBS Files with CScript.exe and Visual Studio

ChrisD — Mon, 14 Apr 2008 16:26:15 GMT

This is another one of those "Posted here for MY convenience" tips.

You can use the Visual Studio Debugger to debug a .vbs (vbscript) file executed with cScript.exe by using the //X flag at the command line.

To debug MyTest.vbs

cscript.exe MyTest.vbs //X

The //X will set a breakpoint and invoke the "select a debugger" dialog where you can choose Visual Studio and step into your vbs code. I haven't found a way to directly edit from the debugger however, so I end up having to debug, break execution, fix my bug and restart the vbs script file again to see my changes.

QuickTip: Performing work on a new thread using anonymous delegates

ChrisD — Tue, 08 Apr 2008 01:39:33 GMT

I know this is available other places on the web, but I'm posting it here because I often have to search for it. This tip is more for my benefit than others :)

class Program
{
   public static void Main()
   {
      Thread t = new Thread(delegate() { 
         SayName("Lou","Costello");
         });
      t.Start();
   }

   protected static void SayName(string firstName, string lastName)
  {
        Console.WriteLine(firstName + " " + lastName);
  }
}