DotNetKicks.com : Stories kicked by dwhittaker

Exploring Code Contracts: Taking a look at Object Invariant Conditions

Thu, 02 Jul 2009 19:45:00 GMT

Taking a look at the new Code Contracts library which is out of MS Research and will be part of .Net 4.0/Vs2010. Contracts allow for many different ways to perform language agnostic code validation and in this episode we are going to focus on how to utilize the Object Invariant checking to maintain an objects state.

What is Unit Testing?

Wed, 01 Jul 2009 16:45:02 GMT

good introductory article explaining what unit tests are (and are not) and why you should use them

Creating Custom Functions w/ NAnt

Tue, 30 Jun 2009 16:00:03 GMT

Taking a look at how to create a custom function for your NAnt script. After you have the basics of NAnt down you may quickly find out that there are features you need, but they are not part of the core library. The good news for you is that in very little effort or coding you can create your own custom assembly which will expose your newly created NAnt functions

Exploring how to use Expressions w/ Spark

Fri, 26 Jun 2009 06:15:00 GMT

Exploring how to use Expressions w/ Spark. We are going to take a look at the various different ways you can use Looping Expressions with the Spark View engine.

Unit Of Work ActionFilter

Tue, 23 Jun 2009 14:21:56 GMT

Setting up StructureMap and The Unit Of Work ActionFilter UnitOfWork ActionFilter In my previous post I had created the repository implementations along with unit of work. But how do we use this unit of work in our application. ASP.NET MVC has a concept of ActionFilters. These could be applied to an action or a controller in general. The two main methods that concern us are OnActionExecuting and the OnActionExecuted. As seen in the code below we call the initialize method of the unit of work which would create a new transaction for us and this is held until the action is complete after which we commit the transaction. We are getting a new instance of _unitOfWork through an IoC container which I will talk about in a bit.

Learning the Decorator Pattern

Tue, 23 Jun 2009 15:15:00 GMT

Taking at how we can use the Decorator Pattern in our application. The decorator pattern is a structural pattern which allows you to attach new or additional actions to an object dynamically. Using the decorator pattern provides a very clean and flexible alternative to subclassing (via inheritance) your object and thus creating an unwanted inheritance tree

Exploring how to use Expressions w/ Spark

Thu, 18 Jun 2009 20:30:00 GMT

Taking a look at the various different ways you can use Expressions with the Spark View engine. We are going to review simply scenarios such as math based expressions and move up to looking at nested if-then-else statements.

Dimecasts.NET plugin for PLEX

Wed, 17 Jun 2009 20:22:52 GMT

A plugin for viewing dimecasts in Plex media center

Exploring Code Contracts: Taking a look at Pre/Post Conditions

Tue, 16 Jun 2009 21:15:00 GMT

Code Contracts Primer - Part 3: Providing Support for Unit Tests

Sat, 13 Jun 2009 15:01:26 GMT

In this post we are going to take a look at how you can setup your unit tests to handle violations from your contracts. If you do not provide any additional support in your code and you violate a contract at test time you will see a dialog like the one below:

Code Contracts Primer - Part 2: Handling Legacy Code

Sat, 13 Jun 2009 15:00:33 GMT

So the one of the first questions that many people ask when talking about using the Code Contracts library is 'what do I do about my legacy code?'. Asking this is a very valid question. If your team has already subscribed to the design-by-contract or fail-fast concepts then maybe you have already added in your own checks. If this is the case the contracts team has thought of you and has already provided a simple answer.

Exploring how to use Global Variables and ViewData (Strongly typed and

Thu, 11 Jun 2009 15:15:03 GMT

Taking a look at how to utilized both global variables and local variables. We will also take a look at how to create and use both strongly typed viewdata and weakly typed view data.

The Most Powerful Development Tool Ever Made

Thu, 11 Jun 2009 16:00:03 GMT

Justin Etheredge wrote a great blog post about not inventing the wheel everytime a classic programming problem shows up.

Learning Hudson: Setting up to run and report Unit Test results

Tue, 09 Jun 2009 15:15:00 GMT

We will be taking a look at how we can use Hudson to report our Unit Tests results after each build. We will be looking at both reporting NUnit and MSTest results and will also show how you can convert MSTest results into NUnit results in order to report all tests in a single screen.

Code Contracts Primer - Part 1: Introduction

Mon, 08 Jun 2009 19:59:27 GMT

If you are not familiar with the Code Contracts library which is coming out of Microsoft R&D labs, you need to check this pretty cool little library out. As of Vs2010/.Net 4.0 this library will be making the jump out of the R&D labs. This is the first in a series where we will walk though various parts of the contracts library.

jQuery Link Repository

Thu, 04 Jun 2009 20:18:00 GMT

This list is fairly short initially however I plan on updating my list here in this post indefinitely as I find more of what I think are some of the best links out there. The intention here again is not to post every conceivable blog post, video, presentation, site..but ones I personally feel are the most useful.

Learning how to add IntelliSense for the Spark View Engine

Thu, 04 Jun 2009 13:45:05 GMT

Learning how to add IntelliSense for the Spark View Engine inside Visual Studio

How to Create a Custom Performance Counter

Tue, 02 Jun 2009 16:00:03 GMT

Taking a look at how to create custom performance counters for usage in your application Part of the core .net framework allows you to create code which can hook into the underlying performance counters which the windows OS has. We will show how you can easily create hooks to take advantage of these counters.

Git For Windows Developers - Git Series - Part 1 - Jason Meridth -

Mon, 01 Jun 2009 12:40:55 GMT

A great tutorial on getting Git up and running on Windows (and a great introduction to Git).

Saying Hello to the Spark View Engine

Wed, 27 May 2009 21:15:00 GMT

Taking a introductory look at the Spark View engine. The Spark is a view engine for Asp.Net Mvc and Castle Project MonoRail frameworks. The idea is to allow the html to dominate the flow and the code to fit seamlessly.

Learning the Observer Pattern w/ Callbacks

Fri, 22 May 2009 18:06:09 GMT

Taking another look at how we can use the Observer Pattern in our application, but this time we will implement the pattern using call backs and events. The Observer pattern allows you to define a one-to-many relationship inside your application where the parent object (the one) has the ability to notify the child objects (the many) of any state change. You can utilize this pattern to make sure that a set of objects are keep in order when there behavior needs to change based on the state of your application.

Introduction to AutoMapper

Wed, 20 May 2009 00:16:11 GMT

take a look at how we can simplify our entity mapping by using AutoMapper. AutoMapper uses a fluent configuration API to define an object-object mapping strategy. AutoMapper uses a convention-based matching algorithm to match up source to destination values. Currently, AutoMapper is geared towards model projection scenarios to flatten complex object models to DTOs and other simple objects, whose design is better suited for serialization, communication, messaging, or simply an anti-corruption layer between the domain and application layer.

Five Reasons for using an ORM Tool

Sat, 16 May 2009 01:46:03 GMT

Gud intro of as what orm tools do...

How Do You Deal With Exceptions?

Fri, 15 May 2009 04:01:09 GMT

A little post on my ideas about handling exceptions within applications. How do you handle them?

Learning the State Pattern

Thu, 14 May 2009 19:06:50 GMT

Taking a look at how you can use the State Pattern in your applications to solve design issues. The State pattern is designed to allow you to create a way to reset or change how an object will act when its state is changed. By utilizing this pattern you can cleanly and easily setup your application to be state away and be able to make decisions based on the given state