Quickduck

Writing clean, usuable CSS

Ben — Thu, 13 Nov 2008 22:47:45 +0000

This article demonstrates 21 techniques you can employ to write usable CSS.

Creating Custom Exception Types

Ben — Mon, 10 Nov 2008 01:20:27 +0000

One of the things that pops up over and over in project development is the issue of when to create Custom Exceptions.

To come to any form of conclusion it’s necessary to understand the reason why you might create your own Exception class.

1. To allow typesafe error detection and act appropriately.
2. To add context specific data.
3. There’s no existing framework exception that signifies the error.

1. To allow typesafe error detection.

Creating a customized exception allows the receiver to act upon a specific error. Using this approach the receiver is forced to detect that specific error to perform any useful action.
Examples where creating a custom exception for this scenario to make sense include;

- situations where you may need to prompt a user to correct a problem (e.g. disk full exception)
or
- where you need to log specific exceptions.

2. To add context specific data.

By adding more context to an exception, the receiver of the exception can use this information to help track down and recover from the error.

An example; say the validation rules for an object instance fail, by attaching the validation rules to the exception the receiver may use them to display appropriate error messages on screen to help recover from the error.

E.g.


public class ValidationException : Exception {

  public ValidationException(ValidationResults results) : base(results.ToString())
  {
Results = results;
  }

  public ValidationResults Results {get;set;}
} 

public class ValidationResults : IEnumerable> {

  public IEnumerator> GetEnumerator() {
    ...
  }

  IEnumerator IEnumerable.GetEnumerator() {
    return GetEnumerator();
  }
}

Usage:

try {
  ...
  ...
} catch (ValidationException ve) {
  foreach (var result in ve.Results) {
    Console.WriteLine("Error:" + result.Key + " : " + result.Value);
  }
}

Alternately, the System.Exception class contains a Data Dictionary property that can be used to attach context without having to create your own customized exception class:
E.g.

var exception = new InvalidOperationException("ValidationException"); 

var validationResults = new Dictionary();
validationResults["Name"] = "The Name value is too long.";
validationResults["Postcode"] = "The Postcode is invalid.";
exception.Data.Add("ValidationResults", validationResults);

throw exception;

The lack of type safety in the Data dictionary may be off-putting but using extension methods you can add some type safety.

public static IDictionary GetValidationResults(this InvalidOperationException ioe)
{
  if (ioe.Data.Contains("ValidationResults"))
  {
    return ioe.Data["ValidationResults"] as Dictionary;
  }
  return new Dictionary();
}

public static string GetValidationMessage(this InvalidOperationException ioe, string key)
{
  if (ioe.Data.Contains("ValidationResults"))
  {
    return ((IDictionary) ioe.Data["ValidationResults"])[key];
  }
  return null;
}

I find that using the Data dictionary approach may save you the benefit of creating a Custom Exception but at the expense of more verbose and un-intuitive code.
3.	There’s no existing framework exception that signifies the error.
The detail level to which you can specify an exception type is infinite. When it comes down to it there are few framework exception types that are valid for most scenarios:
Input value causes exception; throw one of 
System.ArgumentException

System.ArgumentNullException

   System.ArgumentOutOfRangeException
For all other errors a good default option is to use the System.InvalidOperationException.
Conclusion:
To sum up, think carefully about the specific scenario that is being addressed when writing exception logic, follow this checklist to help in your decision making.
Is there a need to act upon the specific exception and find a way to recover from it?
Yes -> Consider creating a generic custom exception.

For example create an exception named DuplicateEntityException rather than JobRateAlreadyExistsException.
No -> throw an existing exception type.
Do you need to log a specific error scenario?
Yes -> Consider creating a generic custom exception.

No -> throw an existing exception type.
Do you need extra information in the exception to respond effectively?
Yes -> Determine whether creating a custom exception with typesafe data members is more intuitive than using the Data dictionary on the System.Exception class.

No -> throw an existing exception type.
For all other scenarios default to throwing an existing exception type.
What are your thoughts and experiences on this issue?



Enterprise Library Walkthrough
Ben — Fri, 07 Nov 2008 06:17:57 +0000
What is Enterprise Library?
Ent.Lib 4.1 - http://msdn.microsoft.com/en-us/library/dd203099.aspx
The Microsoft Enterprise Library is a collection of reusable software components (application blocks) designed to assist software developers with common enterprise development cross-cutting concerns (such as logging, validation, data access, exception handling, and many others).


The application blocks aim to encapsulate proven best-practice for enterprise .net development. 
In total there are over 9 application blocks:

Caching
Cryptography
Data Access

Exception Handling

Logging
Policy Injection
Security 
Unity - Dependency Injection (IoC) container
Validation

This article will address the Exception, Logging, Validation and Unity application block.  The new Unity Application block encapsulates the Policy Injection block and as such will not be addressed in this article along with the Caching, Cryptography and Security blocks.
Download Ent. Library 4.1 here:

http://www.microsoft.com/downloads/details.aspx?FamilyId=1643758B-2986-47F7-B529-3E41584B6CE5&displaylang=en
Important:
This article is just a rehash of information easily found in the Ent.Library documentation and online websites. To get a comprehensive understanding of how the blocks work download the Sample Code I’ve created here.
Alternately, for further demonstrations on how these blocks work, load up the included QuickStart tutorials included with the Ent. Lib download.
Note:

The solution is works with VS 2008 Team System. It utilizes the seperate Unity Application block but works with Ent. Library 3.1 for all other App. Blocks due to 3rd party software we use that has a dependency on Ent. Lib 3.1.
To migrate to Ent. Lib 4.1 just change all references for 3.1 app blocks to 4.1 app blocks.

You will also be able to remove out the the ApplicationCode/CallHandlers/*.cs files and use the 4.1 PolicyInjection CallHandlers.
NOTE: Be sure to read the rest of this article by clicking the link below.
 (more…)



Cohesion and Coupling
Ben — Tue, 04 Nov 2008 22:36:07 +0000
Remember taking Software Design 101 at University and hearing the terms Cohesion and Coupling being thrown about but were too hungover to pay attention?
Well this article by Jeremy Miller is an excellent introduction (or re-introduction) to Cohesion and Coupling - two terms I believe you need a strong comprehension of to design good software.



Reader challenge!
Gerrod — Mon, 03 Nov 2008 17:09:02 +0000
It’s been a while since we’ve had a reader question, so here’s one for you all. It’s not that I can’t solve this problem; it’s more that I’m wondering if there’s a more elegant solution.
The Problem: Given two dates, what’s the easiest way of determining if they fall in the same week?
Please submit your answers as a comment!



Using Flagged Enums
Ben — Sun, 02 Nov 2008 23:28:11 +0000
Have you ever written or come across code where you have a series of boolean values that determine whether or not certain actions are allowed?
Example:

public class WorkDays
{
  public bool Sunday { get; set; }
  public bool Monday { get; set; }
  public bool Tuesday { get; set; }
  public bool Wednesday { get; set; }
  public bool Thursday { get; set; }
  public bool Friday { get; set; }
  public bool Saturday { get; set; }

  public bool Weekdays { get { return Monday && Tuesday && Wednesday && Thursday && Friday; } }
  public bool Weekends { get { return Sunday && Saturday; } }

  public int NumberOfDaysWorked
        {
            get
            {
                int numberOfDaysWorked = 0;

                if (CanWorkMonday) numberOfDaysWorked++;
                if (CanWorkTuesday) numberOfDaysWorked++;
                if (CanWorkWednesday) numberOfDaysWorked++;
                if (CanWorkThursday) numberOfDaysWorked++;
                if (CanWorkFriday) numberOfDaysWorked++;
                if (CanWorkSaturday) numberOfDaysWorked++;
                if (CanWorkSunday) numberOfDaysWorked++;

                return numberOfDaysWorked;
            }
        }
}


There’s a more elegant approach that is utilized through the standard .net framework that we too can mimic.
This scenario is a perfect candidate for using a flagged enum and the power of bit operations. 


    [Flags]
    public enum Days
    {
        None = 0,
        Sunday = 1,
        Monday = 2,
        Tuesday = 4,
        Wednesday = 8,
        Thursday = 16,
        Friday = 32,
        Saturday = 64,
        MondayToFriday = Monday | Tuesday | Wednesday | Thursday | Friday,
        Weekend = Saturday | Sunday,
        All = MondayToFriday | Weekend,
    }

    public class WorkDays
    {
        public Days DaysWorked { get; set; }

        /// 
        /// Get the Number of Days worked.
        /// NOTE: Uses bitwise and operation.
        /// 
        public int NumberOfDaysWorked
        {
            get
            {
                Days days = DaysWorked;
                int numberOfDaysWorked = 0;
                for (; days != 0; numberOfDaysWorked++)
                {
                    days &= days - 1; // clear the least significant bit set
                }
                return numberOfDaysWorked;
            }
        }
    }


By defining an enum with each successive value a power of 2 greater (i.e. binary) you can then use the bitwise or (|) and bitwise (&) operations to group and determine which values are selected.

    [TestClass]
    public class ExampleTestClass
    {
        [TestMethod]
        public void Test()
        {
            var mondayToFriday = new WorkDays { DaysWorked = Days.MondayToFriday };
            Assert.IsFalse(Days.Sunday.In(mondayToFriday.DaysWorked));
            Assert.IsFalse(Days.Saturday.In(mondayToFriday.DaysWorked));
            Assert.IsTrue(Days.Wednesday.In(mondayToFriday.DaysWorked));
            Assert.AreEqual(5, mondayToFriday.NumberOfDaysWorked);

            var monday = new WorkDays { DaysWorked = Days.Monday };
            Assert.IsFalse(Days.Sunday.In(monday.DaysWorked));
            Assert.IsTrue(Days.Monday.In(monday.DaysWorked));
            Assert.AreEqual(1, monday.NumberOfDaysWorked);

            var mondayAndWednesday = new WorkDays { DaysWorked = Days.Monday | Days.Wednesday };
            Assert.IsFalse(Days.Tuesday.In(mondayAndWednesday.DaysWorked));
            Assert.IsTrue(Days.Monday.In(mondayAndWednesday.DaysWorked));
            Assert.IsTrue(Days.Wednesday.In(mondayAndWednesday.DaysWorked));
            Assert.AreEqual(2, mondayToFriday.NumberOfDaysWorked);

            var weekend = new WorkDays { DaysWorked = Days.Weekend};
            Assert.IsTrue(Days.Saturday.In(weekend.DaysWorked));
            Assert.IsTrue(Days.Sunday.In(weekend.DaysWorked));
            Assert.IsFalse(Days.MondayToFriday.In(weekend.DaysWorked));
            Assert.AreEqual(2, weekend.NumberOfDaysWorked);
        }
    }

    public static class Extensions
    {
        /// 
        /// Is the specified enumeration value within the range of Enum values?
        /// 
        /// the enum value to look for in the range
        /// the range of enum values (eg. bitwise OR'd values)
        /// 
        public static bool In(this Enum value, Enum range)
        {
            var valueNumber = (int) Enum.Parse(value.GetType(), value.ToString());
            var rangeNumber = (int) Enum.Parse(range.GetType(), range.ToString());
            return (valueNumber & rangeNumber) == valueNumber;
        }
    }

For further information check out the following resources:
If you’re gotten a bit rusty on your bitwise operations:

http://en.wikipedia.org/wiki/Bitwise_operation
Flagged Enum:

http://weblogs.asp.net/wim/archive/2004/04/07/109095.aspx



Visual Studio 2008 - Shortcut Keys for running Unit Tests
Ben — Thu, 30 Oct 2008 23:41:25 +0000
Short Cut Keys to Run Tests: 
•         Ctl R, T: Run Tests in Current context (namespace, class, and method – ie. Based on where your cursor is within a file it determines the tests to run)

•         Ctl R, C: Run Tests in Current Test Class

•         Ctl R, N: Run Tests in Current Namespace

•         Ctl R, S: Run All Tests in Solution

•         Ctl R, D: Run the Tests in the Last Test Run

•         Ctl R, F: Run the Failed Tests of the Last Test Run



I’m back
Ben — Thu, 30 Oct 2008 07:06:02 +0000
After having 9 months off from doing .net (travelling, bumming and then a 3 month contract role as an architect in a coldfusion shop) I finally got myself a role doing what I love doing best - playing with .net and c#.
In the last 4 weeks I’ve been researching and prototyping apps that use

.net 3.5
ado.net entity framework
ado.net data services - including .net, ajax and silverlight client libraries
Silverlight 2.0
Visual Studio for Software Testers - Web Testing

It’s been awesome to have the time and resources to touch across all of these technologies to enjoy their benefits and to loath the limitations.
All in all I reckon all of the technologies are a great addition to the .net stack and look forward to seeing them mature with each new release.
I look forward to documenting my findings as I find time to re-work them into don’t-give-away-IP examples.



Running VS Unit Tests stops IIS
Ben — Fri, 24 Oct 2008 01:32:05 +0000
We recently ran into this problem where we discovered that running our VS unit tests was killing IIS.
As with all problems, I like to break things down to the simplest scenario I can find and as such created a brand new unit test that did nothing to see if that still caused the problem - it did.
So knowing that it had nothing to do with any code that was web dependent I knew to start looking elsewhere. 
Turns out the problem is caused by enabling code coverage on projects that are dependent on IIS - e.g. a web project.

The simple solution is to disable code coverage on the problem-causing project OR alternately remove the dependency on IIS by modifying it to  use the in-built Cassini web server.



Using Enums for constant values
Ben — Mon, 13 Oct 2008 04:10:40 +0000
Have you ever found yourself using c# const values to remove the risks associated with using copies of string literals throughout your code base?
Example:


public static class VehicleTypesConsts {
  public const string Car = "Car";
  public const string Motorbike = "Motorbike";
  public const string Truck = "Truck";
}


In a situation like this it’s quite easy to replace these const values with a C# enum and use the System.Enum.GetName static method to return Enum properties name.


public enum VehicleTypesEnum {
  Car,
  Motorbike,
  Truck,
}


Calling 

Enum.GetName(typeof(VehicleTypesEnum), VehicleTypesEnum.Car)

will return the string value “Car”.
Looking at this syntax you could be forgiven for thinking why bother? It’s too much hassle and looks puss. 
Well using C# 3.0 extension methods you can provide a convenience method to all Enums to return the enum string representation.


public static class EnumExtensions {
  static public string GetName(this Enum enumeration) {
    return Enum.GetName(enumeration.GetType(), enumeration);
  }
}


Now you can just write:

VehicleTypesEnum.Car.GetName()

and it will return the string “Car”.
The following test method shows illustrates the varying ways to achieve the same result:


        [TestMethod]
        public void Test()
        {
            string expected = "Car";
            Assert.AreEqual(expected, VehicleTypesConsts.Car);
            Assert.AreEqual(expected, Enum.GetName(typeof(VehicleTypesEnum), VehicleTypesEnum.Car));
            Assert.AreEqual(expected, VehicleTypesEnum.Car.GetName());
        }