Andrew Lynes' WebLog : .NET

Microsoft Certifications - Are they worth it?

anlynes — Sat, 17 Feb 2007 00:50:00 GMT

It's that time of year where I really need to move on my training objectives I set out at the beginning of year. In a rush of blood, I decided to update my .NET certifications to the latest and greatest. One question that comes up in discussions from time to time is whether it's worth the effort.

In the best tradition of consultants, my response to this question is that "it all depends". Personally I don't see any point in going through the certification process simply to get a few letters after your name. I've interviewed enough people over the years with the Microsoft alphabet stapled to their resume who couldn't answer basic real world questions. Instead, the real goal of certification is to learn something. Of course in order to learn something, you may actually have to look at the exam material over a period of time rather than cram it in the night before. Although both strategies may see you certified, it is usually pretty clear in an interview/work situation who has actually tried to improve their skills. So, if you're prepared to put in a bit of effort and learn something, I think certifications are worth it. However, if your goal is to be locked in a room for two hours to stare at a computer and eat lollies, you'd be better off staying at home and playing Age of Empires.

For anyone still reading, my main tip for successfully getting certified is to go ahead and book the exam/s. Having a deadline is a great motivator to get on with it.

Finally, for those that haven't looked for a while, the Microsoft Press training kits for the new MCPD and MCTS exams are now available from your favourite online bookstore.

ASP.NET AJAX Ships

anlynes — Wed, 24 Jan 2007 08:00:00 GMT

This is great news. I've been waiting on this one for a while. I'm currently pondering what one of my major customer's application delivery methods might be in the future. This is another option to throw into the mix.

Details can be found at AJAX : The Official Microsoft ASP.NET AJAX Site and Scott Guthrie's blog.

.NET and Auto-Restarting Services Revisited

anlynes — Tue, 01 Aug 2006 13:49:00 GMT

Another follow-up post... I forgot to mention that the numeric values for SC_ACTION_RESTART and SC_ACTION_REBOOT in the SC_ACTION_TYPE enumeration seem to be swapped in the documentation: http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dllproc/base/sc_action_str.asp. I had to use the following declaration to get things to work as expected:

enum SC_ACTION_TYPE : uint
{
    SC_ACTION_NONE = 0x00000000, // No action.
    SC_ACTION_RESTART = 0x00000001, // Restart the service.
    SC_ACTION_REBOOT = 0x00000002, // Reboot the computer.
    SC_ACTION_RUN_COMMAND = 0x00000003 // Run a command.
}

I also followed my own advice and cleaned up my mappings of managed and unmanaged data types in the attached file. There is (should be?) no functional difference from my previous post.

Using .NET Code to Set a Windows Service to Automatically Restart on Failure

anlynes — Sun, 30 Jul 2006 13:30:00 GMT

This one popped up this week as I was investigating why a particular Windows service written in .NET 1.1 was terminating. After a quick MSN search, I only came up with a few fragments of C#, but not a complete solution. In attempting my own implementation, a few things came up that may be of interest to others.

Firstly, the relevant Win32 API function is “ChangeServiceConfig2”. It’s a “jack of all trades” function, whose flexibility makes it a bit of a pain to call from .NET. The difficulty is that we need to pass it a structure that itself contains an array of structures.

Before getting to “ChangeServiceConfig2”, we first need to get a handle to the service via a call to the “OpenService” Win32 API function. It’s not mentioned in any documentation I’ve seen, but you need to request both SERVICE_CHANGE_CONFIG and SERVICE_START access rights, otherwise you’ll receive an “access denied” error from “ChangeServiceConfig2”.

“OpenService” and “OpenSCManager” (which is also needed in the solution) return Windows handles. A common .NET misconception is that Windows handles should be treated as 32-bit integers (int, Int32 etc). In “unmanaged” land, the HANDLE type is actually a pointer to void (void*). This means IntPtr should be used to deal with these.

The key structures for this task are SC_ACTION and SERVICE_FAILURE_ACTIONS. The SC_ACTION structure describes what Windows should do in the event of a service failure. It is possible to provide serveral of these so that different actions can be taken on subsequent service failures. These all need to be placed into an array, which itself is then placed into SERVICE_FAILURE_ACTIONS (this is the pain mentioned above).

struct SC_ACTION
{
   [MarshalAs(UnmanagedType.U4)]
   public SC_ACTION_TYPE Type;
   [MarshalAs(UnmanagedType.U4)]
   public UInt32 Delay;

}

struct SERVICE_FAILURE_ACTIONS
{
   [MarshalAs(UnmanagedType.U4)]
   public UInt32 dwResetPeriod;
   [MarshalAs(UnmanagedType.LPStr)]
   public String lpRebootMsg;
   [MarshalAs(UnmanagedType.LPStr)]
   public String lpCommand;
   [MarshalAs(UnmanagedType.U4)]
   public UInt32 cActions;
   public IntPtr lpsaActions;
}

In preparing the structures to pass to “ChangeServiceConfig2”, there is a requirement to perform pointer arithmetic in order to construct the array of failure actions. An arbitrary cast to a 32-bit integer would make the solution incompatible with 64-bit Windows. The safest option is to use Int64 for pointer arithmetic.

Marshal.StructureToPtr(action2, (IntPtr)((Int64)actionPtr + Marshal.SizeOf(typeof(SC_ACTION))), false);

After a bit of marshalling, we’re actually ready to call “ChangeServiceConfig2”. The good news is that this is straight forward. The only thing remaining is to handle any errors the .NET way.

if (changeResult == 0)

{

throw new Win32Exception(Marshal.GetLastWin32Error(), "Unable to change the Service configuration.");

}

Finally, since we're working with unmanaged resources, we need to make sure that things are cleaned up properly. The best pattern for this is to use a try-finally block.

I’ve attached my first attempt at a solution, but it still needs testing on 64-bit platforms (fingers crossed). Note that under .NET 2.0, we would probably do a few things differently (such as make use of the new SafeHandle class). That said, the solution runs under .NET 2.0.

BTW, for the security conscious, you should actually add a Link Demand to methods that that use the Marshal class. I’ll leave the details for another day, but your method will be exposed to certain types of security issues if you don’t.

[SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]

Enjoy!