Derik Whittaker Episodes

# 205 Consuming a Web Api Endoints

4/12/2012

Level: Beginner

Author: Derik Whittaker

Tags: ASP.NET WCF

Views: (5509) Watched: (4787)

This episode we are we are going to take a another look at the Asp.Net Web Api framework. However, in this episode we are going to look at how we can consume an endpoint in our console application. We will learn how to create the connection as well as how to handle the data which we recieve from our call.

# 204 Self Hosting Web Api

4/5/2012

Level: Beginner

Author: Derik Whittaker

Tags: ASP.NET WCF

Views: (4542) Watched: (3675)

This episode we are we are going to take a look at the Asp.Net Web Api framework. We are going to learn how we can self host a Web API endpoint inside our own application, outside of IIS.

# 203 Introduction to the Async/Await CTP

10/12/2011

Level: Beginner

Author: Derik Whittaker

Tags: Visual Studio Dot Net

Views: (4490) Watched: (3864)

This episode we are we are going take a look at how to simplify asynchronous coding by utilizing the Async CTP.

The async CTP is a library is based off of the Task Parallel Library which introduced the Task<> type use. In this episode we will learn how to use the async and await keywords in the Async CTP

# 202 Silverlight - Learning how to use Value Converters

9/9/2011

Level: Beginner

Author: Derik Whittaker

Tags: Windows Phone 7 Silverlight

Views: (3991) Watched: (3101)

This episode we are we are going to take a look at how to use and harness the power of Value Converters.

A Value Converter (IValueConverter) allows for you to perform custom logic during Bind time in XAML based applications. With a value converter you can implement pretty much any type of complex logic you want (bool to visibility, changing styles, etc) at runtime and have this logic extracted away in a stand alone class.

# 201 Silverlight - Learning how to use Behaviors

8/29/2011

Level: Beginner

Author: Derik Whittaker

Tags: Windows Phone 7 Silverlight

Views: (4743) Watched: (3189)

This episode we are we are going to take a look at how to use and harness the power of Behaviors.

A Behavior in Silverlight is a way to extend an existing UI element in order to add additional state or actions to it. We can create these Behaviors and attach them to pretty much any UI element you could hope for.

# 199 NuGet - Getting Started w/ NuGet

8/17/2011

Level: Beginner

Author: Derik Whittaker

Tags: NuGet

Views: (3860) Watched: (3563)

This episode we are we are going to learn how to use the NuGet Package Management System.

We will start off by looking at how to install NuGet inside of Visual Studio. We will then learn how to use NuGet to install/uninstall packages. We will end the episode by looking at how to create our first NuGet Package.

# 198 WP7 - Creating and Using Associations w/ SQL CE

8/7/2011

Level: Beginner

Author: Derik Whittaker

Tags: Windows Phone 7 SQL CE

Views: (4137) Watched: (3059)

This episode we are we are going to take another look at SQL CE on WP7 Mango.

However, in this episode we will go a step further and learn how to setup relationships (aka associations) between our tables (aka models). We will focus on how to use the [Association] attribute to link our parent-child models together.

# 197 WP7 - Getting Started w/ SQL CE

8/1/2011

Level: Beginner

Author: Derik Whittaker

Tags: Windows Phone 7 SQL CE

Views: (3712) Watched: (3139)

This episode we are we are going to take a look at how to setup and use SQL Ce inside your WP7 Mango Applications.

Prior to Mango being released developers had to resource to storing their data in isolated storage, but now with SQL CE they can use a full RDBM system to store their data. In this episode we will take a look at how to get up and running with SQL CE

# 195 WP7 - Learning how to use Live Tiles

7/18/2011

Level: Beginner

Author: Derik Whittaker

Tags: Windows Phone 7 Silverlight

Views: (3414) Watched: (2788)

This episode we are we are going to take a look at how we can use Live Tiles in WP7 (Mango).

WP7 Mango has introduced not only the ability to create Application Tiles via code but they have also added the ability to create Secondary Tiles, tiles which can deep link into your application. These Secondary tiles can also be created, updated and deleted in code and can provide a very powerful feature for your application.

# 194 MVVM - How to create a ViewModelLocater

7/11/2011

Level: Beginner

Author: Derik Whittaker

Tags: Silverlight MVVM

Views: (3504) Watched: (3391)

This episode we are we are going to take a look at how we can create a simple ViewModelLocator to inject our ViewModel into our DataContext at runtime via conventions.

The ViewModelLocator Pattern will allow you to create a very flexable application because it will decouple your Views from your ViewModel. The approach in this episode will take a convention based approach to determine which ViewModel should go with a given View.

# 193 WCF: How to create Custom Message Interceptors

5/16/2011

Level: Intermediate

Author: Derik Whittaker

Tags: WCF Web Services

Views: (3556) Watched: (3586)

In this episode we are going to take a look at how to extend WCF to create custom Message Interceptors

We will first take a look at how we can create our custom interceptors and hook them into the WCF pipeline. We will then take a look at how we can intercept both inbound and outbound messages to allow us to perform some sort of actions agains the messages.

# 192 WP7: Using Location Services & Bing Maps

5/9/2011

Level: Intermediate

Author: Derik Whittaker

Tags: Windows Phone 7 Silverlight

Views: (3753) Watched: (2988)

In this episode we are going to take a look at how to use the Location Services (GPS) built into the Windows Phone 7 platform.

We will first take a look at how we can use the location servcies library on the phone to get the phones current GPS information. We will then take a look at how we can use that information in conjuction w/ the Bing Services to get the street address for the GPS coordinates

# 191 WP7: Learning to read/write to isolated storage

4/4/2011

Level: Intermediate

Author: Derik Whittaker

Tags: Windows Phone 7 Silverlight

Views: (3831) Watched: (2983)

In this episode we are going to take a look at how to read and write data to Isolated Storage for Silverlight on the Windows Phone 7 platform.

Since the WP7 platform does not have a built in RDMS system you must utilized Isolated Storage in order to persist data between runs. We will look at how to both read and write data using 2 different techniques in this episode.

# 189 Entity Framework: Making changes to the T4 Templates

2/23/2011

Level: Intermediate

Author: Derik Whittaker

Tags: ORM Entity Framework

Views: (3360) Watched: (3442)

In this episode we are going to take a look at how Entity Framework uses T4 Templates (Text Template Transformation Toolkit) when building out the entity model.

We will first learn how EF is using the templates, we will then learn how to view and access these templates and finally we will take a look at how to modify these templates to meet your own specific needs.

# 188 WP7: Learning how to detect Themes

2/16/2011

Level: Intermediate

Author: Derik Whittaker

Tags: Windows Phone 7

Views: (2979) Watched: (3084)

In this episode we are going to take a look at how the phone uses themes and styles.

We will focus on how to determine which theme is being used as well as learning how to swap out our resource files which are used by our application based on the active theme. Knowing which theme is in use will allow your application to better conform to either the light or dark user experience.

# 187 WP7: Writing and Reading from Isolated Storage

2/1/2011

Level: Intermediate

Author: Derik Whittaker

Tags: Windows Phone 7

Views: (2962) Watched: (2920)

In this episode we are going to take a look at store data in Isolated Storage on the phone

Storing data in Isolated Storage on the phone is critical because there is no sql database which can run on the phone at this point. In this episode we will look at how we can store and retrieve data to storage on the phone.

# 186 Entity Framework: Intro to Database First Design

1/18/2011

Level: Intermediate

Author: Derik Whittaker

Tags: ORM Entity Framework

Views: (3448) Watched: (4078)

In this episode we are going to take a look at how to use the Entity Framework via its database first design concepts.

When building out an application which is based off of the Entity framework you have multiple options, you can either build your model off of your existing database or build your database of your existing model. This episode will explore how you start with your existing database and build your entity model.

# 185 WP7: Learning how to handle Tombstoning

1/11/2011

Level: Intermediate

Author: Derik Whittaker

Tags: Windows Phone 7

Views: (2409) Watched: (3826)

In this episode we are going to take a look at how to handle tombstoning (when your application is not longer in focus, but is not shut down yet) in your WP7 application.

When building out a WP7 application it is critical that your application can handle Tombstoning and rebuild itself as needed. This is to allow the user to have their work flow interrupted by an action, but still gives them the ability to back into your app and resume from there last usage point. In fact if you fail to take Tombstoning into account your application will fail certification.

# 184 Entity Framework: Intro to Model First Design

1/3/2011

Level: Intermediate

Author: Derik Whittaker

Tags: ORM Entity Framework

Views: (3937) Watched: (3804)

In this episode we are going to take a look at how to use the Entity Framework via its model first design concepts.

When building out an application which is based off of the Entity framwork you have multiple options, you can either build your model off of your existing database or build your database of your existing model. This episode will explore how you start with your entity model and build out your database.

# 183 Load Testing WCF Services w/ VS2010

12/21/2010

Level: Intermediate

Author: Derik Whittaker

Tags: WCF Unit Testing

Views: (3291) Watched: (4551)

In this episode we are going to take a look at how you can use Visual Studio 2010 to perform load testing on your WCF services

When building out any WCF services it is very important to understand how they will handle under load and stress. You will want know that your services will respond well under peak load in order to allow your users to have a solid experiance. With VS2010 Ultimate there are tools built in which will give you this ability.

# 182 Using Property/Method Exports in MEF

12/15/2010

Level: Intermediate

Author: Derik Whittaker

Tags: MEF

Views: (3090) Watched: (3208)

In this episode we are going to take a look at how you can use MEF (Managed Extensibility Framework) to export either properties or methods on an object.

Having the ability to export only certian properties or methods via MEF provides you another great way to extend your application. You can now have different exports for each use case and you do not need to export the entire class, only parts of that class.

# 181 Using Metadata in your MEF Exports

12/6/2010

Level: Intermediate

Author: Derik Whittaker

Tags: MEF

Views: (2854) Watched: (3079)

In this episode we are going to take a look at how you can use MEF (Managed Extensibility Framework) to expose metadata attributes in your exports.

Having the ability to expose metadata will give you the ability to make decisions around your exports with this metadata.

# 180 Handling System Errors in MVC

10/21/2010

Level: Intermediate

Author: Derik Whittaker

Tags: MVC ASP.NET

Views: (3473) Watched: (5148)

In this episode we are going to take a look at how to perform error handling in Asp.Net MVC.

We will focus on how you can build your MVC application to be able to handle 404 (file not found) and 500 errors (internal server error).

# 179 Parallel Programming w/ Task Parallel Library

7/15/2010

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (4719) Watched: (4319)

In this episode we are going to take a look at how we can simplify parallel programming by using the Task Parallel Library which is part of .Net 4.0

We will take a look at how to move your code away from for and foreach and towards Parallel.For and Parallel.Foreach. These new methods allow you to parallelize your loops w/ little effort, but with large gains.

# 178 Going Out Of Browser w/ Silverlight

7/5/2010

Level: Intermediate

Author: Derik Whittaker

Tags: Silverlight

Views: (3609) Watched: (3717)

In this episode we are going to take a look at how we can use the take our in-browser silverlight application and allow it to run Out of Browser (OOB).

We will take a look at how we can let silverlight perform the lifting as well as how we can provide coding to create the OOB application.

# 177 Data Validation w/ MVC2

6/15/2010

Level: Intermediate

Author: Derik Whittaker

Tags: MVC

Views: (3663) Watched: (4070)

In this episode we are going to take a look at how we can use the built-in features in MVC v2 to simplify data validation.

We will take a look at how we can use data annoations to validate both client side data submission (via javascript) and server side validation.

# 176 Going Lazy<T> with System.Lazy

5/25/2010

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (4525) Watched: (4819)

In this episode we are going to take a look at the how to use the System.Lazy namespace.

One of the pretty cool new nuggets inside the .Net 4.0 framework is System.Lazy and System.Lazy. What System.Lazy brings to the table is a way to create objects which may need to perform intensive operations and defer the execution of the operation until it is 100% absolutely needed.

# 175 Code Contracts: Learning to use Interface Contracts

5/19/2010

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net Code Contracts

Views: (3269) Watched: (4943)

n this episode we are going to take a look at how to utilize some additional features in the Code Contracts library to validate the state of our application.

We are going to focus this episode on the feature of adding contracts to interfaces via buddy classes. This is a powerful feature as it allows us to inherit our contracts from interfaces.
Check out other Episdoes on Contracts here

# 174 Understanding Navigation on Windows Phone 7

5/13/2010

Level: Beginner

Author: Derik Whittaker

Tags: Windows Phone 7 Silverlight

Views: (4143) Watched: (4807)

In this episode we are going to continue taking a look at the Windows Phone 7 Api.

In this episode we are going to focus on learning about the various ways you can navigate from page to page within your application. Because WP7 is based off of Silverlight 3.x you are able to utilize all the native silverlight navigation techniques such as static routing (hard wiring the .xaml path), using routes and using the NavigationService.

# 173 Creating and using the Application Bar w/ Windows Phone 7

5/6/2010

Level: Beginner

Author: Derik Whittaker

Tags: Windows Phone 7 Silverlight

Views: (3502) Watched: (3886)

In this episode we are going to take a look at how to create the Application Bar for Windows Phone 7
When creating an application with Win Phone 7 you may need to create an application bar which contains menus or icons. In this episode we will show you how to create both global app bars as well as local app bars.

# 172 Code Contracts: Validating state with Assert, Assume, ForAll, Exists

4/29/2010

Level: Beginner

Author: Derik Whittaker

Tags: Dot Net Refactoring

Views: (3906) Watched: (5980)

In this episode we are going to take a look at how to utilize some additional features in the Code Contracts library to validate the state of our application.

We are going to focus our efforts here to learn how to use Assert and Assume to validate a given value in our code. We will also learn how to use ForAll and Exists, which can be used to validate content inside of an array or a collection.

# 168 Exploring how to use Layer Diagrams in VS2010

3/30/2010

Level: Beginner

Author: Derik Whittaker

Tags: Visual Studio

Views: (4278) Watched: (4224)

In this episode we are going to explore how to use the new Layer Diagram feature which is part of Visual Studio 2010.

The layer diagram feature of VS2010 is a new feature which allows you to create a map of your code (from the assembly level down to the method level) and then use that mapping later to validate your system still conforms to your architecture.

# 167 Setting Up Basic Mappings w/ Fluent NHibernate

3/17/2010

Level: Intermediate

Author: Derik Whittaker

Tags: NHibernate

Views: (4006) Watched: (4607)

In this episode we are going to continue taking a look at Fluent Nhibernate.

we are going to focus this episode on setting up basic mappings for NHibernate. We will focus on setting up Many-to-One (References) and One-To-Many (HasMany) references as these are the most common mappings you will need to setup.

# 166 Setting Up Fluent NHibernate for your project

3/11/2010

Level: Intermediate

Author: Derik Whittaker

Tags: NHibernate

Views: (4600) Watched: (4326)

In this episode we are going to take a look at how to use setup and configure Fluent NHibernate for usage. We will focus on how to setup your database settings as well as how to get your Fluent NHibernate mappings registered into the system.

# 165 Introduction to Nhibernate.Burrow

3/2/2010

Level: Intermediate

Author: Derik Whittaker

Tags: NHibernate

Views: (4080) Watched: (4761)

In this episode we are going to take a look at how to implement the NHibernate.Burrow session management library.

NHibernate.Burrow is a light weight middleware developed to support .Net applications using NHibernate by providing advanced and smart session/transaction management and other facilitates.

# 164 Learning how to use Manual Mocks for Testing

2/23/2010

Level: Intermediate

Author: Derik Whittaker

Tags: Refactoring

Views: (3806) Watched: (4113)

In this episode we are going to take a look at how to use manual mocks for testing

Often times when creating unit tests we need to work in isolation in order to cover the paths we are attempting to test. When we want to test in isolation you can use a testing technique where you mock out your dependencies. When using Mocks you can either do it manually (what we are looking at) or you can use a mocking framework like Rhino Mocks. Either way you achieve the same results.

# 163 Learning how to use the Extract Interface Technique

2/16/2010

Level: Intermediate

Author: Derik Whittaker

Tags: Refactoring

Views: (3660) Watched: (4330)

In this episode we are going to take a look at another refactoring technique, the Extract Interface technique.

This technique allows you to extract an interface from a class in order to break your concrete dependencies. By doing this you can provide yourself with better testing support as well as a better layer of abstractions.

# 161 A deeper look into AutoMapper: Custom Type Resolvers

2/2/2010

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net AutoMapper

Views: (4733) Watched: (4486)

In this episode we are going to continue looking at the AutoMapper framework.

AutoMapper is a framework which uses a convention-based matching algorithm to match up source to destination values. In this episode we are going to learn how to use type resolvers. Type resolvers allow you to perform custom value mapping in a very simple and elegant way with very little code

# 160 A deeper look into AutoMapper: Projection and Flattening Objects

1/26/2010

Level: Beginner

Author: Derik Whittaker

Tags: Dot Net AutoMapper

Views: (3865) Watched: (4520)

In this episode we are going to continue looking at the AutoMapper framework.

AutoMapper is a framework which uses a convention-based matching algorithm to match up source to destination values. In this episode we are going to take a deeper look at how you can flatten your model during transformation or perform projection during transformation.

# 158 Exploring Operator Overloading in C#

1/12/2010

Level: Intermediate

Author: Derik Whittaker

Tags: .Net 3.0 Dot Net

Views: (4152) Watched: (4373)

In this episode we are going to take a look at how create overloaded operators for your objects.

perator overloading permits user-defined operator implementations to be specified for operations where one or both of the operands are of a user-defined class or struct type. When creating your own operators there are many different operators which can be overloaded.

+, -, *, /, %, &, |, <<, >> All C# binary operators can be overloaded
+, -, !, ~, ++, –, true, false All C# unary operators can be overloaded
==, !=, <, >, <= , >= All relational operators can be overloaded, but only as pairs.

# 155 Exploring .Net 4 Features - Tuples

12/17/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (3953) Watched: (4339)

In this episode we are going to continue taking a look at some of the new features which are part of .Net 4.

We will be focusing this episode on Tuples. Tuples allow you to return multiple values from a method with simplicity and ease by allowing you to dynamically create a return object which is typed for your specific needs.

# 154 How to host a WCF Service inside your Windows Service

12/8/2009

Level: Intermediate

Author: Derik Whittaker

Tags: WCF

Views: (3767) Watched: (3828)

In this episode we are going to take a look how to host your WCF service inside your Windows Service. In many situations hosting WCF inside of IIS may not be the best solution for you or your team. When this is the case hosting inside a windows service may be the best solution and in this episode we will take a look at how you can accomplish this.

# 153 Exploring .Net 4 Features - Named and Optional Parameters

11/24/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (4360) Watched: (3697)

In this episode we are going to start taking a look at some of the new features which are part of .Net 4.

We will be focusing this episode on Named and Optional Parameters. Optional Parameters all you to default values for your methods which can reduce the need to for overloading methods. Named parameters allow you to specify the exact parameter by Name when calling a method

# 152 Introduction to MEF, Getting rolling with basic usage

11/17/2009

Level: Beginner

Author: Derik Whittaker

Tags: Dot Net MEF

Views: (3706) Watched: (4963)

In this episode we are going to take a quick look at the new plugin framework from Microsoft the Managed Extensibility Framework (MEF for short).

In this episode we will explore how to setup your first MEF based plugin system and show how easy it can be.

# 151 Introduction to NCover, setting up for analysis

11/10/2009

Level: Beginner

Author: Derik Whittaker

Tags: Continous Integration Dot Net Code Analysis

Views: (3875) Watched: (4742)

In this episode we are going to take a quick look at how to setup and use the NCover code coverage and analysis tool.

Having the knowledge of the state of your code, is key to understanding the potential success and failures in your code. If having this knowledge is key to you, NCover is a great tool to help you better gain this knowledge

# 150 Adding IoC Support to your WCF Services

10/3/2009

Level: Advanced

Author: Derik Whittaker

Tags: IoC WCF StructureMap

Views: (6849) Watched: (8199)

In this episode we are going to take a quick look at how to setup your WCF services to use an IoC Container.

When building out a set of services in WCF you still would like to follow the SOLID principles and in order to do this you may want to setup the ability to inject dependencies (via Structure Map) into your services at run time. With WCF extension points this is not only possible, but pretty easy

# 149 Introduction to NDepend, adding NDepend to your Nant Script

10/27/2009

Level: Beginner

Author: Derik Whittaker

Tags: NDepend NAnt

Views: (4643) Watched: (4330)

This episode we are we are going to take a look at the NDepend static analysis tool.

When taking a look at NDepend we are going first to do a simple fly-by of how to setup and run NDepend. Once we have our simple project up and running we are going to turn our focus at takig a look at how to run NDepend from our NAnt scripts. Running NDepend as part of our builds will allow us to have a clear picture of the state of our code with each build.

# 148 Validating your XML Documents w/ XSD Schema

10/20/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (4486) Watched: (3699)

This episode we are going to take a look at how to perform XML message validation by using an XSD document schema. By creating an XSD schema you can simply and easily validate the structure and the data content of your document which will ensure your message is well formed.

# 147 Abstracting away Dependencies for Simpler code

10/13/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net Design Patterns

Views: (4696) Watched: (6631)

This episode is a direct request from an emailer that wanted to know how to abstract away WCF services to allow for better abstraction and simplier unit tests. In this episode we will take a look at the pain points around having direct knowledge of a web service can bring for not only testing, but in running your application. Once we understand the pain points we will take a look at how to abstract them away with the adapter pattern.

# 145 Getting started with Lucene.Net Search Library

10/1/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net Lucene

Views: (4550) Watched: (4781)

In this episode we are going to start to take a look at the Lucene.Net Search Engine Library. Lucene.Net is a source code, class-per-class, API-per-API and algorithmatic port of the Java Lucene search engine to the C# and .NET platform utilizing Microsoft .NET Framework. In this episode we will learn the basics needed to simply get Lucene.net up and running.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 144 Learning the Iterator Pattern

9/29/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Design Patterns

Views: (3493) Watched: (5010)

In this episode we are going to take a look at how to use the Iterator Design Pattern.

We will look at how using the Iterator Pattern can help you abstract the way in which you interact with a collection of data. This is helpful when you are working with various formats but you would like to create a constant way to work with each format.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 142 Isolation Frameworks: Learning to use Partial Mocks

9/22/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Unit Testing Mocking Rhino Mocks

Views: (4459) Watched: (4834)

In this episode we are going to continue our series on learning how to use an isolation framework (Rhino Mocks) to help create simpler and more reliable unit tests.

This time around we are going to be focusing how to use Partial Mocks to test abstract classes and methods within a concrete class.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 141 Learning Nant: Creating Token Driving Configuration Files

9/17/2009

Level: Intermediate

Author: Derik Whittaker

Tags: NAnt

Views: (4781) Watched: (3736)

In this episode we are going to continue our series on how to create a build script using the Nant build tool.

In this episode we going to take a look at how we can create dynamic config files by putting tokens in your files and letting Nant replace those tokens for each user based on their unique settings.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 140 Using Reflection to Invoke members

9/15/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net Reflection

Views: (5054) Watched: (3688)

In this episode we are going to take a look at how to use the reflection to invoke members on an object

Reflection can allow you to call methods, properties, etc of any scope on an object. This can be a very, very useful tool for the tool-belt for the times this is needed.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 138 Isolation Frameworks: Mocking Out/Ref Arguments

9/3/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Rhino Mocks Mocking

Views: (4109) Watched: (4075)

In this episode we are going to continue our series on learning how to use an isolation framework (Rhino Mocks) to help create simpler and more reliable unit tests.

We are going to focusing this episode on how to setup you mocks when you need to mock a class with either Out or Ref arguements.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 137 Exploring Reflection: Using Reflection to find Markers

9/1/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (3364) Watched: (3215)

In this episode we are going to take a look at how to find varous markers (interfaces and attributes) on a class by using reflection. This technique can help you to build out dynamic loading/find type of logic in your pluggable applications.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 135 Exploring StructureMap: Learning how to setup profiles

8/13/2009

Level: Intermediate

Author: Derik Whittaker

Tags: IoC StructureMap

Views: (4438) Watched: (4137)

In this episode we are going to continue our series were we are exploring some of the features of StructureMap 2.5.

In this episode we are going to take a look at how to setup profiles to allow the container to dynamicly determine which objects to inject.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 134 Refactoring Techniques: Learning the Wrap Method

8/11/2009

Level: Beginner

Author: Derik Whittaker

Tags: Refactoring

Views: (3813) Watched: (4294)

In this episode we are going to take a look at a refactoring technique outlined in detail in Working Effectively with Legacy Code

We will walk though this technique and take a look at how it can help you to create better and more maintainable code.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 133 Learning how to Read & Write to the windows registry

8/6/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (3180) Watched: (3214)

In this episode we are going to take a look at reading and writing to the registry.

The registry is a bane to use and work with, but lets face it many, many applications we will work on will utilize it. Because of this fact we are going to review how to read and write data to it in a simple and easy fashion.

# 132 Exploring StructureMap: Learning how to setup registries

8/4/2009

Level: Intermediate

Author: Derik Whittaker

Tags: IoC StructureMap

Views: (4377) Watched: (3850)

In this episode we are going to continue our series were we are exploring some of the features of StructureMap 2.5.

In this episode we are going to take a look at how to setup and use the Registry feature of StructureMap. This is a feature that will allow the IoC container to scan for and find a method in a single class which will setup your mappings for the associated assembly.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 130 Isolation Frameworks: Learning how to validate complex expectations

7/28/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Mocking Rhino Mocks

Views: (4598) Watched: (3654)

In this episode we are going to continue our series on learning how to use an isolation framework (Rhino Mocks) to help create simpler and more reliable unit tests. We will focus our learning this time around on the various ways you can setup and validate complex expectations on your stubs/fakes. Validating these expectations will allow your to confirm in tests your dependencies are being used in the manor expected.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 129 How to read from Performance Counters

7/23/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (4206) Watched: (3122)

In this episode we are going to take a look at how to read data from custom performance counters.

Part of the core .net framework allows you to not only create (see episode 114) counters, but also allows you to read from them as well. We will show how you can easily create hooks to take advantage of these counters and read in the data.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 128 Exploring StructureMap: Learning how to setup Auto Registration

7/21/2009

Level: Intermediate

Author: Derik Whittaker

Tags: IoC StructureMap

Views: (4311) Watched: (4018)

In this episode we are going to kickoff a new series were we will be exploring some of the features of StructureMap 2.5.

We are going to start off by looking at the simple use case and how to setup for Auto Registration. Auto Registration is where StructureMap can map your types for you, assuming you follow the standard convention where Foo implementes IFoo.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 127 Isolation Frameworks: Learning how to validate expectations

7/16/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Mocking Rhino Mocks

Views: (4490) Watched: (4009)

In this episode we are going to continue our series on learning how to use an isolation framework (Rhino Mocks) to help create simpler and more reliable unit tests. We will focus our learning this time around on the various ways you can setup and validate expectations on your stubs/fakes. Validating these expectations will allow your to confirm in tests your dependencies are being used in the manor expected.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 126 Building a NAnt script - Part 5: Adding MSTest results to your build scripts

7/14/2009

Level: Intermediate

Author: Derik Whittaker

Tags: NAnt

Views: (4499) Watched: (4065)

In this episode we will continue our series on how to create a build script using the NAnt build tool. In this episode we will take a look at how to add in the ability to run the MSTest testing engine via our scripts to run our MSTest unit tests.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 125 Isolation Frameworks: Learning how to Stub & Fake Data

7/9/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Mocking Rhino Mocks

Views: (3664) Watched: (5055)

In this episode we are going to start learning how to use an isolation framework (Rhino Mocks) to help create simpler and more reliable unit tests.

In this episode we will start off our learning experience by learning the basics. We will be taking a look at how to setup stubs/fakes in order to hard wire return values for our objects/methods.

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 124 Learning the Mediator Pattern

7/7/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Design Patterns

Views: (3848) Watched: (5260)

In this episode we will take at how we can use the Mediator Pattern in our application.

.The Mediator pattern allows us to create a loosely coupled system by creating a set of objects which encapsulates the way that sets of objects interact with each other. By removing this behavior from the individual objects you reduce their responsibility and reduce coupling

--- Sponsor Information ---
ANTS Memory Profiler 5 out now. It’s a must have in your toolbox if you program in C# or VB.NET.
Download your free trial of ANTS Memory Profiler here.

# 123 Exploring Code Contracts: Taking a look at Object Invariant Conditions

7/2/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net Code Contracts

Views: (5625) Watched: (3838)

In this episode we are going to take 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.

# 122 Creating Custom Functions w/ NAnt

6/30/2009

Level: Intermediate

Author: Derik Whittaker

Tags: NAnt

Views: (4565) Watched: (3263)

In this episode we will take 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

# 120 Learning the Decorator Pattern

6/23/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Design Patterns

Views: (3990) Watched: (5878)

In this episode we will take 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

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

6/16/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net Code Contracts

Views: (4145) Watched: (4127)

In this episode we are going to take 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 setup pre and post condition validation.

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

6/9/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Continous Integration

Views: (12806) Watched: (3986)

In this episode we will continue taking a look at how to setup the Hudson build server for usage in a .net environment.

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.

# 114 How to Create a Custom Performance Counter

6/2/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (4599) Watched: (5455)

In this episode we are going to take a look at how to create custom performance counters.

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.

# 112 Learning the Observer Pattern w/ Callbacks

5/21/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Design Patterns

Views: (4181) Watched: (4498)

In this episode we will take at how we can use the Observer Pattern in our application.

This is a follow up episode to Episode 108 where we take another look at this pattern and how we can implement it using either call backs or 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.

# 110 Learning the State Pattern

5/14/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Design Patterns

Views: (3595) Watched: (4423)

In this episode we will take a look at how we can use the State Pattern in our application.

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 easliy setup your application to be state away and be able to make decisions based on the given state

# 109 Learning Hudson: Setting up a simple build

5/12/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Continous Integration

Views: (4950) Watched: (4591)

In this episode we will take a look at how to setup the Hudson build server for our application. We will start off by showing how simple it is to install Hudson and then walk through various configuration points in the server. Finally we will end up by creating a simple build which pulls from SVN and runs our Nant script

# 108 Learning the Observer Pattern

5/7/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Design Patterns

Views: (3721) Watched: (4513)

In this episode we will take at how we can use the Observer Pattern in our application.

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.

# 106 Learning the Adapter Pattern

4/30/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Design Patterns

Views: (4477) Watched: (5238)

In this episode we take a how you can use the Adapter Design Pattern in your applications.

The adapter pattern comes in 2 types, the Class Adapter and the Object Adapter. In this episode we will demo the class adapter but explain the general concepts behind both class and object adapters

# 105 Getting your Func<T> along with your Action<T> on

4/28/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (4757) Watched: (3868)

In this episode we will take a look at the Func and Action types

We will take a look at how these two types to allow you to simplify your code and replace the need to create delegates when you need to use function pointers.

# 103 Learning how to harness the power of NUnit RowTest

4/21/2009

Level: Intermediate

Author: Derik Whittaker

Tags: NUnit

Views: (3667) Watched: (5021)

In this episode we will take a look at how you can utilize the power of RowTests within NUnit. By learning how to use RowTests you can reduce the amount of duplicate test code which exists when doing data driven tests.

# 101 Building a Nant Script -- Part 4: Adding fxCop to your build script

4/14/2009

Level: Intermediate

Author: Derik Whittaker

Tags: NAnt

Views: (4572) Watched: (3406)

In this episode we will continue our series on how to create a build script using the NAnt build tool.

In this episode we will take a look at how to add in the ability to run the fxCop static analysis tool to your build script. Having this ability can allow you to keep very close tabs on your code at any time.

You can get the script for this episode here

# 100 Learning the Template Pattern

4/9/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Design Patterns

Views: (3414) Watched: (4906)

In this episode we take a how you can use the Template Design Pattern in your applications.

The Template Design Pattern is perhaps one of the most widely used and useful design pattern. It is used to set up the outline or skeleton of an algorithm, leaving the details to specific implementations later. This way, subclasses can override parts of the algorithm without changing its overall structure.

# 99 Creating SOLID Code: Refactoring the SOLID episode on DI to use StructureMap

4/7/2009

Level: Intermediate

Author: Derik Whittaker

Tags: SOLID Principle Ninject

Views: (4053) Watched: (7285)

In this episode we are going to take another look at Episode 96 (Dependency Inversion Principle) and add in the usage of StructureMap.

In the original episode Stephan kept the code simple and on point by showing how to do DI by hand. In this episode I am going to show you how to take that up a notch and use an IoC container to make life a little simpler

# 98 Learning about the Strategy Design Pattern

4/2/2009

Level: Beginner

Author: Derik Whittaker

Tags: Design Patterns

Views: (7290) Watched: (6830)

In this episode we take a how you can use the Strategy Design Pattern in your applications.

We will start off by looking at code which does not utilize this pattern and then take a look at how we can refactor the code base to utilize the Strategy Pattern.

# 95 Building a Progressive Fluent Interface

3/24/2009

Level: Intermediate

Author: Derik Whittaker

Tags: DSL

Views: (4677) Watched: (4823)

In this episode we take a look at how to build a progressive fluent interface

A Progressive Fluent Interface is a DSL in which the options can and will change as you progress through the syntax. This is a useful form of a fluent interface if the want to be able to skillfully guide the user down only one path at a time.

# 93 Retrieving data from a REST based service using C#

3/17/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Web Services

Views: (3520) Watched: (3692)

In this episode we take a look at how you can retrieve data frp, a REST based service in C#. We wll walk though the steps needed to build the build the connection and then connect to and retrieve the data from the remote service. In order to do this we will utilize the WebRequest and the WebResponse objects in C# (.net)

# 91 Posting data to a REST service using C#

3/9/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Web Services

Views: (3725) Watched: (3533)

In this episode we take a look at how you can post data to a REST based service in C#.

We wll walk though the steps needed to build the data and then post it to the service. In order to do this we will utilie the WebRequest and the WebResponse objects in C# (.net)

# 89 Learning to use Fluent NHibernate: Mapping with Composite Keys

3/2/2009

Level: Intermediate

Author: Derik Whittaker

Tags: NHibernate FluentNhibernate

Views: (10094) Watched: (5569)

In this episode we will continue our short series on how to use the FluentNHibernate library to create you NHibernate mapping files. We will walk you though how to create your mappings for tables which have Composite Keys. This is NOT meant to teach you how to use the NHibernate OR/M

# 87 Building a Nant Script -- Part 4: Running SQL Scripts w/ SqlCmd

2/24/2009

Level: Intermediate

Author: Derik Whittaker

Tags: ASP.NET MVC

Views: (3883) Watched: (4490)

In this episode we will continue our series on how to create a build script using the NAnt build tool.

In this episode we will be building off our existing script to add the ability to run sql scripts using the SqlCmd tool.

# 86 Introduction to the Routing Engine in the ASP.Net Framework

2/15/2009

Level: Beginner

Author: Derik Whittaker

Tags: ASP.NET MVC

Views: (3424) Watched: (4432)

In this episode we will take a look introductionary look at how to use the Routing engine which is part of the Asp.Net MVC framework.

We will start off by showing how the various parts of the routing commands are used while building routes. We will then take a look at how to create a simple route which can be used by your application.

# 84 Learning how to create a simple Fluent DSL via Method Chaining

2/5/2009

Level: Intermediate

Author: Derik Whittaker

Tags: DSL

Views: (4940) Watched: (4038)

In this episode we take a look at how to create a simple Fluent DSL which is built via Method Chaining.

We will build this DSL from the ground up and talk about the various decisions which were made along the way. This is just a simple example of how you can create a internal DSL for your application with very little effort.

# 83 Learning to use Fluent NHibernate: Getting started w/ your first mappings

2/3/2009

Level: Intermediate

Author: Derik Whittaker

Tags: NHibernate FluentNhibernate

Views: (4155) Watched: (5773)

In this episode we will start a short series on how to use the FluentNHibernate library to create you NHibernate mapping files.

We will walk you though creating very simple mappings and showing you how they work when using FluentNhibernate. This is NOT meant to teach you how to use the NHibernate OR/M

# 82 Building a Nant Script -- Part 3: Adding Code Coverage w/ NCover

2/2/2009

Level: Intermediate

Author: Derik Whittaker

Tags: NAnt

Views: (3538) Watched: (4080)

In this episode we will continue our series on how to create a build script using the NAnt build tool.

In this episode we will build off the script for episode #81 and add in the ability to run code coverage within our script.

You can get the script for this episode here

# 81 Building a Nant Script -- Part 2: Adding NUnit tests

1/29/2009

Level: Beginner

Author: Derik Whittaker

Tags: NUnit NAnt

Views: (5377) Watched: (4216)

In this episode we will continue our series on how to create a build script using the NAnt build tool.

In this episode we will build off the script for episode #78 and add in the ability to run NUnit tests within our script. You can get the script for this episode here

# 80 Replacing the default view engine in MVC w/ Spark

1/26/2009

Level: Beginner

Author: Derik Whittaker

Tags: MVC ASP.NET

Views: (5751) Watched: (11872)

In this episode we will take a look at how you can easily swap out the default view engine within the MVC Framework.

Once we learn how simple it is to swap view engines we will take a intro look at how to use the Spark View engine.

# 79 Learning how to use the XML Serializer

1/22/2009

Level: Beginner

Author: Derik Whittaker

Tags: Dot Net

Views: (3675) Watched: (3757)

In this episode we will take a look at how to utilize the XML Serializer to make your life easier.

We will take a look at how you can simplify your coding efforts when you need to turn an object model into XML or your XML document into an object model.

# 78 Building a Nant Script -- Part 1: Setting up the script

1/20/2009

Level: Beginner

Author: Derik Whittaker

Tags: NAnt

Views: (5857) Watched: (4434)

In this episode we will start a series on how to create a build script using the NAnt build tool.

We will start off this series by walking you though how to setup a simple build script which will simply compile your application. We will use this script as our basis for all future episodes on this topic.

Purchase this book with code decp75 and save 40% for a limited time -- http://www.manning.com/baley/

# 76 How to add ReCaptcha to your MVC Web Site

1/6/2009

Level: Intermediate

Author: Derik Whittaker

Tags: ASP.NET MVC

Views: (4471) Watched: (5163)

In this episode we will show you how to implement ReCaptcha within your MVC Web site. We will walk you though the various steps needed in order to create a simple and easy MVC solution.

# 74 Becoming a ReSharper Samurai - Part 3

12/26/2008

Level: Intermediate

Author: Derik Whittaker

Tags: ReSharper

Views: (3709) Watched: (4848)

This is the third in a multi-part series were we will guide you through various features of ReSharper. In this episode we will focus on various ways to use ReSharper to navigate your code, we take a look at the following features.

  1. Navigate to file/type/member
  2. Go to definition/declaration
  3. Show list of implementers
  4. Find usages within code
  5. Quick Scrolling to methods/properties
  6. Display parameter information
  7. much, much more

# 72 Learning the various ways to use UpdateModel in Asp.Net MVC

12/17/2008

Level: Intermediate

Author: Derik Whittaker

Tags: MVC ASP.NET

Views: (3424) Watched: (9978)

In this episode we will take a look at at some of the various ways you can use the UpdateModel mechanism which is part of the ASP.Net MVC framework to update your data model from a form post.

We will take a look at how to use UpdateModel, TryUpdateModel and how to use an IBindable interface in conjuction with the UpdateModel. At each point we will take about the various different features that are part of this process in order to provide you a solid understanding of the process.

# 70 Creating a new feature via TDD -- Part 2

12/11/2008

Level: Intermediate

Author: Derik Whittaker
Kyle Baley

Tags: TDD New Feature

Views: (3576) Watched: (4534)

In this episode Kyle Baley and I walk though creating a new feature for DimeCasts.net via remote pairing.

This is the 2nd part of our pairing session, in this session we will fill out the application logic to allow our test to pass.

# 68 Becoming a ReSharper Samurai - Part 2

12/4/2008

Level: Intermediate

Author: Derik Whittaker

Tags: ReSharper

Views: (3379) Watched: (4845)

This is the second in a multi-part series were we will guide you through various features of ReSharper. In this episode we will take a look at the following features.

  1. Delete unused directives
  2. Create a constructor (with parameters)
  3. Extract logic into a new method
  4. Create overloaded methods
  5. Much, much more

If you like this episode check out
- Becoming a ReSharper Samurai - Part 1

# 66 Taking a look at the various ways to implement Binding in Asp.Net MVC

11/24/2008

Level: Intermediate

Author: Derik Whittaker

Tags: ASP.NET MVC

Views: (3563) Watched: (4463)

In this episode we will be taking a look at the various ways that you can perform model binding with Asp.Net MVC.

We will start off by looking at how to use binding to translate your form data into an object. We will then take a look at how to use the various veatures of the Bind Attribute to filter the data that is bound.

# 65 Using TDD to create a new Feature for DimeCasts.net

11/19/2008

Level: Intermediate

Author: Derik Whittaker
Kyle Baley

Tags: TDD New Feature

Views: (3979) Watched: (5758)

In this episode Kyle Baley and I walk though creating a new feature for DimeCasts.net via remote pairing.

We are doing this in a TDD fashion and by the end of this episode we have a flushed out our design via a test, but no working feature (yet). We actually flush out the concrete logic in a future tests.

***NOTE***
This Episode is a bit longer than most episodes at ~15 minutes... sorry
***NOTE***

# 64 Learning how to turn an Anonymous object into a Dictionary

11/17/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (3308) Watched: (3515)

In this episode we will take a look at how to use Anonymous objects. We will also learn how we can use Anonymous objects as property bags and turn them into a Dictionary for usage.

# 62 Introduction to the AutoMocking Conatiner in StructureMap

11/6/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Mocking StructureMap

Views: (3766) Watched: (4941)

In this episode you will take a look at how to use the AutoMocking Cotainer that is part of StructureMap 2.5

You will be shown how to setup and use this container to reduce noise in your tests.

# 61 Becoming a ReSharper Samurai - Part 1

11/5/2008

Level: Beginner

Author: Derik Whittaker

Tags: ReSharper

Views: (4911) Watched: (7739)

In this episode you will start your journey on becoming a ReSharper Samurai.

This is the first in a multi-part series were we will guide you through various features of ReSharper. In this episode we will take a look at the following.

- Toggling scope on class and methods
- LiveTemplates
- Generate Constructor
- Extract Interface
- Derive Clas
- Much, Much more

# 58 Leveraging the power of ActionName and AcceptVerbs in Asp.Net MVC

10/25/2008

Level: Intermediate

Author: Derik Whittaker

Tags: MVC ASP.NET

Views: (3835) Watched: (4799)

In this episode you will learn how to leverage the power of a few key controller attributes that are part of the Asp.Net MVC framework.

We will show you how you can use ActionName and AcceptVerbs to simplify your life and make your controllers more robust.

# 56 Creating Live Templates with Resharper

10/16/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Dev Tools

Views: (4014) Watched: (4143)

In this episode you will learn how to harness the Live Template engine within ReSharper.

We will learn how to Creating and Using Live Templates can increase your coding productivity.

# 55 Form Validation Simplified w/ Asp.Net MVC

10/13/2008

Level: Intermediate

Author: Derik Whittaker

Tags: ASP.NET MVC

Views: (4401) Watched: (4697)

In this episode you will learn how to use the ASP.Net MVC framework to simplify your Form Validation needs.

We will show you how to use the ModelState model inside the MVC in order to communicate your errors between the controller and the view.

# 52 Creating and Applying patches with Subversion (SVN)

10/6/2008

Level: Intermediate

Author: Derik Whittaker

Tags: SVN

Views: (3747) Watched: (4698)

In this episode you will learn how to use Subversion to create and apply patches.

We will walk you though two different ways to do this and explain the pros and cons of each way.

# 49 Using Reflection to Populate a ComboBox from an Enumeration

9/29/2008

Level: Beginner

Author: Derik Whittaker

Tags: Reflection Dot Net

Views: (3388) Watched: (4353)

In this episode we will walk you though how to use reflection to populate a ComboBox with the data in an Enumeration.

We will look at how to populate the ComboBox multiple ways and how to use attributes to create friendly names.

# 48 Contextual binding with StructureMap

9/24/2008

Level: Advanced

Author: Derik Whittaker

Tags: IoC StructureMap

Views: (3845) Watched: (5309)

In this episode we will walk you though how to do contextual binding with StructureMap 2.5.

What is Contextual Binding? Contextual Binding is the ability to switch out different concrete implementations of a service (i.e. class) at runtime depending on the context in which they are used.

# 47 Using Linq2Objects to perform list conversions

9/22/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Linq

Views: (3379) Watched: (4280)

In this episode we will walk you though how to do list conversion using Linq.

We will walk though the various ways in which you can perform list conversions.

# 45 Logging to the Database with Log4Net and ADO.Net

9/16/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Dev Tools

Views: (4836) Watched: (4204)

In this episode we take a look at how use Log4Net to log to SQL Server. We will be using the ADO.Net and the ADONetAppender.

This example will use the default database table layout in order to store the data. We will also look at creating an abstracted provider for the Logging classes.

# 43 App.Config & Creating Custom Configuration Sections

9/9/2008

Level: Beginner

Author: Derik Whittaker

Tags: Visual Studio

Views: (4463) Watched: (4132)

In this episode we take a look at how to create custom configuration sections withen our App.config or Web.config files.

Creating a ConfigurationSection in our config files allows us to describe and load configuration data in our own format/layout.

# 42 Adding IoC Support (w/StructureMap) to ASP.Net MVC

9/4/2008

Level: Beginner

Author: Derik Whittaker

Tags: MVC IoC StructureMap

Views: (4208) Watched: (5832)

In this episode we take a look at how to setup an ASP.Net MVC website to use IoC for creating its controllers. We will learn how to replace the default ControllerFactory with our own implementation.

# 39 Getting Started with StructureMap -- Simple Setup Scenarios (v2.5)

8/26/2008

Level: Beginner

Author: Derik Whittaker

Tags: IoC StructureMap

Views: (4204) Watched: (7091)

In this episode we take a look at how to setup and configure StructureMap for dependency injection.

We will review how to configure your dependencies 2 different ways. First we will review how to use StructureMaps configuration Files and then we will review how to use the built in DSL syntax for wiring.

# 37 Exception handling with Action Filters in Asp.Net MVC

8/19/2008

Level: Intermediate

Author: Derik Whittaker

Tags: MVC

Views: (6537) Watched: (3933)

In this episode we take a look at how to handle exceptions with Action Filters in the ASP.Net MVC framework. We will create a custom Action Filter and have it perform our exception handling logic.

# 36 XML Data Manipulation with XLinq

8/14/2008

Level: Intermediate

Author: Derik Whittaker

Tags: XLinq

Views: (3286) Watched: (4003)

In this episode we take a look at how to use the new XLinq (the Linq implementation for XML Documents) to query and manipuate XML Documents.

We will take a look at how to update an XML Document in multiple different ways using a few different techniques

# 35 Taking a look at the AAA syntax in RhinoMocks 3.5

8/12/2008

Level: Beginner

Author: Derik Whittaker

Tags: Unit Testing Mocking Rhino Mocks

Views: (3381) Watched: (5477)

In this episode we take a look at the new AAA (Arrange, Act, Assert) syntax that is part of RhinoMocks 3.5.

By the end of the episode you should have an general understanding of how the new syntax works and how it differs from the Record/Replay model.

# 34 Learning how to resolve conflicts within Subversion (SVN) using TortoiseSVN

8/5/2008

Level: Beginner

Author: Derik Whittaker

Tags: SVN

Views: (14255) Watched: (4944)

In this episode we walk though how to resolve code conflicts using the TortoiseSVN client.

By the end of this episode you should be able to use both the Diff and Merge tools that are built into TortoiseSVN to manage and resolve any code conflicts that may arise.

# 32 Harnessing the Power of Linq2Sqls Delayed Execution

8/4/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Linq2Sql

Views: (3249) Watched: (3724)

In this episode we will how to use Linq2Sqls Delayed Execution process to modify or append query syntax to our statements.

This can be used to remove duplication withen your query logic.

# 31 Advanced Usages of LinqPad

7/31/2008

Level: Advanced

Author: Derik Whittaker

Tags: LinqPad

Views: (4119) Watched: (6198)

In this episode we will walk you though how to use some of the advanced features of LinqPad.

By the end of this episode you will see how you can load external assemblies into LinqPad and use them in your statements.

# 29 Setting up a Project in Subversion (Svn)

7/29/2008

Level: Beginner

Author: Derik Whittaker

Tags: SVN

Views: (3225) Watched: (4554)

In this episode we will walk you though how to setup and add your project to the Subversion (SVN) source control server.

We will be using the VisualSVN Server and TortoiseSvn Client in this episode. By the end of this episode you should be able to setup, maintain and use a SVN server with a project.

# 28 Introduction on how to use Reflector

7/24/2008

Level: Beginner

Author: Derik Whittaker

Tags: Dev Tools

Views: (3230) Watched: (4582)

In this episode we will walk you though how to use the .Net tool Reflector.

Reflector is the class browser, explorer, analyzer and documentation viewer for .NET. Reflector allows to easily view, navigate, search, decompile and analyze .NET assemblies in C#, Visual Basic and IL.

# 26 Adding a New Feature to DimeCasts.Net - Data Listing

7/22/2008

Level: Intermediate

Author: Derik Whittaker

Tags: New Feature

Views: (2721) Watched: (3405)

In this episode is the second a series where we are going to be walking through the coding process of adding a new feature to the Dimecasts.net website. In this episode we will create the needed code needed to list the raw data onto the website.

# 25 Introduction to LinqPad - Intermediate Usage

7/17/2008

Level: Intermediate

Author: Derik Whittaker

Tags: LinqPad

Views: (3651) Watched: (5390)

In this episode we will learn how to use the LinqPad expression evaluator.

LINQPad is more than just a LINQ query tool: it is a code snippet IDE. Instantly execute any C# 3 or VB 9 expression or statement block!

In this episode we will look at how to execute native .Net code.

# 23 Adding a New Feature to DimeCasts.Net - Data Access

7/15/2008

Level: Beginner

Author: Derik Whittaker

Tags: Linq2Sql New Feature

Views: (2576) Watched: (3689)

In this episode we will start a new series where we are going to be walking through the coding process of adding a new feature to the Dimecasts.net website. In this episode we will create the needed data access to allow us to pull the data correctly.

# 22 Introduction to LinqPad

7/10/2008

Level: Intermediate

Author: Derik Whittaker

Tags: LinqPad

Views: (3795) Watched: (6057)

In this episode we will learn how to use the LinqPad expression evaluator.

LINQPad is more than just a LINQ query tool: it is a code snippet IDE. Instantly execute any C# 3 or VB 9 expression or statement block!

# 20 Testing Abstract classes with Rhino Mocks

7/8/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Unit Testing Rhino Mocks Mocking

Views: (3773) Watched: (5138)

In this episode we will walk you though how to test your abstract classes with Rhino Mocks.

You will learn how that by using a mocking framework you can simplify and reduce the friction in testing your abstract classes and methods.

# 19 Generating an RSS Feed with Argotic

7/3/2008

Level: Intermediate

Author: Derik Whittaker

Tags: ASP.NET

Views: (6180) Watched: (4100)

In this episode we will walk you though how to create and implement an RSS feed using the Argotic RSS framework.

We will walk through generating the document, creating the feed access point and finally creating the hooks so the world knows we have a feed.

# 17 Performing Subselects with Linq2Sql

7/1/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Linq2Sql LinqPad

Views: (2997) Watched: (4751)

In this episode we will walk you though the the various ways to perform subselects with Linq2Sql.

We will also take a look at the SQL that is generated. We will be doing all of our coding in this episode in LinqPad

# 15 Using Linq to query the File System

6/26/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Linq

Views: (3353) Watched: (4564)

In this episode we will learn how to query an a file system using Linq.  By using Linq we can reduce the complexity when it comes trying to find files on our file system.

# 14 Exploring Extension Methods in C# 3.0

6/24/2008

Level: Beginner

Author: Derik Whittaker

Tags: .Net 3.0

Views: (5013) Watched: (4144)

In this episode we will be exploring a new feature in C# 3.0/.Net 3.5 called Extension Methods.

Extension Methods are a way to allow a developer to extend an object (add new methods) without having to subclass or recompile that object.

# 13 Querying XML Data using XLinq

6/19/2008

Level: Intermediate

Author: Derik Whittaker

Tags: XLinq

Views: (2747) Watched: (3933)

In this episode we will learn how to query an XML document by using the XLinq libraries.  XLinq is the Linq implementation on top of an XML document.

We will learn how to us the inline query syntax as well as using SQL style syntax.  By the end of the episode you should be able to retrieve data from an XML document via XLinq

# 12 Introduction to Mocking with Rhino Mocks

6/16/2008

Level: Beginner

Author: Derik Whittaker

Tags: Rhino Mocks

Views: (4483) Watched: (6768)

In this episode we will learn how to use the Mocking framework Rhino Mocks.

This is an introductory overview of using Rhino Mocks and is meant for those who are new to either mocking or Rhino Mocks.

# 11 Preserving Routes for SEO using the MVC Routing Engine

6/13/2008

Level: Advanced

Author: Derik Whittaker

Tags: MVC

Views: (3426) Watched: (6734)

In this episode we are going to take a look at how to use the Routing Engine that is part of the Asp.Net MVC framework to allow us to preserve old or dead routes in order to not break external links.

We will walk though create the new route, watching it hit our new controller action then finally testing the new route to ensure they both work.  By the end of the session we will have two valid routes that both render the same view

# 10 How to Link/Share files between projects in Visual Studio

6/11/2008

Level: Beginner

Author: Derik Whittaker

Tags: Visual Studio

Views: (6357) Watched: (5712)

In this episode we will learn how to use Visual Studio to link/share common files between projects.

By linking/sharing common files you can reduce the amount of effort needed to make common changes. This can also reduce the chance of errors due to missing a file or two.

# 9 Creating Templates in Visual Studio

6/9/2008

Level: Beginner

Author: Derik Whittaker

Tags: Visual Studio

Views: (3909) Watched: (4528)

In this episode we will learn how to use Visual Studio to create both file and project templates.

Creating template will allow us to quickly create either files or projects that are setup and laid out in a common way. They can also reduce the amount of friction that is needed to get coding faster.

# 8 Introduction to Mocking with Moq

6/5/2008

Level: Beginner

Author: Derik Whittaker

Tags: Mocking Moq

Views: (7376) Watched: (15933)

In this episode we will learn how to use the Mocking framework Moq. This is an introductory overview of using Moq and is meant for those who are new to either mocking or Moq.

# 7 (re)Creating your DB with Linq's DataContext for testing

6/3/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Linq2Sql

Views: (2618) Watched: (4232)

In this episode we will learn how to use the DataContext object that is part of Linq2Sql to build/rebuild our data base for testing.

We will walk though the creation of the database, the creation of data and learn how to wire this process up to our Tests.

# 6 Joins, Grouping, Aggregating w/ Linq2Sql

5/30/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Linq2Sql LinqPad

Views: (3904) Watched: (5076)

In this episode we take a look at how to create various types of Linq2Sql statements.  All the statements created in this episode are done using the really sweat LinqPad tool.

The types of statements that are reviewed here are:

  1. Inner Joins
  2. Outter Joins
  3. Groupings (with some Aggregations)
  4. Select top N rows

# 5 Introduction to Linq2Sql

5/29/2008

Level: Beginner

Author: Derik Whittaker

Tags: Linq2Sql

Views: (2843) Watched: (4402)

In this episode we do an introductory of Linq2Sql.  This is meant to be a beginners guide.

The items that are covered are:

  1. Learn how to create the data connection via Server Explorer
  2. How to use the Linq2Sql Designer
  3. Review the DataContext object that is generated
  4. Simple Linq2Sql Statements

# 4 Unit testing events with NUnit

5/27/2008

Level: Advanced

Author: Derik Whittaker

Tags: NUnit Unit Testing

Views: (3483) Watched: (5642)

In this episode we will cover how to test events that are raised from an object.  We will cover multiple different ways to do this.

# 3 Creating tests with NUnit

5/27/2008

Level: Beginner

Author: Derik Whittaker

Tags: NUnit Unit Testing

Views: (3039) Watched: (5630)

In this episode we will cover the basics on how to create various unit test using the NUnit testing framework.  We will also review the different Assert helper classes that are part of the testing framework.

# 2 Overview on NUnit's Attributes

5/27/2008

Level: Beginner

Author: Derik Whittaker

Tags: NUnit Unit Testing

Views: (3063) Watched: (5169)

In this episode we will learn how to use some of the different attributes that are built into the NUnit testing framework.

The attributes we will review are:

  • Test
  • TestFixtureSetup
  • TestFixtureTeardown
  • Setup
  • Teardown
  • Ignore
  • Explicit
  • ExpectedException

# 1 Overview on how to use NUnit

5/27/2008

Level: Beginner

Author: Derik Whittaker

Tags: NUnit Unit Testing

Views: (3679) Watched: (8536)

This screencast is an introduction to NUnit as well as a brief overview of testing with NUnit.  In this episode you will learn the following:

  1. Use the NUnit IDE
  2. Create simple tests with NUnit
  3. Debug a test via the VS IDE