VS2008 / .NET 3.5

Iterating Static Fields / Properties

ChrisD — Thu, 10 Jul 2008 02: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 21: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 15: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 19: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 15: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 00: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);
  }
}

QuickTip: Turn off CSS Validation Errors

ChrisD — Mon, 17 Mar 2008 21:03:07 GMT

I'm working on a prototype of a Single Sign On (SSO) solution for a web portal using Windows Cardspace as the authentication mechanism. This means I've spent my weekend developing web sites which may explain my foul mood.

I was applying some color attributes to some of my UI controls which rendered fine, but generated compiler errors because they were failing CSS Validation. Since it renders without issue (even between browsers), I'm not sure why its an error at all. In any event these errors were preventing me from continuing with my SSO server work. Fortunately we can specify how to treat CSS validation errors during a build in visual studio.

1. Go to Tools -> Options -> Text Editor -> HTML -> Validation

2. Uncheck the Show Error option

3. Click OK

QuickTip: Clean up Visual Studio's Recent Project List

ChrisD — Mon, 18 Feb 2008 03:47:05 GMT

We recently revised the organizational structure of some source code, and as a result projects now resided in new locations on disk. I've a big fan of the MRU list, and make use of it often in visual studio (both via the File->Recent Project/Solution menu option and the quick links available on the VS start page). The reorganization of my code base orphaned this links. I was unable to locate a UI for managing this list within visual studio, but did locate the source of these lists in my window's registry.

HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0\ProjectMRUList

Open RegEdit (or your favorite registry editor), migrate to the above locate and modify/delete the MRU list presented within.

It's the small things that speed along the work day, don't you think?

.NET 3.5 Certification Exam Beta is Still Available

ChrisD — Fri, 25 Jan 2008 18:57:32 GMT

Microsoft has extended the deadline for the .NET 3.5 technologies certification exam betas. There are certification tests available for WCF, WPF and Windows Workflow. You can take the exams for free, if you pass they will count towards your overall MS certification. Interested? Read more about it here

HowTo: Set up your project for Window's Workflow (C# style)

ChrisD — Sat, 19 Jan 2008 16:31:08 GMT

Any C# project can contain Workflow definitions. They're just code file and/or XAML files. The trick is getting Visual Studio to recognize the project as supporting worfklows for design-time support and compilation.

To enable a project for Windows Workflow,:

Open the project in visual studio.
If you're using source control check out the project file so it becomes writable
In the Solution Explorer, right click and select Unload Project . The project tree will disappear from the solution explorer and is replaced with a single node of the project name followed by the phrase (Unloaded).
Right click on the unloaded project node in the Solution Explorer again, and select Edit Project. This will open the project file in Visual Studio. The project file is just an XML file, so we can edit it manually.
Find the entry named <ProjectTypeGuids> and make sure it includes these id's

<ProjectTypeGuids>{14822709-B5A1-4724-98CA-57A101D1B079};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>

This tells visual studio its a C# project and a workflow project. Both are necessary to get design time support in your visual studio project. If you forget to include these project guid's you'll like end with an error like this when you try to edit a workflow file

The service 'System.Workflow.ComponentModel.Design.IIdentifierCreationService' must be installed for this operation to succeed. Ensure that this service is available.

Finally we have to tell Visual Studio to include the workflow compilation build targets for MSBuild when the project compiles. Add the following entry to your project's xml file inside the <Project> node

<Import Project="$(MSBuildExtensionsPath)\Microsoft\Windows Workflow Foundation\v3.0\Workflow.Targets" />

Save and close the project xml file.
Right click on the project node in the Solution Explorer again and select Reload Project

Your project is now Workflow-capable. You should be able to edit and compile Windows Workflow files.