James Crisp » C#

Bounded Actions Using Lambda - IDisposable is old and ugly!

James — Mon, 26 May 2008 13:17:37 +0000

In .NET 2, it was all the rage to make hand-crafted, clever IDisposables that let you do a bounded action with clean up. Eg,

void SomeMethod()
{
        using (new SetCursorToWaitEggTimer())
        {
            VerySlowOperation();
        }
}

void VerySlowOperation()
{
    ... etc ...
}

This was kind of cute - you could make sure that, even if an exception was thrown, your clean up (eg, changing cursor back to normal) would occur. Implementing the IDisposable was a bit ugly but consuming it wasn’t bad.

Now, with the sexy C# 3 syntax, you can do something similar much more elegantly. Eg,

void SomeMethod()
{
       DoWithWaitEggTimer(VerySlowOperation);
}

void DoWithWaitEggTimer(Action action)
{
    try
    {
        Mouse.OverrideCursor = Cursors.Wait;
        action();
    }
    finally
    {
        Mouse.OverrideCursor = null;
    }
}

If you’re feeling like more adventures, you can also start passing these delegates around and injecting them. For example:

class SomeClass
{
    public Action RunSlowCode
    {
    	get { return runSlowCode ?? new Action(a => a.Invoke()); }
    	set { runSlowCode = value; }
    }
    Action runSlowCode;

    void DoSomethingSlow()
    {
         RunSlowCode(PullDataFromExternalSystem);
    }
}

This approach allows you to inject the delegate for what happens when slow code is run. So you could inject DoWithWaitEggTimer() or something new like DoWithWaitMessageDisplayedToUser(). Similarly, it could be used for unit testing or injecting between layers in your application.

C# Default Access Modifier for Class Members - and drop that private habit!

James — Mon, 26 May 2008 12:39:28 +0000

The default access modifier for the members of a C# class (eg, fields, methods, and properties) is ‘private’. As such, I recommend never using the redundant ‘private’ keyword for class members. Leaving off the private nicely separates your privates from your public/inheritable interface in syntax highlighting. It also saves people having to read redundant code - you wouldn’t want your code to be full of un-needed casts, or redundant ‘this.’ references, would you?

WPF Control Inheritance With Generics

James — Mon, 26 May 2008 12:19:17 +0000

Working in WPF is quite exciting - there’s a lot of new possibilities, especially with easy control composition, much improved binding and Expression Blend to make sexy interfaces. One of the things you’re likely to want to do though, when writing anything more than a toy application, is to have a base class for your UserControls or Windows, to share common functionality. It is also quite likely you will want to use generics in conjunction with control inheritance. With both the code behind, and the XAML, it’s not immediately obvious how to do generic inheritance. It is a bit fiddly to get going, and sometimes the errors are not helpful. Here’s a simple example that outlines how to bring it together.

The base control

namespace WpfGenericsDemo
{
    public class BaseUserControl : UserControl where T : IPresenter
    {
        public BaseUserControl()
        {
            ... various configurations ...
        }

         ... Awesome functionality to share ...
    }
}

The child control code-behind

namespace WpfGenericsDemo
{
    public partial class ChildUserControl : BaseUserControl
    {
        public ChildUserControl()
        {
            InitializeComponent();
        }

         ... More code ...
    }
}

The child control XAML



    ... The rest of your awesome XAML ...

Notes

Your top level node is the parent class of the control you want to create (eg, BaseUserControl). You specify the control class you want to create with ‘x:class’ (eg, ChildUserControl)
‘x:TypeArguments’ is the way you specify the generic type (eg, ChildPresenter)
You need to namespace your classes - eg, with ‘xmlns:WpfGenericsDemo’ which uses a clr-namespace style reference
Only your top level node can be genericised in XAML

NUnit Test Runners Were Not All Made Equal

James — Tue, 08 Apr 2008 07:26:11 +0000

NUnit tests can be run using a variety of different runners. Some common ones are:

The NUnit GUI and Test Driven create a new instance of the test class for each test run. This leads to more isolation but potentially slower performance.

Resharper and NUnit MSBuild Task re-use the same instance of the test class when running each test in the class. This can lead to unintended interaction between tests. Using these runners, it is vital to to assign initial values to instance variables in SetUp, rather than when they are defined or in the constructor.

If you use a mix of different test runners, you can end up with tests that pass on some machines and fail on others (eg, Test Driven locally works fine, but you use NUnit MSBuild Task on your build box and get intermittent failures).

NUnit SetUp Attribute and Subclassed Test Cases

James — Tue, 08 Apr 2008 07:05:44 +0000

If you have a ChildTestCase class that inherits from a ParentTestCase class, and both of these have a SetUp method, marked with the [SetUp] attribute, would you expect both to be called? If so, you would be sadly disappointed. Only the SetUp method of the ChildTestCase will be called, and the SetUp in the ParentTestCase will be ignored.

According to the NUnit documentation on the Set Up attribute, this is intended behaviour:

If you wish to add more SetUp functionality in a derived class you need to mark the method with the appropriate attribute and then call the base class method.

An alternative approach to get all your SetUps called is to have a base TestCase class define a protected virtual SetUp() (with the SetUp attribute), which all child classes override (and call base on their first line).

Delicious .NET - Slides & Code

James — Thu, 04 Oct 2007 04:47:07 +0000

Here’s the slides and code from yesterday’s “Delicious Dot Net” talk at ACS.

ACS Talk - “Delicious .NET” - 3rd Oct

James — Fri, 28 Sep 2007 13:41:38 +0000

I’ll be giving a talk at an ACS event after work on Wed next week (3rd October). Here’s the blurb:

A tasty take on WPF, WCF, LINQ and O-R Mapping

An exploration of some of the freshest, tastiest and most powerful features in .NET 3.5 through implementing a useful application.
You’ll take away an understanding of what’s in .NET 3.5 and how to build online and offline applications with the new technology stack supported by Visual Studio 2008 (Orcas Beta 2).

Location
Norman Selfe Room,
Level 3,
280 Pitt St Sydney (Sydney Mechanics School of Arts)

Time
6:15pm, 3rd October 2007

For more info or to register, please visit the ACS site.

Hope you can come

Reflexil, cute code injection for C#

James — Thu, 27 Sep 2007 07:20:42 +0000

While catching up on my favourite blogs, I came across Reflexil on Fabrice’s blog. Reflexil is able to do C# code injection into existing assemblies and save the resulting assembly. I haven’t given it a go yet, but it looks like a really neat tool. The legal implications may mean it is only useful for emergency patching or debugging however…

BarCamp Sydney this Saturday

James — Wed, 22 Aug 2007 12:09:05 +0000

It is BarCamp in Sydney this Saturday. I haven’t been to one of these unconference style events before, but I’ve heard good things about it from my colleagues. I’m quite excited to go along and see what it is like.

If you’re in Sydney and interested in stopping by, details are as follows:

When: Sat 25th August 2007 from about 9am
Where: University of Technology, Sydney (Jones St entrance)
More details…

One of the novel aspects of BarCamp is that all participants are encouraged to present or start a discussion around something that interests them. For my part, depending on what people are interested in, I was thinking of one of the following:

new stuff in the .net space (C# 3.0, .NET 3.5, LINQ, WPF, WCF, etc) and showing some demos
giving a bit of a Ruby/JRuby introduction with help from Ola’s JavaBin slides
or, if people are keen, a discussion around JRuby vs C# 3 vs Java vs ?? and their stacks for different situations and problems

By the way, the conference is free, and it is not too late to sign up
Hope to see you there!

Slides from ‘Learning to live with the static-typing fascist and the dynamic-typing fan-boy in your enterprise…’

James — Wed, 15 Aug 2007 02:03:13 +0000

Here’s the slides from Jim’s and my recent presentation at Tech Ed 07 on the Gold Coast and in Auckland:

LearningToLiveWithTheStaticTypingFascistAndTheDynamicTypingFanboy-TechEd07.pptx (Powerpoint 2007)

LearningToLiveWithTheStaticTypingFascistAndTheDynamicTypingFanboy-TechEd07.ppt (Powerpoint 2003)

You may also be interested in having a read of the abstract.

TechEd 07 - Some interesting snippets

James — Mon, 13 Aug 2007 22:06:11 +0000

Silverlight

Silverlight runs on MAC and PC.
There is now a CLR for the Mac.
Microsoft is not currently planning to provide Silverlight for any unix platform (although there is MoonLight).
Silverlight 1.0 is basically a media player. It has hooks for javascript etc and some might say it has similar functionality to the Flash movie player.
Silverlight 1.1 has the real programming API. All further Silverlight references are to 1.1.
Silverlight will do a (currently undefined) simplified subset of WPF.
Silverlight gives acess to DOM in the browser.
Currently, the alpha allows 1mb local storage per page. In future, the storage is probably going to be shared across a domain rather than on a page by page basis.
Silverlight provides the capability to open a file on disk for read to allow for file uploads etc.
Interop between JavaScript and hosted Silverlight app is quite easy.
Silverlight looks a bit fiddly to set up, requiring javascript and sometimes xaml bootstrap - but being improved.

Software Factories

Allow solution and project structures to be auto-generated based on wizards.
Can provide code snippets and some (often template-based) code auto-generation.
Comes with documentation in help files and some context specific stuff.
Can include GUI designers that generate code.
People can develop their own domain specific factories.

DSLs
Currently, Microsoft’s take on DSLs is GUI editors, not written language or code. At the Software Factories talk, a GUI tool in Visual Studio for drawing your business entities and relationships was billed as a DSL.

Windows Workflow Foundation (WF)

Activity based with GUI designer for connecting and composing activities.
Custom activities and compositions can be developed and inherit from base classes.
Single threaded and mainly queue based, with some events sprinkled through.
Activities can reference data from other activities using a mechanism vaguely like data binding.
Hosted in the CLR, so can be part of a console app, ASP.NET, WinForms etc.
Handles pickling and reconstitution of long running activities.
Base Activity classes provide virtual hooks. Eg, ‘Execute’ for doing the work, ‘Cancel’, and ‘Compensate’ for handling rollback scenarios.

New in the Enterprise Library 3.1

Validation Application Block: provides simple, attribute based property validation. Easy integration with standard ErrorProvider on WinForms and WebForms and WPF is possible. Looks ok but somewhat basic - don’t think it supports warnings for example. It has GUI tool support and also capability to specify related objects which need to be validated.
Policy Injection Application Block: provides aspect oriented programming (AOP) style coding using attributes. All new AOP objects need to be created using the block’s object factory. Looks useful - there is out of the box support for validation, caching and logging in AOP fashion.

Tech Ed Talks

James — Thu, 02 Aug 2007 06:37:18 +0000

Jim Webber and I will be co-presenting at Tech Ed Australia and Tech Ed New Zealand this year. Here’s the low down:

Learning to live with the static-typing fascist and the dynamic-typing fan-boy in your enterprise…

Gold Coast
Thursday 9 Aug
5pm - 6:15pm

Auckland
Tuesday 14 Aug
2:20pm - 3:35pm

“What’s best for your enterprise? Is it the ‘glue that never sets’ and flexibility of dynamic languages like Ruby, or the tried and true, hard and fast rules and tool support of static languages like C# 3.0? Are there different trade-offs for green field development and integration?

And more importantly, which is best, the Mac or PC?

In a dynamic, and combative presentation, Jim and James will let their alter-egos run amok and answer these questions from the perspective of a seasoned enterprise architect and a l33t hax0r. By the end of this session you will understand the interplays between the two personality types, have had a few laughs, and picked up a few tips on how to use both technology
sets in harmony in your enterprise. “

Hope to see you there!

The Castle Project - Rails for .NET

James — Tue, 12 Jun 2007 13:26:00 +0000

The Castle Project is an interesting open source alternative to ASP.NET / ADO.NET. Among other things, the Castle Project provides a Rails-like development framework for .NET. It has an ActiveRecord implementation built on top of NHibernate, a very Rails-like MVC setup called MonoRail, and uses NVelocity for template style views. It’s worth checking out. This screencast gives a bit of an overview.

There’s tough competition around the corner though, with Orcas already in beta, providing XAML, LINQ and O-R mapping.

Is .NET or Java dying?

James — Tue, 05 Jun 2007 09:52:00 +0000

Are C# and .NET losing ground as Martin Fowler suggests? Or is Java’s market share dropping? What about Ruby? And what about the Australian market in particular?

Here’s what I’ve been able to find.

Job Trends
Which technologies have the most demand for people?

From Indeed.com, which claims to search “millions of jobs from thousands of job sites”, but I suspect may have a USA focus:

“Best Talent Index May 2007″ from Best People Solutions gives an Australian perspective:

Here’s job counts from the (largest?) primarily Australian job search site Seek on 5 June 2007, 3pm (today):

Keyword(s)	Number of positions found
Java	3,414
“.NET” or “dot net”	2,744
“c#” or “c sharp”	1,722
ruby	100

As an aside, I remember doing a search on Seek for “ruby” about 6 months ago, and getting under 20 jobs mentioning it.

Search Engine Number of Hits

Extract from the TIOBE Programming Community Index for June 2007:

Position Jun 2007	Position Jun 2006	Programming Language	Ratings Jun 2007	Delta Jun 2006	Status
1	1	Java	20.025%	-1.10%	A
2	2	C	15.967%	-2.29%	A
3	3	C++	11.118%	+0.45%	A
4	4	(Visual) Basic	9.332%	-0.85%	A
5	5	PHP	8.871%	-0.72%	A
6	6	Perl	6.177%	+0.17%	A
7	8	C#	3.483%	+0.25%	A
8	7	Python	3.161%	-0.30%	A
9	10	JavaScript	2.616%	+1.16%	A
10	19	Ruby	2.132%	+1.65%	A

I think this gives a good idea of web buzz, but suggest that most non-IT companies do not publish information about their projects and chosen technologies and languages on the web.

Conclusion
The data collected suggests that:

Both .NET and Java are major players in the job market with thousands of positions advertised, implying wide industry adoption of both.
Neither .NET nor Java seem to be undergoing any significant decline in jobs.
Java has much more information about it on the internet, although .NET is slowing gaining ground and Java slowly losing it.
Ruby is comparatively tiny but growing rapidly in terms of jobs and information on the internet.

Thanks
Thanks to Jason Yip and Suzi Edwards for their help finding/sourcing information.

Using floating point variables to represent money => not a good idea!

James — Sun, 25 Feb 2007 10:59:00 +0000

I was reading through some code the other day and was surprised to find that it was using doubles to represent dollar amounts. Reason for the alarm bells is that doubles and floats cannot accurately represent many decimal fractions (eg, 0.1), since doubles and floats internally work with powers of 2 rather than powers of 10. These inaccuracies are likely to lead to significant errors, especially when performing arithmetic (eg, adding up a table of dollar amounts). See this IBM article for a more in depth explanation and examples. The solution is to use types that work with powers of ten internally. In C#, you can use ‘decimal’ and in Java or Ruby, ‘BigDecimal‘, to avoid these problems.

AntiPattern: BusinessObjects in the driving seat

James — Fri, 12 Jan 2007 00:51:00 +0000

When you have a rich domain model with a business object centric design, and a Windows forms GUI, it can be very tempting to start putting significant process logic in the business objects. After continuing along this path a little further, you may realise that the process needs some sort of user input, and you use events or some sort of notifier pattern to gain user input required by the process, while still maintaining layering in terms of referencing. Then additionally you may need to access some sort of external service.

Here is an example:

class Order : BusinessObject
{
  public void SendOrder(INotifier notifier)
  {
    if (ReadyForDelivery ||
        notifier.Confirm("Are you sure you want to send order lines? They are not ready for delivery."))
    {
      OrderLine[] orders = GetLinesToSend();
      foreach(OrderLine line in Lines)
      {
        SendLine(line); // send line using a web service?
      }

      Notify("Lines sent successfully.");
    }
  }
}

interface INotifier
{
  void Notify(string msg);
  bool Confirm(string msg);
  OrderLine[] GetLinesToSend();
}

I would like to suggest that this is an anti-pattern and a trap. Although there is no direct reference from the Business Layer to the GUI layer (INotifier is implemented in GUI and passed down), the Business Layer now requires the ability to stay instantiated, pause while waiting for responses from the notifier, and then continue execution. This will work for rich client applications, but not in a stateless web environment. The ideal of being able to swap in/out the GUI layers on top of the Business layer is now compromised.

Instead, it would be possible to drive form the GUI layer, and call a service to send the Order Lines. In pseudo code below:

void SendMenu_Click(...)
{
  if (Order.ReadyForDelivery ||
      MessageBox.Show(...) == DialogResult.Yes)
  {
    using (ChooseLineForm chooseLineForm = new ChooseLineForm(Order))
    {
      chooseLineForm.ShowDialog()
    }
    SendingSevice.SendLines(chooseLineForm.selectedLines);
    ...
  }
}

If the logic in the GUI layer became much more complex, it may be a good idea to pull it out into its own class (eg, LineSender). This class would be a type of GUI level controller, responsible for orchestrating the send process.

Using this approach, there are a number of benefits:

BusinessObjects have no reliance on GUI implementation, so can be used for Rich Client and Web Client indiscriminately.
Web developers are free to implement the user input process in stateless way more appropriate to their platform.
Functionality for sending Order lines (some sort of integration with a web service?) is pulled out into a service class which can be reused elsewhere (potentially sending other types of objects?) and unclutters the Order business object and removes its dependency on an external service.
Code is simpler and easier to follow.