Steve Dunn's Blog

Announcing a new version of the Gleed 2D XNA tool

2012-01-08T19:35:00.001Z

I’ve spent some time over the Summer and Autumn of 2011 rewriting the Gleed 2D tool. This is a tool for editing levels for 2D games and is a very popular tool in the XNA community for games running on XBox and Windows Phone.

Most of the changes in the new version are under-the-hood. The biggest change has been to make it have a plug-in architecture. There has also been a few UI changes though; here’s some screen-shots.

The original tool before being re-written:

and here’s the new version:

The main reason for rewriting the tool was that I wanted to add more features to it but found that it wasn’t easy. It wasn’t easy because it was originally written to just handle the basics needed for creating and editing levels.

The features that I wanted to add were for the next version of my game (video here). I wanted to include lighting and shadows and I wanted to design these on the canvas.

Instead of shoe-horning my changes into the original Gleed 2D source, I decided it’d be best to rewrite it and change it to a plug-in based tool.

So, now everything is a plug-in. The basic shapes (rectangle, circle, path) and textures are now plug-ins. Lighting (lights and shadows) is now a plug-in. There’s also a plug-in for simple ‘behaviour’.

Here’s a quick video showing how to use the basic shapes and textures:

Basic shapes and textures

Here’s a short video showing lighting:

Lights and shadows

and lastly, here’s a short video showing simple behaviours:

Simple behaviours

The tool is still currently a bit rough. There’s various bugs that need to be fixed, but none of them stop the tool from doing what it was designed to do. The project is now quick big, so I’m hoping that the community will jump in and add/fix stuff. I’d like to see plug-ins for physics and particle systems.

Feel free to download the source and play around.

A fast way of converting C# enums to strings–and back again.

2011-08-17T21:45:00.001Z

I recently needed a fast way of converting lots of enums to strings (and back again). I needed to do it very quickly. ‘Enum.Parse’ just wasn’t fast enough.

I discovered there was no ‘enum mapper’ in C#, so I knocked up this little class. It uses reflection just once when it comes across a new enum.

It’s compatible with .NET 3.5 too.

Handy use of extension method on a bool

2011-05-11T19:41:00.001Z

I don’t like to overuse if/else statements. I really dislike seeing code like this:

if(somethingIsTrue)
{
  DoSomethingWhenTrue( ) ;
}
else
{
  DoSomethingElse( ) ;
}

I just had an idea about using extension methods so I can write this instead:

somethingIsTrue.Branch(
        ( ) => DoSomethingWhenTrue( ),
        ( ) => DoSomethingElse( ) ) ;

… and here’s the extension method:

public static void Branch(this bool @bool, Action left, Action right)
{
  if( @bool )
  {
    left( ) ;
  }
  else
  {
    right( ) ;
  }
}

Nice or not? I think it reads a bit better (for single line expressions anyway).

New version (2.5) of the Code Formatter Plug-in for Windows Live Writer

2010-07-11T13:13:00.001Z

A new version of my code formatter plug-in for Windows Live Writer can be found at http://tinyurl.com/3483vwh

Summon Method

2010-04-14T11:54:00.002Z

"Summon Method" A method that gets or creates something.

A common question (well, I've seen it asked a few times), is what should I call a method the gets or creates something? Instead of

Foo GetOrCreateFoo()

use:

Foo SummonFoo()

What do you think?

A tool to switch project files between using Visual Studio 2008 and 2010

2010-02-25T21:02:00.006Z

Update: the source is now on GitHub

Visual Studio 2010 is almost here. Visual Studio 2010 (the release candidate) is here.

I’ll describe the problem before I describe the tool: You want to use the latest version of Visual Studio but you don’t want it to modify all of your projects and solutions because you’ve got other team members who don’t want to (or can’t) switch to 2010.

A serious problem indeed. If only you could you run a tool to update all of you project files to 2010, do your changes in Visual Studio 2010, then switch all projects back to 2008 format before checking in.

Well, here’s a command line tool to do just that!

It’s very easy to use: run it from the command line, give it a folder name, and tell it whether you want all your projects and solutions under that folder to be either 2008 or 2010 format. For example:

SwitchVsVersion c:\temp\MySolution 2010
SwitchVsVersion c:\temp\MySolution 2008

As a bonus, you can also tell it to change all your target frameworks to either .NET 4 or .NET 3.5. For example:

SwitchVsVersion c:\temp\MySolution 3.5Framework
SwitchVsVersion c:\temp\MySolution 4.0Framework

Binary here. Source code here. Here’s a test solution with lots of different empty projects to try it out on too.

Disclaimer: this is a noddy little tool that may not work properly on your projects and solutions. I’ve tested it on quite a large WinForms solution and it worked fine. I’ve also tested it on quite a variety of projects including C# and VB WinForms, Web Apps, Libraries, WPF Projects, and WPF Libraries. The only one it doesn’t do is C++ projects (which is a coincidence, because I no longer do C++ projects either). Be sure to back up your stuff before you use this tool! Terms and conditions apply.

Update: Thanks for the feedback. As requested, the source is covered under the WTFPL. Do what you want with it:

DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE


This program is free software. It comes without any warranty, to the extent permitted by applicable law. You can redistribute it and/or modify it under the terms of the Do What The Fuck You Want To Public License, Version 2, as published by Sam Hocevar. See http://sam.zoy.org/wtfpl/COPYING for more details.

Updated: Code Formatter Plugin for Windows Live Writer

2010-01-09T20:07:00.001Z

This plug-in formats and highlights code. Version 2.0.0.3 can be downloaded here. Keep reading for more info.

As well as a few bug fixes, this release includes the following features:

· Use different formatting engines such as ActiPro (Insert formatted code), and SyntaxHighlighter (Insert highlighted code)
· Dozens of languages, including PowerShell, MSIL, Pascal and XAML
· Live formatting of code using the superb ActiPro code editor. ActiPro very kindly donated the license.
· The ability to output either highlighted text (html) or an image
· WordPress support for the SyntaxHighlighter Evolved plugin

This plugin adds four tools in WLW's tool window:

Tool 1) Code as bitmap

This uses the ActiPro formatting engine to take a snapshot of the code.

You'll see this screen when clicked – if there’s text in the clipboard, it’ll be shown here, or you can copy and paste when the window appears:

This srceen allows you to set the size of the editor window. You can either select common widths from the drop-down or put in your own width - for instance, 465 is the ideal width for my template on Blogger. The buttons on the bottom right allow you to then:

a) insert the image straight into the blog post or
b) have the plugin copy the image or
c) discard it.

The advantage of the option A is that the code is still editable in WLW; the disadvantage - you cannot [yet] apply bitmap effects, such as reflection or drop shadow.

The advantage of option B is that you can apply bitmap effects, but the disadvantage is that code will no longer be editable.

Tool B) Formatted code

This also uses uses the ActiPro formatting engine.

When inserting code, the plugin window will allow various properties of the code to be changed:

When clicking edit code, you'll see the edit source code screen:

Tool C) Highlighted code

This uses the Syntax Highlighter formatting engine. When inserting code, the edit screen will appear in the same way as when you insert formatted code (see above). The only difference is a ‘show preview’ button, which displays this preview window:

To use the SyntaxHighlighter engine, ensure your blog is correctly set-up. For the preview window to correctly display your code, ensure the Settings are correct. Here’s the Settings window:

Tool D) WordPress Formatted

This changes the HTML output to that expected by theSyntaxHighlighter Evolved plugin for WordPress. It’s very similar to using the SyntaxHighlighter engine, but you don’t need to worry about setting up your blog with the correct scripts. Do be aware though, that for the Preview window to work correctly, you still need to set-up this plugin so that it knows where the SyntaxHighlighter brushes and scripts are (the default settings work right now, but if Alex changes the location in the future, you’ll need to update the settings).

To see examples of the output, please see this blog post.

Version 2.0.0.3 can be downloaded here. To use it, extract the binaries to Program Files\Windows Live\Writer\Plugins and run WLW. If you're using a version of WLW prior to Beta 3, then you need to remove it and update! (alternatively, change the directory to \Program Files\Windows Live Writer\Plugins)

Thanks again to all those that left feedback. Please keep it coming. Hopefully the bugs that have been reported have now been fixed.

Problems with CSS and themes when using ASP.NET Forms Authentication

2009-10-17T19:25:00.001Z

A while back, I wrote a blog post about how turning on Forms Authentication caused problems with stylesheets and Themes. A lot of people found this post useful but had trouble finding it. One reader suggested I change the title to get more hits. So, I did, and this is it.

ReSharper for Visual Studio 2010

2009-07-27T19:48:00.001Z

I don’t know how I missed this for so long, but JetBrains have released a preview of ReSharper for Visual Studio 2010! They say this version is neither 4.5.1 nor 5.0, but a preview build with some of the new 5.0 features enabled.

Looking at the nightly builds, it seems that the first release was 9th July, but there was no news on their blog, which I’ve been checking daily since June (when they said it’d be ready).

Anyway, now I can give Visual Studio 2010 another try. I just couldn’t use it, not even for evaluation, without ReSharper!

Also, let’s not forget that version 4.5.1 for Visual Studio 2005 and 2008 is also now available.

Google Squared and sexy languages!

2009-06-04T06:24:00.001Z

Google Squared looks like an interesting tool.

“Google Squared is a search tool that helps you quickly build a collection of facts from the Web for any topic you specify.

Facts about your topic are organized as a table of items and attributes (we call them "Squares" for fun).

Customize these Squares to see just the items and attributes you're interested in.

See the websites that served as sources for the information in your Square.

Save and share Squares with others.”

There’s some interesting results. I searched for ‘programming languages’.

It displays a list of languages, a picture of the language, a description, and what it was influenced by.

I was very surprised to see the Miranda language (apparently influenced by Haskell). Try it yourself: scroll down to Miranda. I must take a closer look at this one!

Another one that might get you excited is Limbo. Scroll down and take a look (but be careful if you’re at work!!). Apparently influenced from Stackless Python. I’d say more like alcohol!

Updated: Tree Trim

2009-05-25T12:45:00.001Z

Tree Trim is a command line tool that trims your source code tree. It removes debug files, source control bindings, and temporary files.

It’s integrated with Windows Explorer: when you right click a folder you’re given the option to clean the folder.

Massive thanks to Scott Hanselman for blogging about it and for providing some great and detailed feedback.

If you’re interested in doing your own Tree Trim plugin, there’s now a Wiki page to take you through the process. If you’d like to contribute your plugin or fix any issues, then take a look at this page.

Updated: Code Formatter Plugin for Windows Live Writer

2009-05-15T21:11:00.001Z

Version 2.0.0.2 of the Code Formatter Plugin can be downloaded here. This has a fix for when the plugin tried to load configuration from the wrong location on disk.

New tool: TreeTrim

2009-04-13T11:45:00.001Z

I've recently been working on a tool based on Jeff Atwoods Clean Sources Plus.

It's called TreeTrim. It's a tool that strips out debug files and folders in your source code tree and also zips and emails amongst other things.

One of the BIG requests for CleanSourcePlus (well, amongst the 5 people in the comments section of the tool's page!) is for the tool to make a working copy of your source before it deletes and zips. TreeTrim does this.

It's plug-in based, so if it doesn't do something that you want, you can write your own plug-in, plonk it in the directory, and have the tool run it alongside the other plugins.

The installer and source code is available for download at http://code.google.com/p/treetrim/

ReSharper 4.5 Beta

2009-03-13T21:35:00.001Z

Nice

Update to the Code Formatter Plugin

2009-03-12T19:44:00.001Z

Version 2.0.0.1 of the Code Formatter Plugin is now available.

New in this version:

Enhanced support for Syntax Highlighter 2x
You can now specify things such as tab size, show ruler, collapse, show toolbar, show line numbers, starting line number, and highlighting specific line numbers.
Configuration screens for the different providers

You can now add and remove languages and generally configure each provider. You can also edit the files manually – they are called SyntaxHightlighter2xConfiguration.xml and ActiProConfiguration.xml. They are located in the Plugins folder.
Preview window for Syntax Highlighter formatted code.

This was added because the Preview tab in Windows Live Writer doesn’t include the scripts and styles used in your blog engine’s templates and hence previewing Syntax Highlighted code means it looks plain. Click the Show Preview button to see this window.

Code Formatter Plugin home-page
Direct download link

IDisposable alerts

2009-03-06T20:10:00.001Z

Types that implement IDisposable usually do so for a reason. They probably consume resources that should be released as early as possible.

In a recent project, I came across a very neat idea. In the destructor/finalizer/finaliser of your IDisposable type, do something to alert the consumer that you’re being collected by the Garbage Collector and hence you haven’t been disposed of correctly.

But how does this type know it’s not been disposed correctly? Well, if you follow the IDisposable pattern to the letter (described in the excellent book Effective C# (Item 18), and about 3,000 places around t’internet), in your Dispose method, you’ll call GC.SupressFinalize(this); meaning the Garbage Collector won’t call your finalizer. So if you ever end up in the finalizer, the naughty user hasn’t called Dispose or hasn’t put the construction of your type in a using block.

There’s two bits to this

The constructor:

public MyResourceHungryType( )
{
  _stackTrace = new StackTrace( ) ;
}

The finalizer:

~MyResourceHungryType( )
{
  Debug.WriteLine( _stackTrace.ToString( ) ) ;
}

Then, if the finalizer is ever called, you’ll get a call stack printed up to the point where you created this type – something like:

at Namespace.MyResourceHungryType..ctor()
   at Namespace.MyType.DoSomething()
   at SomeNamespace.SomeMethod()

Handy.

New version of the Code Formatter Plugin

2009-03-06T07:21:00.002Z

Version 2.0 of the Code Formatter Plugin for Windows Live Writer is now available.

New in this version is the ability to use different formatting engines – in this version: ActiPro and SyntaxHighlighter 2.0

Also new is the ability to output either formatted code as text or as a bitmap.

A massive thank you to ActiPro for donating the ActiPro Syntax Editor component – the best code editor available!

If you’re reading this in an aggregator, the following code snippets may look unformatted (apart from the bitmap), but if you’re not, then it should be all nicely formatted.

Here’s some output from ActiPro as text:

public int TabWidth
{
  get
  {
      return _content.GetInt(@"TabWidth", 4);
  }
  set
  {
      _content.SetInt(@"TabWidth", value);
  }
}

Here it is again as a bitmap:

and here it is using SyntaxHighlighter 2.0

public int TabWidth
{
  get
  {
      return _content.GetInt(@"TabWidth", 4);
  }
  set
  {
      _content.SetInt(@"TabWidth", value);
  }
}

Please feel free to read more and download it.

Online mind maps in Silverlight

2009-03-05T07:16:00.001Z

I’m a big fan of mind maps. I use MindManager, but there’s now an online Silverlight alternative from DropMind.

It’s currently in beta, so there’s a few things that need addressing to make it as nice to use as MindManager (such as keyboard navigation). Despite this, it looks feature packed compared to other online mind mapping tools I’ve tried.

There’s also a desktop version. It has none of the above keyboard problems. It also looks and feels very similar to MindManager:

DropMind

MindManager

It’s nice to see Silverlight apps like this. I’d probably switch to it once all the glitches are resolved. MindManager’s great, but it comes with a lot of fluff I don’t need, like Office integration and RSS features.

Halt, this is StyleCop. You are in violation of SA1201!

2009-03-04T16:19:00.001Z

StyleCop has a ~~law~~ rule named SA1201. It says that you should put various parts of your code in the correct order. For the contents of a class this goes like:

Fields
Constructors
Finalizers (Destructors)
Delegates
Events
Enums
Interfaces
Properties
Indexers
Methods
Structs
Classes

Doing all this by hand is tedious, but as with most things, ReSharper (R#) makes it easier!

R# has a couple of features that, when combined, will mean you are fully SA1201 compliant (and, quite possibly well within the 20 seconds compliance window!) Firstly, there is a feature called Code Cleanup:

You can get R# to do various things during code clean-up. One of them is Reorder Type Members. R# does a decent job of moving stuff around by default, but it’s not perfect and doesn’t stop all warnings about SA1201. Thankfully, Reorder Type Members is configurable. The interface is straight XML in the R# Options screen. It’d be nice to have a GUI over it, but as yet (in R# 4.1 and 4.5), there isn’t one. Thankfully, you can’t bugger things up too much as the XML is validated against an XSD before it’s saved.

I was going through a legacy project recently and wanted a way to automatically reorder things, so I modified the R# XML configuration. To get your environment set-up, download the new XML configuration, go to ReSharper/Options and under languages/C# there an entry named Type Members Layout.

Deselect Use Default Patterns check-box and past in the new XML and click OK.

If you want a C# class that contains most of the things that should be reorganised, download it here. Mash it up a bit and then run StyleCop on it to ensure no SA1201 errors.

Hiding your privates from StyleCop

2009-03-03T11:55:00.001Z

I like StyleCop but I didn’t like the fact it produced warnings on private fields and methods. I was wrong. Not wrong in that I didn’t like warnings on privates, but wrong that I thought there was no way to tell it to stop it.

Apparently there is. Jason Allor kindly left a comment saying that it can be configured through the StyleCop settings dialog in Visual Studio.

I took a look and initially didn’t find it. I didn’t find it because I assumed there’d be different rules for public and private entities. But there’s not, you can decide at the rule type level:

It’d be nice to have separate rules for public and private. Currently, I’ve turned off all Documentation rules because I don’t like being warned that I haven’t commented private methods. However, I’d still like it to give me all the other great warnings if I do decide to comment a particular private method.

Programs that launch (or should launch) Visual Studio

2009-03-03T11:34:00.001Z

Programs such as FxCop provide links to source files that can be clicked and then edited in Visual Studio.

FxCop recently (probably since I went 64bit, but also possibly a side-effect of running Windows 7) started failing when clicking these links. It said:

Could not start Microsoft Visual Studio. Try specifying an alternate source code editor in Application Settings.

Maybe it just looks in \Program Files\Microsoft Visual Studio\[whatever version]. Anyway, I couldn’t see anything in the event log or any local FxCop logs, so I just changed the setting under Tools\Settings to use an explicit path to devenv.exe.

This worked, although it started a new instance of the IDE for every file. To get around that, you need to use the /Edit argument. Here’s what it looks like (click to make it bigger):

There’s other handy switches, some of which I knew about, like building a particular project/solution (to get the full list, run devenv.exe /?). It now uses an existing instance of Visual Studio if one’s present, otherwise it starts one up.

ThoughtWork’s Mingle on X64 machines

2009-02-26T10:20:00.001Z

By default, 32 bit applications installed on 64 bit machines are installed into the \Program Files (x86) directory.

Mingle, in particular, Ruby doesn’t like the brackets in this path, hence, when Mingle tries to start, it fails. It writes the following entries to the log file in the program’s directory:

Failed to load Rails: C:/Program Files (x86)/Mingle_2_2/app/controllers/caching/keys.rb:1: Invalid char `\257’ (‘¯’) in expression C:/Program Files (x86)/Mingle_2_2/vendor/rails/activesupport/lib/active_support/dependencies.rb:505:in `load’ C:/Program Files (x86)/Mingle_2_2/config/../vendor/rails/railties/lib/initializer.rb:475:in `load_application_initializers’ C:/Program Files (x86)/Mingle_2_2/config/../vendor/rails/railties/lib/initializer.rb:474:in `each’ C:/Program Files (x86)/Mingle_2_2/config/../vendor/rails/railties/lib/initializer.rb:474:in `load_application_initializers’ C:/Program Files (x86)/Mingle_2_2/config/../vendor/rails/railties/lib/initializer.rb:145:in `process’ C:/Program Files (x86)/Mingle_2_2/config/../vendor/rails/railties/lib/initializer.rb:93:in `run’ C:/Program Files (x86)/Mingle_2_2/config/environment.rb:116 C:/Program Files (x86)/Mingle_2_2/config/environment.rb:1

The solution: change the default installation to just \Program Files. Handy. If you want to use Mingle. On a 64 bit machine.

Problems adding an XBox 360 Media Center Extender

2009-02-24T21:53:00.001Z

Skip this if you’re not using a Linksys Wireless N device, Media Center, or an XBox 360!

After my umpteenth Seagate disk packed up yesterday, I’ve just reinstalled Windows 7 X64. I have spent the last couple of hours trying to get an XBox 360 connected to Windows Media Center.

Not too long ago I went through the exact same thing: Start WMC, Start the XBox, type the number on the XBox’s screen into WMC, and get nothing. The last time I did this, it was too late in the day to discover what was wrong or how to fix it – but the next day, everything worked perfectly!

This time, I went through exactly the same ritual. I looked at the Security event log and it said that :

Event 5032 – Audit Failure - Windows Firewall was unable to notify the user that it blocked an application from accepting incoming connections on the network.

After ensuring that I’d allowed Media Center Extenders through the home network (shortly followed by turning the damn firewall off altogether), I started getting (from the Media Center log under Applications and Services Logs in Event Viewer):

Event 538 - Media Center Extender Setup failed as the Extender was detected on the network but the UPnP search for the Extender failed (timed out after 20000ms).

This all seemed very familiar and nothing I was doing was making a difference. It was at this point on my last attempt that I went off to do something else. This time though, the something else’s opening hours hadn’t yet arrived, so I persevered!

In the corner of the screen (remember, this is a fresh install), was the Windows Update icon. I checked to see what it needed to update, and along with the 294 Office 2007 security patches was an update for a Marvell - Network – Wireless-N USB Network Adapter. I wondered if this had anything to do with my Linksys Wireless N USB, and it looks like it does. And after restarting, everything worked great!

The information from Windows Update showed this information:

Marvell - Network - Wireless-N USB Network Adapter

Update type: Optional

DriverUpdate: Marvell Network software update released in October, 2007

More information:
http://winqual.microsoft.com/support/?driverid=20110859

The URL wasn’t much good as it was broken. The driver information from device manager reads:

Marvell Semiconductor, Inc, version 1.00.04.03 – filename MRVW24C.sys.

This replaced the Vista drivers that I downloaded and installed from the Cisco site.

In fact, I’ve just done a search for Marvell Linksys driver, and it showed this page. This shows how to force the driver on Vista/Windows 7 if it doesn’t show up via Windows Update.

I hope some of these keywords will help others with this problem. My heart sank when I searched for the Media Center error and didn’t get 1 single hit! That shouldn’t happen any more!

Tool update: Visual Studio Orphaned Items

2009-02-23T11:21:00.001Z

A while back I did a small simple tool to find files on disk that were once part of a Visual Studio project but are now orphaned (removed from the project but still on disk and in your source repository). I’ve just updated it to find obsolete files from Visual Studio 2008 projects. You can download the app or the installer, or the source (or all of them!). The installer adds a right-click context menu action for .csproj files in Windows Explorer.

Available here.

StyleCop

2009-02-21T13:44:00.001Z

StyleCop is a tool that looks at your source code and recommends ways to improve readability and consistency. For instance, it tells you to:

Put things in a consistent order in the file – Constructors first, followed by public methods, followed by private methods etc.
Put a blank line after a closing brace. I thought this was a bit anal, but for some reason it makes code much more readable. On a related note, some people swear by having no blank lines in their source. Their reasoning: they can see more on screen without having to scroll and can see more of the method on screen at once. To me, this was like reading a book with no paragraphs. Also, If you’ve got methods that take up a whole screen, they’re probably doing too much and are too complex. I was invited to try it with the reassurance that I’d eventually see the benefit. I declined, but then realised that I had been ‘trying it’ all along - every time I read the code!
Remove unnecessary parenthesis. Reminds of a quote: “Parenthesis (however relevant) are unnecessary.”
Add XML comments to methods, properties, and events.

There’s hundreds of suggestions, mostly good, although there are some issues – here’s mine:

I generally don’t like to comment private methods, but there doesn’t seem a way to tell it to only warn me if I have public methods that are undocumented. I hope this’ll be added to the next version. I don’t like commenting private methods as, if I feel it needs a comment, then the code isn’t self describing and is either a) poorly named, or b) too complex, or c) doing too much.
StyleCop says don’t precede field names with notation. I follow the almost ubiquitous practice of preceding private fields with an underscore. For no other reason than to be able to type underscore + ctrl+space and have intellisense pop-up my private fields.

The good news is that it’s possible to turn off warnings. It’s also very well thought out in how these settings are managed: If you think a certain warning is so ridiculous you never want to see it again, you can put it in the StyleCop.Settings file and put this file at the top of your source tree. If you’ve got a project where it would make sense to turn off a warning just for that project, you can put another StyleCop.Settings file at the project level. More here.

I’m wondering if anybody would be brave enough to integrate this in their CI process! Breaking the build because there’s not a blank line under a brace seems a tad extreme!

Stand-up send-up

2008-11-28T15:19:00.002Z

C# 4 - Default Parameters

2008-11-20T12:04:00.007Z

Coming from a C++ background, I'm really pleased that there'll eventually be default parameters built into the next version of C#. But I do think that C++ had a much cleaner way of handling them: it would only allow defaults from right to left, for instance:

void foo(int a, int b, int c=3, int d=4)

It wouldn't let you do:

void foo(int a=1, int b=2, int c, int d)

C# will, so for the example above, you'd end up with method calls that could look like:

foo( ,  , 3, 4)

One feature that I still really miss from C++ is const. This keyword could be applied to methods or parameters, so a method declared as:

void foo(int a, int b) const
{
}

would be guaranteed to not modify the state of the object (except for mutable members) A method declared as:

void foo (const Person person)
{
}

would be guaranteed to not modify the person. Maybe C# 5?

Adding folders to the Class View in Visual Studio

2008-11-19T11:16:00.002Z

I didn't know this, but you can add folders to the Class View. You can then drag classes to it. What's even better, you can drag methods to it!

Thanks to Sara Ford for her post describing this.

There's more good news! When you're editing code in the editor and you're over a class or method, you can use the 'Synchronise Class View' command (I've mapped mine to a keyboard short-cut, but you can add a toolbar item) to synchronise the Class View to the item you're currently editing. Once synchronised, you can go to Class View and drag that into one of your folders. Also, when you do this, you won't upset any of your team with changes to the solution or project files - because these are your settings, and hence are stored in the .suo file (which, on the other hand could be a pain, because user option files shouldn't be checked into your source repository).

Anyway, this is the next best thing to a 'bread-crumb' feature in the editor that let's you jump around to favourite places in the the code. Maybe the bread-crumb feature will be in the next version of ReSharper?

Displaying values in the Visual Studio Debugger

2008-10-20T12:51:00.006Z

Normally, when you display values in the Visual Studio debugger, you get formatting (quotes, tabs etc.) included. For instance, if you've got string s = "Hello[tab]World"; then hovering over s in the debugger displays "Hello\tWorld". If you wanted to copy a value value to the clipboard (maybe because you landed on an exception and you want to send the error to ~~the idiot that caused it~~ your fellow colleague), you'd probably right click on the value and select 'copy value'. This copies the value to the clipboard. Another way is to use the immediate window. Using the example above, typing 's' in the immediate window would produce:

To get rid of formatting (the quotes and the control characters), use the ,nq option:

This is useful in itself, but it really becomes invaluable if you want to show some XML. With the magical ,nq switch, the following code:

produces the following output in the immediate window:

Pretty useless, but if you add ,nq, you get:

Much nicer.

nq stands for nice'n quick, because it doesn't waste time writing quotes.

Probably.

Excluding Items From Code Coverage

2008-06-27T19:20:00.001Z

There's an attribute in nCover that can be applied to your code to exclude it when doing code coverage. This is handy for auto-generated types such as web services etc.

The attribute is in the nCover assembly, but most people wouldn't want to ship with their assemblies. Fortunately, you can define your own attribute. If you're using TestDriven.NET, call it 'CoverageExcludeAttribute', if not, call it what you want.

When using NCover, pass the name of the attribute in the /ea WhateverYouCalledTheAttribute command line attribute.

Here's the code, with comments. Remember, don't put this in a namespace!

/// <summary> 
/// Use this attribute on types that do not need code coverage analysis. 
/// Such types are auto-generated types, such as web services etc. 
/// 
/// This attribute is used by TestDriven.NET to exclude the type/method in the 'test with coverage' functionality. 
/// This attribute can also be passed to NCover proper by using the /ea CoverageExcludeAttribute command line. 
/// </summary> 
/// <remarks> 
/// Note that this should NOT be part of a namespace! 
/// </remarks> 
[CoverageExclude] 
class CoverageExcludeAttribute : Attribute { }

New!

2008-06-21T18:58:00.001Z

Code Formatter Plug-in for Windows Live Writer

2007-12-12T21:21:00.001Z

Version 1.0.0.4 of my plug-in for Windows Live Writer (WLW) is now available. This version is for the released version of WLW. As with the previous version, the following languages are supported:

Assembly
BatchFile
CSharp
CSS
HTML
INIFile
Java
JScript
Lua (pronounced LOO-ah)
MSIL
Pascal
Perl
PHP
PowerShell
Python
SQL
VBDotNet
VBScript
XAML
XML

Download it now from my tools page.

Thanks to everyone who left comments and feedback; this addressed two issues reported - 1 with inserting pictures and then editing a block of code, and the other was with duplicate scroll-bar options.

New version of the Code Formatter Plug-in for Windows Live Writer.

2007-09-23T10:14:00.001Z

Version 1.0.0.3 of my plug-in for Windows Live Writer is now available. This version works with the new Beta 3 version of WLW (and also older versions).

Languages now include:

Assembly
BatchFile
CSharp
CSS
HTML
INIFile
Java
JScript
Lua (pronounced LOO-ah)
MSIL
Pascal
Perl
PHP
PowerShell
Python
SQL
VBDotNet
VBScript
XAML
XML

Download it now from my tools page.

If Agile is so good, why haven't we always done it?

2007-08-20T16:25:00.001Z

Fred George has an interesting post on his successfulness with Agile processes. He asks, if Agile is so much better, why didn't it emerge earlier?

He thankfully rules out stupidity and instead lists the three enablers that we have today that we didn't have back then (Fred goes back to the 70's, but I'd say these were just as relevant for most of the 80's):

We didn't have the languages (Java, C#, Ruby) and techniques (OO, rules engines) to write code that could be changed. Our paradigms were actually the opposite: Design your data structures, and the code writes itself.
JIT (Lean) hadn't made it out of the automotive manufacturing sector.
We didn't have the horsepower. I have more memory in my watch than I had in my first computer. And don't think of comparing an entry iPod to the first PC.

I'm trying to imagine how horrendous it would be to try and mock some behavior written in 6502 assembler in a unit test, on the Commodore 64!

Challenging Conventions with Test First Development

2007-07-19T10:13:00.001Z

I've just read a great post over at Tim Ottinger's blog. In it he discusses how test first development challenges conventional development. He makes several interesting points, some of which include:

Point 3: Private makes less sense than it used to. You can’t test anything that’s private.

This is something I often ponder over. Making things private makes your intent very clear, which I think is very important. But private implementation is still a unit of code that needs testing. Then again, as described in Test Driven Development: A Practical Guide, unit tests should test the facets of behavior. As Dave Astels puts it in this blog post:

"... the idea of “unit” is a major problem. First of all it’s a vague term, and second it implies a structural division of the code (i.e. people think that they have to test methods or classes). We shouldn’t be thinking about units… we should be thinking about facets of behaviour."

To me, the term 'facets of behaviour' reads that 'behaviour' has 'facets', and that private implementation makes up each facet. So by testing the facets of behaviour, you are really testing units of private implementation (i.e. private methods). This point may be worthy of a new post...

Point 4: The fat constructor argument list is a concession to the need for isolation and testing with mocks...

Good comment. I always refactor any code I see with a fat parameter list so it takes a 'property bag' instead. In ReSharper, this refactoring is called 'ExtractClassFromParameters'. The benefit of this is cleaner, more separate code, and also overcomes C#'s limitation of not having default parameters (i.e. you leave it null/default in the property bag).

Point 7: Hard to use class interfaces are now hard for you to use...

Exactly. Which is why I find TDD a great way to figure out 'how to design an API/Framework' rather than 'how to implement the API/Framework to achieve something'. Something that made a lot of sense when reading the Framework Design Guidelines is to forget OO when designing the public interface to an API - i.e. design it so it's easy to use for the most common scenario. Exactly what is achieved by practicing TDD.

Handy .NET Cheat Sheets

2007-07-05T10:15:00.001Z

John Sheehan has some great cheat sheets on string formatting, ASP.NET Page Lifecycle and Visual Studio code snippets. Very handy. I'm sure there's a medical explanation as to why it's impossible to remember string formatting parameters for more than 1 minute after you've discovered them!

Getting 'code://' hyperlinks into FlexWiki

2007-07-04T17:02:00.001Z

Reflector, when installed, adds a "code://" protocol handler, enabling hyperlinks to specified types in assemblies. This handler is similar to http:// or ftp://, but instead of taking you to a web site, it takes you to a type in an assembly!

For example, code://System.Web/System.Web.UI.WebControls.WebControl will launch Reflector and navigate to the WebControl type in the System.Web.UI.WebControls namespace.

Custom types can also be navigated to, although the associated assembly must be loaded first.

By default, FlexWiki does not handle all protocol handlers. To get it to handle the code:// protocol, a recompile is needed. I'm working with version 2.0.0.41. Later versions are now available, but the code should be in a similar place. So, for version 2.0.0.41, changes are needed to the file: FlexWikiCore-2.0.0.41-src\EngineSource\Formatter.cs.

Change lines 1706 and 1707 - adding the 'code|' segment next to the https?| text:

static string urlPattern = 
  @"((https?|code|ftp|gopher..." ) ;

static string urlPatternInBrackets = 
  @"((https?|code|ftp|gopher..." ) ;

I must say, it's very handy for your team to be able to navigate directly to code from a Wiki entry.

ReSharper 3.0 released

2007-06-22T09:03:00.001Z

The new release of ReShaper has a great set of new features and seems to be very stable. The only downside: it doesn't yet run in Visual Studio 2008 (Orcas). This is planned for version 4.0 which is planned for release at the end of the year. The lack of ReSharper may just put off beta testing the new Visual Studio. If I hear of how to get it to work, I'll post it here.

Framework design lecture avaliable for download

2007-06-19T10:58:00.001Z

Krzysztof Cwalina, co-author of the excellent Framework Design Guidelines book, did an API design lecture a little while back and it's now available for download here.

Object Oriented vs Test Oriented

2007-05-17T14:25:00.001Z

Roy is debating this very topic - that is - for any API that needs to be unit-tested, do we forego OOD principles, such as hiding irrelevant stuff, in favour of testability?

To summarise Roy's case: he's using public bits of the FxCop API to automate (unit-test) his custom rules - but... the FxCop team have realised they've got a bunch of types that shouldn't be exposed and will be making them internal in the next 'Orcas' release. This means that Roy's unit-tests will not compile against the new API.

I think the issue here is Roy using something in the API that wasn't intended to be exposed but is rather useful; that is, offering an API to automate custom rules. From what I can see, the FxCop team are quite correctly 'concealing' types that shouldn't be exposed; I for one would be glad of this decision if I were looking through their API 'contracts' - I wouldn't want to spend time creating and trying to use an exposed type if it weren't mean to be exposed.

I do see the need to automate testing of custom rules, but I think this should be designed as appopriate additions to the API for that particular purpose (rather than relying on accidentally exposed types spread throughout the API to acheive the same thing). This way, the API stays tight, and also enables a more succinct, targeted API for automating tests for custom rules.

Of course, this doesn't anwser the more general question "How do I design an API that hides irrelevant stuff but also enables the irrelevant stuff to be tested?"

In fact, in the paragraph above, I was going to use the term 'How do I design an API that is both OO and easily tested', but, as Framework Design Guidelines correctly states, API's are not meant to be Object Oriented (the implementation is OO, not the public API).

So, I suppose the question really becomes 'How do I hide my OO implementation but make it easily testable?"

One way is to have the unit tests in with the implementation. I'd prefer not to do this, but I've done it in the past. I've also taken the other route and made the odd type here and there public instead of internal so I can test externally.

I've been toying with the idea of having a 'Unit Test Facade' object in my OO code/API. Anyone use the 'API' can see my intent from what's exposed, and anyone running unit tests can exercise the implementation via the facade. Of course, this adds overhead, but does make the distinction between the API and implementation.

Uploading to an FTP server with parameters

2007-05-09T16:26:00.001Z

This post will have a limited audience (even more limited than my normal posts!), but if you're searching for a solution to this particular problem, I hope you'll be glad you found this.

I was recently tasked with uploading a file to an FTP server. I optimistically estimated that it shouldn't take long as we're using .NET 2.0 and there's FTP stuff in 2.0.

But, the particular server I had to write to took parameters on the PUT command (something I'd never seen before). The put looked something like this:
PUT thefile.txt %destinationFilename.txt%param2%%param4

The parameters tell the server things like what 'mailbox' to use, what account to use to write the file, etc. etc.

A quick bit of info on FTP: you first send the PUT request, and get a response, followed by other requests (for things like credentials), followed ultimately by sending a STOR command.

The .NET 2.0 implementation of FtpWebRequest does not take into account differences between the 'request (PUT)' parameters and the 'command (STOR) parameters'.

To get around this, one must use sockets directly. I found a Microsoft KB article that contained just that. The sample demonstrated using pluggable protocol handlers. I removed the bits that weren't relevant and modified it to handle command parameters.

I fronted all this with an FtpTransfer class that deals with just uploading files. Typical usage looks like this:

FtpTransfer ftpTransfer = new FtpTransfer( 
    new Uri( @"ftp://serverRequiringParameters" ), 
    @"yourUsername", 
    @"yourPassword" );

ftpTransfer.UploadFileWithParameters( 
    @"c:\temp\ftptest.txt", 
    @"destinationFilename.txt", 
    @"%destinationFilename.txt%PARAM2%PARAM3" );

The source (and a Visual Studio 2005 project) can be download here.

Beta Testing Windows Home Server

2007-04-18T20:15:00.001Z

Time to try another beta OS from Microsoft. This time, Windows Homer Server. Thirty seconds in and I'm getting my first error (well, it's better than waiting 30+ minutes like back in the days of the Windows 2000 beta!)
The error was "Could not initialize UI subsystem". I looked around the forums and found suggestions to try and set the DVD
as the first boot device. Mine already was. I then found a suggestion to use different DVD burning software. Rubbish I thought and carried on searching.
Having come to a dead-end, I tried what was suggested and downloaded the free 'ImgBurn' utility. This software is great. Not only did it fix the installation problem, but it's also a light-weight utility to burn stuff to CD's and DVD's (190mb for Nero 7, 1.5mb for ImgBurn!). Sold!

Framework Design Guidelines

2007-04-02T14:17:00.000Z

Framework Design Guidelines is a fantastic book about er, guidelines for designing frameworks (API's). Krzyztof, one of the authors, has now posted a video of a talk he did about this very subject.

Running unit tests in Visual Studio Express

2007-03-19T20:43:00.001Z

The brilliant TestDriven.net can't run in Visual Studio Express (well, from what I've heard, it can, but Microsoft asked for it to be removed).

Therefore, to run unit tests in Visual Studio Express, you must set your debugger application to point to NUnit.exe (or the brilliant MBUnit). This isn't straightforward in Express and means editing the .csproj file by hand and telling it to run the NUnit exe.

Today, I wanted to run and debug some unit tests I'd written in the XNA Game Studio Express (Visual Studio Express with some XNA bits bolted on). I couldn't have the excellent right click/run unit test feature and I thought there's got to be a better way than editing the .csproj file manually.

So I changed the unit test project to be a console application and added this to the Main method.

    public static void Main( )
    {
      AppDomain.CurrentDomain.ExecuteAssembly( 
        @"C:\Program Files\NUnit-Net-2.0 2.2.9\bin\NUnit-console.exe",
        null,
        new string[ ] { Assembly.GetExecutingAssembly( ).Location } );
    }

And it worked. Which was nice.

Update:

Jamie recently left a message saying that the new Beta version DOES support Express editions! Read his post here and get downloading straight away!

Email certificate popups

2007-02-25T17:48:00.001Z

I recently switched to Vista and Office 2007. I set-up Outlook with the details of my email certificate. The trouble is, whenever sending a message, Vista pops up a dialog asking whether to grant or deny permission to the certificate. The exact text is:

"Grant or Deny this application permission to use this key".

The way around this is to not use Outlook to install the certificate but to right click on the certificate in Explorer and let Vista install it. Another important thing when doing this is to NOT click the Strong option - this is what causes the prompting - leave it as Medium.

To reinstall the certificate:

Go to Internet Explorer/Tools/Option/Content/Certificates then Export your certificate (checking the box to delete it after export).
Then, right click from Explorer and select Install.
When this is done, reselect the certificate from Outlook - Tools/Trust Center/E_mail Security.

A tool for converting animated GIFS to spritemaps

2007-02-11T18:29:00.005Z

I'm having a lot of fun playing around with the XNA development kit. One day I'll get around to learning 3D but for now I'm still having too much fun with sprites! I wanted a tool that took an animated GIF and produced a spritesheet (a bitmap with each frame of the GIF).

From this:

... to this:

I couldn't find a tool forthis (although I'm sure they exist), so I did my own and uploaded it to my tools page

New version of the Code Formatter Plugin for Windows Live Writer

2007-02-03T20:00:00.001Z

Version 1.0.0.2 can be found here. This update adds the ability to change the font - including the font name, size, style, and weight.

2007-01-18T08:15:00.000Z

A New Version of Microsoft Terminal Services Client (Remote Desktop) Version 6 of MSTSC now supports multiple monitors(!) as well as wide-screen resolutions and other features that I haven't yet tried. This is the version that comes with Vista but it's worth noting that there is a download for Windows XP SP2 and Windows Server 2003. It's also worth noting that the new features are only available if the machine you're connecting to is Vista or Longhorn Server.

FluentInterface

2007-01-17T13:03:00.000Z

I've posted before about the StringBuilder tip in .NET.

Martin Fowler describes this as an ExpressionBuilder pattern.

More formal terms are described in his post, for instance, a FluentInterface which allows code like this:

customer.newOrder() 
	.with(6, "TAL") 
	.with(5, "HPK").skippable() 
	.with(3, "LGV").priorityRush();

I personally like this style but agree that if every object had these strange looking methods it would certainly pollute an API.

Another formal term describing how not to pollute an API is CommandQuerySeparation. Basically, this means that a method that changes the observable state of an object shouldn't have a return value.

The ExpressionBuilder pattern is the solution to this: it is a seperate object that defines the FluentInterface and yet doesn't pollute the API.

I'm glad that I now know more than 3 patterns, the Factory pattern, the Visitor pattern, and the Submarine pattern.

Settling into my XNA Development Environment

2006-12-22T11:21:00.001Z

Microsoft recently released the XNA toolkit for XBox 360 and PC games development. The supported IDE for this is Visual C# Express.

I am quite picky about my development environment, for instance: I like the Consolas 12pt font; I like 2 tab spaces instead of 4; I like virtual space in the editor; etc. etc.

Visual Studio Express does not give the option to change tab size and virtual space settings so I immediately jumped into regedit and edited the values. Then I thought that maybe I could export my settings from Visual Studio 2005 Professional and import them into Express.

This worked, with the exception of some command bar stuff that isn't supported in Express. The added bonus was that the Options screen now displays more settings that before:

Options screen before import:

Options screen after import:

Very nice. It's just a shame that Express doesn't support plug-ins as I really miss ReSharper.

ReSharper 2.5 Released

2006-12-12T11:00:00.001Z

The download links don't seem to work at the moment (they're still pointing to version 2.0.2). The link to the direct download is http://download.jetbrains.com/resharper/ReSharper-2.5-setup.exe (which I rather cleverly deduced from the existing broken link of http://download.jetbrains.com/resharper/ReSharper-2.0.2-setup.exe)

Remember though, this is Visual Studio 2005 only.

In the name of science

2006-11-30T12:10:00.001Z

What is the speed of meme? People write in general (typically truimphant) terms about how swiftly a single voice can travel from one side of the internet to the other and back again, but how often does that actually happen?

If you have a blog, please read this and follow the instructions. I'm supposed to beg you to do this, but the title of this post is "In the name of science" and not "In the name of science and commision" !

FAJAX - Fake AJAX!

2006-11-30T11:09:00.001Z

AJAX is great for reducing page flicker when posting back to the same page (for instance, updating a listbox or a textbox), but a lot of a web-site navigation involves clicking around to different pages.

DHTML behaviour has been around a good few years allowing page developers to have page transitions (such as wipe, chequerboard etc.) when the page loads and unloads. None of these transitions were that great and a certain amount of flicker was still present.

I’ve seen a few sites recently that have a nice fade transition that is much smoother than DHTML behaviours. I’ve just discovered from this blog, how it’s done.

I Hate ClearCase Part II - When a text file isn't a text file!

2006-11-21T10:53:00.001Z

Here's a question: If you have a text file that contains a very long line of text (>8000 characters), is it still a text file?

I'd say Yes. But ~~Computer~~ClearCase says No. Or at least hinted it meant No via several obscure error messages.

The file in question is a whole bunch of JavaScript code (part of the Microsoft AJAX release) that is not intended to be read by anyone viewing a web page, and hence is sensibly put on one line (albeit 69168 bytes in length).

Firstly, I was getting a strange error when adding them to ClearCase. Apparently, despite of the error, they were being added – I found them in a checked-out state. Upon trying to check them in, I got:

Error checking in '...MicrosoftAjax.js'. Type manager "text_file_delta" failed create_version operation.
Unable to check in '...MicrosoftAjax.js'

...followed by OK and Cancel buttons (quite how one can Cancel an operation that can't be done anyway is beyond me!)

I then thought I’d take a look at the file and did a ‘diff’ with the previous version. I got this:

Error encountered doing compare operation.
"c:\temp\ccdm02327" is not a 'text file': it contains a line exceeding 8000 bytes.
Use a different type manager (such as a compressed file).

So, according to ClearCase, a text file is not a text file if it has lines of over 8000 characters!

Anyway, the solution was to use the cleartool command line tool to add the file using a different 'type' - a compressed text file type. Note that this doesn't actually change the contents of the file, nor the way it's handled (thankfully!). Of course, once the solution was presented to me...

C:\folder\ScriptLibrary\Release>cleartool mkelem -nc -eltype compressed_text_file MicrosoftAjax.js

...everything became perfectly clear!

I Hate ClearCase - Part I

2006-10-30T13:18:00.001Z

ClearCase isn't my favourite source control system. I find the UI clunky and for the most part, it's way over engineered.

I've just tried deleting a file and I'm getting an error message that says:

Trigger "NO_RMNAME" has refused to let rmname proceed.
Unable to remove "[file]".

WHAT DOES THIS MEAN AND HOW DO I DELETE A FILE?!

My 20+ years of working with software - coupled with my powers of deduction, have led me to "guess" that this means I don't have the permission to delete a file! (I could be wrong; I'm waiting for the in-house ClearCase administrator to advise!)

I'm going to stop using the advanced features of this software and continue with the basics...

Cassini and assembly loading problems

2006-10-24T13:36:00.001Z

Cassini is the Visual Studio development web server. Generally, Cassini is great; you give it a port number and a path and off it goes - hosting ASP.NET pages in a similar fashion to ISS but much quicker. Plus, it's unloaded when you stop debugging.

One issue I came across today was with Cassini and the loading of assemblies. During development of .NET applications, I like to use project references rather than binary references (whether those references are in our out of the GAC).

The problem lies with the fact that Cassini occasinally switches app domains, forcing objects to be serialised across. This serialisation was failing as one of our serialisable objects were in an assembly that wasn't in the GAC and wasn't available anywhere for the Cassini process to load. The exact error was:

Type is not resolved for member 'Company.Product.Type,Company.Product.dll, Version=1.0.0.0, Culture=neutral, PublicKeyToken=blah'

Investigation led to the suggestion to use DEVPATH. Basically, this means adding the following entry to the ‘runtime’ section of the machine.config file:

<developmentMode developerInstallation="true"/>

… and setting the DEVPATH environment variable to the directory where your private copies of assemblies are located. This is supposed to load a matching assembly regardless of version. Unfortunately, this didn’t work and for whatever reason, a ComException was being thrown very early on when Cassini started.

Although this didn't work, there was a link in the page to another MSDN article describing a way to redirect assembly loading. This again used the runtime section of the machine.config file, but this time using:

 <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <assemblyIdentity name="Company.Product" publicKeyToken="blah" culture="neutral" />
        <codeBase version="1.0.0.0" href="file://C:/Blah/Company.Product.dll"/>
      </dependentAssembly>
    </assemblyBinding>

This worked great and saved me having to use IIS or copying my assemblies all over the place so Cassini can load them.

I hope this post proves useful to anyone having a similar problem. It will probably prove useful to me when I come across the problem again in the far future having forgotten how I got around it the first time!

What to expose in a framework

2006-10-23T15:27:00.001Z

Scott Hanselman blogged recently on reasons to make a class public in a framework. One reason was that a developer may want the functionality offered by a particular class, either to be used as-is or to be extended.

Normally, frameworks are quite specific in what they do and what they provide. If a whole 'chunk' (class) is required to be made public, then it may be the case that this functionality isn't in the realm of what the Framework was designed to offer. For example, should a class that lists the zipped files in a directory be exposed from a compression framework? Or, should a regular expression helper class be exposed from a logging/tracing framework?

Opening up large chunks of code because someone wants the functionality can dilute the Framework and make the API harder to understand because it offers so much functionality. With this in mind, if the framework you've given them doesn't do what they want, then maybe rethink ways of incorporating the functionality into the Framework rather than opening up a chunk of code.

You might be thinking that it'd be difficult incorporating all the functionality of a particular class into other parts of the framework; classes, whether internal or exposed, should be succint (following the Single Responsibility Principle) - so there shouldn't be too much to move around to give them the features they require.

When we start talking about frameworks and OO concepts such as SRP, it brings to mind a very valid point raised in the excellent Framework Design Guidelines book - something along the lines that OO should play a part in the implementation of a framework but not in the API of the framework (I think the example of Streams/TextReaders was used as a very good example). The .NET Framework now seems to have more and more utility classes that help to flatten the heirarchy and (in my opinion) increase usability/memorability.

Some examples would be a good way of testing our arguments. Perhaps examples based on the .NET Framework wouldn't be the best to use as this is a lot more generic than say, frameworks for logging/tracing or compression.

Retrieve your Windows OS Product Keys

2006-10-22T08:50:00.001Z

Today I needed to get the Windows XP Product Key but didn't have the neccessary information to hand. I did a search and found the MagicJellyBean utility.

This worked but I was curious how it worked. I read around a little bit and discovered a snippet of C# code from Willem's blog.

I then modified it a bit and created my own C# WinForm application.

The application lists the most common product keys (Windows XP and Office) and has a button to search for more keys that look like product ID's. It searches all keys in HKEY_LOCAL_MACHINE.

Here's the source code and here's the binary. Note, the application depends on the .NET Framework 2.0. Also, save the binary before running it otherwise it'll run with restricted permissions and won't be able to probe the registry.

Visual Studio Orphaned Project Items Finder

2006-10-21T21:32:00.001Z

The name is a bit of a mouthful, but sums up what it's all about. It finds orphaned items in a Visual Studio project. Inspired by Clean Source Plus, this utility is a stand-alone application and also a right-click Explorer menu item.

Recently I came across several dozen projects that had been worked on by dozens of people for several years. Inevitably, there were files present in the source tree that were not part of the project.

This is a tool to find those files. Please feel free to download it from CodePlex. There is an installer file and the source code is also available. If you'd like to contribute to the project, please let me know.

To use it is very simple. Download it and run it, or right click a Visual Studio project in Explorer and 'Find Orphaned Items...'.

Warning!

I've tested this project on Visual Studio 2003 and 2005 projects. I haven't tested this on Web Projects or Web Application Projects (in Visual Studio 2005). I would recommend verifying what the application thinks are orhpaned items. If it continually gets it right, you can trust it more and check it less. If it continually gets it wrong, then please let me know!

Problems with Forms Authentication and ASP.NET Themes

2006-10-20T18:58:00.001Z

It's sometimes the strangest (and seemingly irrelevant) combinations of technology that give you the most problems. For a good few hours I've been wondering why my web site, which uses Forms Authentication and Themes, was not displaying any formatting or images.

It turns out that the URLs specified in the authentication section in web.config are used for ALL resources. So, in my case, the page was trying to load a .css file but ASP.NET was redirecting the request to default.aspx, which of course, is not a style-sheet and has a different MIME type. Here's the section of my web.config file:

<authentication mode="Forms">
      <forms  loginUrl="Default.aspx"
        defaultUrl="Default.aspx"
        protection="All"
        timeout="30"
        path="/"
        requireSSL="false"
        slidingExpiration="true"
        cookieless="UseDeviceProfile"
        domain=""
        enableCrossAppRedirects="false"/>
    </authentication>

To fix this, I allow unauthenticated access to the resources, which was straight-forward. I added the following to the web.config file:

 <location path="App_Themes">
    <system.web>
      <authorization>
        <allow users="*"/>
      </authorization>
    </system.web>
  </location>

The tricky part in finding this was that the page's HTML looked fine, there were no errors, and saving the resulting HTML to a file and viewing it produced the right results.

Firefox's JavaScript Console proved incredibly helpful in finding the problem:

Once I saw this, it all fell into place!

BackgroundWorker - automating this handy class

2006-10-19T06:39:00.001Z

BackgroundWorker objects are an addition to .NET 2.0 to simplify asynchronous programming and are very useful in (but not restricted to) Windows Forms.

The basic idea is:

Create a BackgroundWorker object
Set-up various events on it, like DoWork, RunWorkerCompleted, and ProgressChanged
Set-up various properties, like WorkerReportsProgress and WorkerSupportCancellation
Call RunWorkerAysnc

...then, in your form you get notified of progress and can cancel the operation at any time.

I've created a ReSharper Live Template that will help you create and set-up the BackgroundWorker object. You can download it here. For instructions on importing the Live Template into ReSharper, see my previous post here.

Visual Studio Build Tip

2006-10-18T07:18:00.003Z

By default, Visual Studio will build all of the projects in your solution regardless of any errors.

The problem with this is that if the first project it builds contains an error, the resulting binary will not get generated. If any other projects depend on this (which is normally the case, as it was the first to be built) then they'll fail too, and so on to the end of the project heirarchy.

Pointless; you'll spend ages sitting around in a locked IDE unable to edit the error until the build finishes.

You might as well stop at the first error. You could of press Ctrl+Break (several times) and hope that VS will eventually stop. But, there's a better way: get Visual Studio to stop automatically after an error.

Go to Tools/Macros/Macro Explorer
Expand MyMacros
Double click Module1
This will bring up the macro in a new window. In that window, double click the EnvironmentEvents entry.
From the drop-down (currently 'General', select 'Build Events')
Select 'OnBuildProjConfigDone' and paste this in:

If Success = False Then 'The build failed...cancel any further builds.
DTE.ExecuteCommand("Build.Cancel")
End IfThe whole method should look like this:
Private Sub BuildEvents_OnBuildProjConfigDone( _  
ByVal Project As String, _ 
ByVal ProjectConfig As String, _ 
ByVal Platform As String, _ 
ByVal SolutionConfig As String, _ 
ByVal Success As Boolean) Handles BuildEvents.OnBuildProjConfigDone   
    If Success = False Then 'The build failed...cancel any further builds.     
        DTE.ExecuteCommand("Build.Cancel")   
    End If 
End Sub

ReSharper Live Templates for validating parameters of public C# methods.

2006-10-04T06:21:00.001Z

ReSharper Live Templates are smart shortcuts you can type and have filled in automatically. For instance, typing 'foreach' and pressing tab produces:

      foreach ( object o in something )
      {
      }

I've created 3 Live Templates for validating arguments in public methods (C#). Here's a short video demonstration. I've blogged about these before for ReSharper 1.5 and said that there's no way to export/import the templates. But in ReSharper 2.0, there is! You can get them here. Go to ReSharper/Options/Templates/LiveTemplates and click the 'Import templates from file' button.

MbUnit and null parameters

2006-09-29T11:21:00.000Z

I've recently moved from NUnit to MbUnit. I like the extra features it offers, in particular, the RowTest feature. This allows a single test to take different parameters - the parameters of which are specified in the attributes. Here's an example:

class Test
{
    internal Test( string s )
    {
        if( string.IsNullOrEmpty( s ) )
            throw new ArgumentNullException( ) ;
    }
}

[ RowTest ]
[ Row( @"Hello World!" )]
[ Row( @"Another string" )]
public void Test1( string val )
{
    Test t = new Test( val );
}

Here, Test1 is being given the parameters from the attributes on the test. Previously, say, in NUnit, I'd have written a couple of unit tests that create this Test object and give it different values. Normally, I'd also write a couple that would try and create one with a null string and an empty string and assert that it throws an ArgumentNullException.

Now, in MbUnit, I went to write the test like so:

        [ RowTest ]
        [ Row( null , ExpectedException = typeof( ArgumentNullException ) ) ]
        [ Row( @"Hello World!" )]
        public void Test1( string val )
        {
            Test t = new Test( val );
        }

Strangely, this caused an internal error in MbUnit. Reading around, It looks like MbUnit is taking the first parameter of Row and treating it as an array rather than a single parameter. The complete non-obvious way around this is to cast the null to a string:

        [ RowTest ]
        [ Row( (string)null , ExpectedException = typeof( ArgumentNullException ) ) ]
        [ Row( @"Hello World!" )]
        public void Test1( string val )
        {
            Test t = new Test( val );
        }

This now works. Which is nice!

.NET Memory usage - A restaurant analogy

2006-09-06T19:46:00.000Z

Tess uses a great analogy of restaurant bookings to describe .NET memory usage. The rest of the posts in this blog are also very interesting. Thanks Tess.

Link to If broken it is, fix it you should : .NET Memory usage - A restaurant analogy

Thanks for the feedback on the CodeFormatter plugin

2006-09-06T19:31:00.000Z

I'd like to thank everyone for their feedback on the CodeFormatter plugin. I've had some great suggestions and fixed a few bugs. Keep them coming!

ReSharper 2.0.1 Maintenance Release Now Available

2006-08-25T22:15:00.000Z

ReSharper 2.0.1 Maintenance Release Now Available

JetBrains ReSharper version 2.0.1 is now available for download at http://www.jetbrains.com/resharper/download/.
This release fixes a number of bugs and usability issues, in addition to substantial performance improvements. For more information, please see online Release Notes.
The update is a free maintenance release for all licensed users of previous ReSharper versions. All current users are highly encouraged to upgrade, due to the transition of the ReSharper development project to a new issue tracking system. So, the new release automatically sends bugs and exceptions to this new system.
Keep developing with pleasure!

Source: JetBrains .NET Tools Blog » Blog Archive » ReSharper 2.0.1 Maintenance Release Now Available

Code Formatter Plugin now on Codeplex

2006-08-23T21:34:00.000Z

Check it out on Codeplex. Please leave feedback on anything you'd like see. The source code is there if you want to look around. Let me know if you'd like to contribute.

Resharper 2.0.1 RC2 is now available.

2006-08-22T21:19:00.000Z

One of the best tools ever just keeps getting better and better! Get RC2 here.

New version of the Code Formatter plugin for Windows Live Writer now available.

2006-08-22T21:14:00.000Z

The new binaries are here. One small bug fixed in the form where you edit the code: pressing return caused the OK button to fire. Doh! Thanks to JTB World for spotting it.

Windows Live Writer - Bug

2006-08-22T21:07:00.000Z

When content in a smart plugin exceeds the height of the canvas area, dragging on the size points on the surrounding rectangle causes strange behaviour. Is anyone else seeing this or is it just me?

Windows Live Writer - Additions to API

2006-08-22T21:01:00.000Z

Maybe this already exists, but it's not immediately obviose. When developing a plugin, the component that sits along the right side of the screen is the Content Editor. WLW has its own color scheme and to intermingle* nicely with it, it'd be nice if the color(s) used were available.

*is that a word?!

Code Formatter Plugin for Windows Live Writer

2006-08-20T22:01:00.000Z

I'm quite new to blogging and have recently discovered Windows Live Writer. I've downloaded various plugins for code formatting but none provided me with what I wanted:

The ability to format the code 'live'
The ability to wrap lines
The ability to change the background color
The ability to just quickly paste what's in the clipboard as code

The plugin I implemented formats and highlights code and also does all the above. Here's a screen shot of it in use:

Here you can see that the content editor on the right can change the tab width, background color, language, and line numbers.

Below are some sample of code used with the plugin.

Here's some C# code:

public int TabWidth

{

get

{

return _content.Properties.GetInt( @"TabWidth", 4 );

}

set

{

_content.Properties.SetInt( @"TabWidth", value );

}

}

and some XML markup...

<Triggers>

<KeyPressTrigger Key="PropertyListTrigger" Character=" ">

<KeyPressTriggerValidStates>

<KeyPressTriggerValidState State="PropertyState" />

</KeyPressTriggerValidStates>

</KeyPressTrigger>

<KeyPressTrigger Key="ValueListTrigger" Character=" ">

<KeyPressTriggerValidStates>

<KeyPressTriggerValidState State="ValueState" />

</KeyPressTriggerValidStates>

</KeyPressTrigger>

</Triggers>

I've made available the source and the binaries for this plugin.

To use it, extract the binaries to \Windows Live Writer\Plugins and run WLW. The source is in C# 2.0 and comes with a Visual Studio 2005 solution.

Note that the .NET 2.0 Framework must be installed before this plugin will work.

Going forward

I plan to put this plugin onto CodePlex (if they let me!). I also plan on making a few additions to the defaults via the Options screen. New languages can easily be added too thanks to the great ActiPro Code Highlighter. I'd also like to thank Christophe De Baene for his syntax highlighting tool. It's a great plugin and also helped me understand how to use the ActiPro control.

Please let me know if you'd like to contribute on CodePlex or if there are any features you'd like to see at steve at dunnhq d.o.t. com

Converting System.Drawing.Color to HTML color (and vice-versa)

2006-08-18T21:35:00.000Z

This is something I need very rarely. So rare in fact that in-between uses it is completely removed from my memory, leaving just the fact that I know I've searched for it before!

To convert a .NET Color object to an HTML RGB or named color, use

string colorAsString = ColorTranslator.ToHtml( _backgroundColor ) ;

and vice-versa

Color c= ColorTranslator.FromHtml( @"#RRGGBB" ) ;

Reshaper Live Templates for validating arguments

2006-08-16T19:15:00.000Z

I strongly agree with the 'contract' mataphor in API design, hence my interest in Spec# (that I've blogged about before).

To assist in this and to eliminate the tedium of writing argument checks, I've created 3 Resharper Live Templates. These check for

null parameters for any object passed
invalid parameters for any object passed
null or empty check for any String passed.

These templates are called 'arg', 'argnull' and 'argempty' respectivly.

Resharper 1.5 doesn't allow importing or exporting of Live Templates from the GUI. They are however stored in an XML file at %userprofile%\Application Data\JetBrains\ReSharper\UserSettings.xml. Below is a chunk of XML that must be placed under the TemplateManager\Templates node. If you have any others, please let me know!

<Template text="if( $TYPE$$EXPRESSION$ )
 throw new ArgumentException( @"Cannot $ACTION$ as the value passed was invalid. Please provide a valid value.", @"$TYPE$" ) ;
" shortcut="arg" description="Throws an ArgumentException" kind="livetemplate" reformat="false" fileMask="" context="Everywhere" fileContext="CSharp" enabled="False" id="1723695683">
<Variables>
<Variable name="TYPE" expression="variableOfType("System.Object")" initialRange="0" />
<Variable name="EXPRESSION" expression="constant(" != 1")" initialRange="0" />
<Variable name="ACTION" expression="constant("PERFORM AN ACTION")" initialRange="0" />
</Variables>
</Template>
<Template text="if( $TYPE$ == null || $TYPE$.Length == 0 )
throw new ArgumentNullException( @"$TYPE$", @"Cannot $ACTION$ as the value passed was null or empty. Please provide a valid non null value." ) ;
" shortcut="argempty" description="Throws an ArgumentNullException when a string is null or empty" kind="livetemplate" reformat="true" fileMask="" context="Everywhere" fileContext="CSharp" enabled="False" id="1705884294">
<Variables>
<Variable name="TYPE" expression="variableOfType("System.String")" initialRange="0" />
<Variable name="ACTION" expression="constant("PERFORM AN ACTION")" initialRange="0" />
</Variables>
</Template>
<Template text="if( $TYPE$ == null )
throw new ArgumentNullException( @"$TYPE$", @"Cannot $ACTION$ as the value passed was null. Please provide a valid non-null value." ) ;
" shortcut="argnull" description="Throws an ArgumentNullException" kind="livetemplate" reformat="true" fileMask="" context="Everywhere" fileContext="CSharp" enabled="False" id="1497171628">
<Variables>
<Variable name="TYPE" expression="variableOfType("System.Object")" initialRange="0" />
<Variable name="ACTION" expression="constant("PERFORM AN ACTION")" initialRange="0" />
</Variables>
</Template>

Spec#

2006-08-16T19:07:00.000Z

Spec# is an addition to C# to allow specifications to be explicitly added to methods. Specifications can state that a method takes a string (which must be non-nul), an integer (which must be between 0 and n), or an array (of which all entries must be non null). Previously in C#, this would have meant a fair few lines of code that manually checked parameters and threw the respective exceptions. Furthermore, without specifications, you cannot force any over-ridden method to comply to the same specification.

Spec# is currently a research project and can be downloaded at http://research.microsoft.com/specsharp/

It can be installed to run in Visual Studio 2003 and 2005. For both systems, it requires an application called Simplify. This is a java application that can be downloaded at HP Labs Java Programming Toolkit page. The zipped file that contains Simplify.exe can be found at http://www.hpl.hp.com/downloads/crl/jtk/download-escjava.html, but don't forget to first read the licence at http://www.hpl.hp.com/downloads/crl/jtk/agreement.html ;)

Quicky StringBuilder Tip

2006-08-16T18:53:00.000Z

StringBuilder has an Append method that returns a reference to itself. This is useful for when you want to append several items in one go. The following code is an example. Obviously, you'll get more benefit the more items you add:

      StringBuilder sb = new StringBuilder( ) ;
      string s = sb.Append( @"Hello " )
        .Append( @"World" )
        .ToString( ) ;

If you've been forced into programming in VB, then check out the original text of this tip at devx.com:

http://www.devx.com/tips/Tip/28152

Quicker loading of the Visual Studio .NET IDE

2006-08-16T18:51:00.000Z

A handy tip from the Bug Slayer MSDN column:

Tip 57 - To hasten the startup of the Visual Studio .NET IDE, get rid of the Start Page. Because the Start Page requires all Web-browsing components to be loaded, you can chop off a considerable amount of startup time by skipping it. To turn off the Start Page, select Options from the Tools menu to bring up the Options dialog. In the Environment/General property page, select "Show empty environment" in the "at Startup" combobox.

Of course, with Resharper installed, this causes the the IDE's start-up time to become terribly slow. But it's worth it!