Intermediate Episodes

# 216 Native Swift Networking with Alamofire

11/7/2014

Level: Intermediate

Author: Peter Shearer

Tags: Swift

Views: (10759) Watched: (6012)

In this episode, you'll pull Alamofire as a Git submodule. You'll add Alamofire to an existing Swift project. We'll also take a look at creating a simple Alamofire request and receive a JSON Response. And finally we'll use Alamofire to track upload/download progress

# 215 Using AFNetworking v2 with Swift

10/14/2014

Level: Intermediate

Author: Peter Shearer

Tags: Swift

Views: (11191) Watched: (6157)

In this episode, you'll learn how to bring the AFNetworking CocoaPod into a Swift Project. You'll learn how to manually create an Objective-C Bridging Header. How to call "Swift-ified" AFNetworking API. And we'll end with parsing an AFNetworking JSON Dictionary using Swift

# 214 Swift and Objective-C: Better Together

10/4/2014

Level: Intermediate

Author: Peter Shearer

Tags: Swift

Views: (10352) Watched: (5972)

In this episode, you'll learn how to call Objective-C from Swift through a Bridging Header. You'll learn How to call Swift from Objective-C from the Automatically Generated Header. And you'll learn two ways to declare your Swift objects so that they can be constructed in Objective-C classes

# 193 WCF: How to create Custom Message Interceptors

5/16/2011

Level: Intermediate

Author: Derik Whittaker

Tags: WCF Web Services

Views: (3451) Watched: (3487)

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: (3628) Watched: (2897)

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: (3713) Watched: (2879)

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.

# 190 Rake: Learning to use Rake With MSBuild

3/9/2011

Level: Intermediate

Author: Amir Baylko

Tags: Continous Integration Rake

Views: (3196) Watched: (3692)

In this episode we are going to take a look at how to use Rake in order to help refactor your MSBuild Scripts.

We will use Rake in order to allow you to build out smaller targets in MSBuild as well as to run external features which are supported by Rake.

# 189 Entity Framework: Making changes to the T4 Templates

2/23/2011

Level: Intermediate

Author: Derik Whittaker

Tags: ORM Entity Framework

Views: (3220) Watched: (3337)

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: (2879) Watched: (2975)

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: (2862) Watched: (2817)

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: (3349) Watched: (3982)

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: (2313) Watched: (3729)

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: (3814) Watched: (3711)

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: (3169) Watched: (4451)

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: (2981) Watched: (3114)

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: (2753) Watched: (2968)

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: (3337) Watched: (5020)

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: (4593) Watched: (4227)

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: (3504) Watched: (3613)

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: (3550) Watched: (3976)

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: (4384) Watched: (4721)

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: (3149) Watched: (4831)

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

# 167 Setting Up Basic Mappings w/ Fluent NHibernate

3/17/2010

Level: Intermediate

Author: Derik Whittaker

Tags: NHibernate

Views: (3879) Watched: (4460)

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: (4465) Watched: (4232)

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: (3971) Watched: (4655)

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: (3693) Watched: (3985)

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: (3536) Watched: (4227)

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.

# 162 Learning how to use a Web Cam with Silverlight

2/10/2010

Level: Intermediate

Author: Scott Seely

Tags: Silverlight

Views: (10691) Watched: (3482)

In this episode we are going to take a look at how you can setup and use a web camera in Silverlight. We will walk you though how to capture both the raw video as well as how to take snap shots of the video.

# 161 A deeper look into AutoMapper: Custom Type Resolvers

2/2/2010

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net AutoMapper

Views: (4589) Watched: (4351)

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

# 159 Working with Partials in Spark: Part 2

1/19/2010

Level: Intermediate

Author: Donn Felker

Tags: MVC

Views: (4329) Watched: (3656)

In this episode we are going to continue looking at how to use Partials within the Spark View Engine.

In this episode we will take a deeper look at partials and learn more about their _undocumented_ features. We will also be learning how partials will allow us to create clean, compartmentalized and well orgianized code.

# 158 Exploring Operator Overloading in C#

1/12/2010

Level: Intermediate

Author: Derik Whittaker

Tags: .Net 3.0 Dot Net

Views: (4038) Watched: (4242)

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.

# 157 Working with Partials in Spark: Part 1

1/7/2010

Level: Intermediate

Author: Donn Felker

Tags: MVC

Views: (4374) Watched: (4144)

In this episode we are going to take a look at how to use Partials within the Spark View Engine.

We will be taking a first look at partials and learn how we can setup our application to use partials as well as how to use them in your application. We will also be learning how partials will allow us to create clean, compartmentalized and well orgianized code.

# 156 Learning how to use Named Content Areas w/ Spark

12/29/2009

Level: Intermediate

Author: Donn Felker

Tags: MVC

Views: (4319) Watched: (3597)

In this episode we are going to take a look at the how to setup and use Named Content Areas w/ the Spark view Engine. Named Content areas allow for an easy and simple way to organize the content or structure of you website.

# 155 Exploring .Net 4 Features - Tuples

12/17/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (3830) Watched: (4226)

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: (3649) Watched: (3729)

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: (4200) Watched: (3587)

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

# 148 Validating your XML Documents w/ XSD Schema

10/20/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (4322) Watched: (3587)

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: (4570) Watched: (6512)

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.

# 146 Advanced Query Options with Lucene.Net

10/6/2009

Level: Intermediate

Author: Kyle Baley

Tags: Dot Net Lucene

Views: (4180) Watched: (4158)

In this episode we are going to continue our 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 about more advanced ways to query a Lucene.Net Index. This will include the various ways you can setup your index for searching and how to do boolean searches.

# 145 Getting started with Lucene.Net Search Library

10/1/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net Lucene

Views: (4384) Watched: (4672)

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: (3374) Watched: (4890)

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: (4288) Watched: (4719)

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: (4634) Watched: (3635)

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: (4900) Watched: (3573)

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.

# 139 Learning the Specification Pattern

9/10/2009

Level: Intermediate

Author: Tim Barcz

Tags: Design Patterns

Views: (21521) Watched: (10596)

In this episode we are going to take a look at how to use the specification pattern.

Business logic is the heartbeat of our application. It is what makes your application worth something to the business. In this episode we will explore the Specification Pattern and see how this simple pattern take your complex business logic and turn it into a more manageable and readable piece of art.

--- 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: (3970) Watched: (3970)

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: (3251) Watched: (3130)

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: (4243) Watched: (4038)

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.

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

8/6/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (3071) Watched: (3112)

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: (4246) Watched: (3731)

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: (4454) Watched: (3548)

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: (4054) Watched: (3025)

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: (4182) Watched: (3907)

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: (4344) Watched: (3915)

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: (4355) Watched: (3956)

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: (3547) Watched: (4939)

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: (3683) Watched: (5158)

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: (5415) Watched: (3733)

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: (4419) Watched: (3164)

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

# 121 Exploring how to use Looping Expressions w/ Spark

6/25/2009

Level: Intermediate

Author: Donn Felker

Tags: MVC ASP.NET

Views: (5035) Watched: (3808)

In this episode we will continue taking a look at the Spark View engine.

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

# 120 Learning the Decorator Pattern

6/23/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Design Patterns

Views: (3835) Watched: (5758)

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

# 119 Exploring how to use Expressions w/ Spark

6/18/2009

Level: Intermediate

Author: Donn Felker

Tags: MVC

Views: (4449) Watched: (4029)

In this episode we will continue taking a look at the Spark View engine.

We are going to take 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.

# 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: (4024) Watched: (4021)

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.

# 117 Exploring how to use Global Variables and ViewData (Strongly typed and weak typed) with Spark

6/11/2009

Level: Intermediate

Author: Donn Felker

Tags: MVC

Views: (7149) Watched: (4316)

In this episode we will continue taking a look at the Spark View engine.

In this episode we will focus our attention on 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.

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

6/9/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Continous Integration

Views: (12641) Watched: (3890)

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.

# 115 Learning how to add IntelliSense for the Spark View Engine

6/4/2009

Level: Intermediate

Author: Donn Felker

Tags: MVC

Views: (5022) Watched: (5266)

In this episode we are going to continue our look at how to use the Spark View Engine

We will be focusing on how to add intellisense to the Visual Studio IDE to aid in your development experiance.

# 114 How to Create a Custom Performance Counter

6/2/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Dot Net

Views: (4418) Watched: (5365)

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.

# 113 Saying Hello to the Spark View Engine

5/27/2009

Level: Intermediate

Author: Donn Felker

Tags: MVC

Views: (3913) Watched: (6347)

In this episode we are going to start a series where we take an indepth look at the Spark View Engine.

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.

# 112 Learning the Observer Pattern w/ Callbacks

5/21/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Design Patterns

Views: (4006) Watched: (4375)

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: (3478) Watched: (4320)

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: (4827) Watched: (4486)

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: (3607) Watched: (4394)

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.

# 107 Testing MVC Routes

5/5/2009

Level: Intermediate

Author: Kyle Baley

Tags: TDD MVC

Views: (3854) Watched: (4274)

In this episode we will take a look at how you can test your routes in an MVC application.

We willl start the process of creating new functionality for our application in this episode by showing how to create the tests for the routes first by using MvcContrib project. In the next episode we will continue creating our routes to make the tests pass.

# 106 Learning the Adapter Pattern

4/30/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Design Patterns

Views: (4341) Watched: (5130)

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: (4589) Watched: (3782)

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.

# 104 Navigate your codebase like a pro with ReSharper 4.5

4/23/2009

Level: Intermediate

Author: Ray Houston

Tags: ReSharper

Views: (4761) Watched: (5645)

In this episode we will take at how you can navigate your souce code using ReSharper 4.5

With the latest release of ReSharper there have been a few changes and in this episode we will review then and show you how simple and easy it is to navigate around your soucde with the tool

# 103 Learning how to harness the power of NUnit RowTest

4/21/2009

Level: Intermediate

Author: Derik Whittaker

Tags: NUnit

Views: (3552) Watched: (4896)

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.

# 102 Taking a look at how to modify the T4 templates used by Sharp Architecture

4/16/2009

Level: Intermediate

Author: Kyle Baley

Tags: MVC ASP.NET

Views: (3746) Watched: (3946)

In this episode we will be taking a look at how you can modify the T4 templates which are used to change the default generation behavior of Sharp Architecture

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

4/14/2009

Level: Intermediate

Author: Derik Whittaker

Tags: NAnt

Views: (4443) Watched: (3314)

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: (3274) Watched: (4792)

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: (3908) Watched: (7151)

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

# 97 Another look at Sharp Architecture: Validation, Design Decisions and Automapping

3/31/2009

Level: Intermediate

Author: Kyle Baley

Tags: ASP.NET MVC

Views: (4238) Watched: (4766)

In this episode we will be taking a deeper look at the Sharp Archicture ASP.Net MVC Framework. We will explore the its validation, design decisions, and automapping features. This will set some background for later dimecasts on the framework.

# 96 Creating SOLID Code: Dependency Inversion Principle

3/26/2009

Level: Intermediate

Author: Stephen Bohlen

Tags: SOLID Principle

Views: (6425) Watched: (7630)

This is the last episode in a 5 part series where we will explore the tenets of the S.O.L.I.D principles.

In this episode we will take a look at the D (Dependency Inversion Principle) and see how following this principle can help us to create cleaner, more manageable code

S - Single Responsibility Principle
O - Open/Closed Principle
L - Liskov Substitution Principle
I - Interface Segregation Principle
D - Dependency Inversion Principle

# 95 Building a Progressive Fluent Interface

3/24/2009

Level: Intermediate

Author: Derik Whittaker

Tags: DSL

Views: (4516) Watched: (4689)

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.

# 94 Creating SOLID Code: Interface Segregation Principle

3/18/2009

Level: Intermediate

Author: Stephen Bohlen

Tags: SOLID Principle

Views: (4457) Watched: (6944)

This is the fourth in a 5 part series where we will explore the tenets of the S.O.L.I.D principles.

In this episode we will take a look at the I (Interface Segregation Principle) and see how following this principle can help us to create cleaner, more manageable code

S - Single Responsibility Principle
O - Open/Closed Principle
L - Liskov Substitution Principle
I - Interface Segregation Principle
D - Dependency Inversion Principle

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

3/17/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Web Services

Views: (3428) Watched: (3596)

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)

# 92 Creating SOLID Code: Liskov Substitution Principle

3/11/2009

Level: Intermediate

Author: Stephen Bohlen

Tags: SOLID Principle

Views: (4583) Watched: (10866)

This is the third in a 5 part series where we will explore the tenets of the S.O.L.I.D principles.

In this episode we will take a look at the L (Liskov Substitution Principle) and see how following this principle can help us to create cleaner, more manageable code

S - Single Responsibility Principle
O - Open/Closed Principle
L - Liskov Substitution Principle
I - Interface Segregation Principle
D - Dependency Inversion Principle

# 91 Posting data to a REST service using C#

3/9/2009

Level: Intermediate

Author: Derik Whittaker

Tags: Web Services

Views: (3621) Watched: (3407)

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)

# 90 Creating SOLID Code: Open/Closed Principle (OCP)

3/5/2009

Level: Intermediate

Author: Stephen Bohlen

Tags: SOLID Principle

Views: (4267) Watched: (8367)

This is the second in a 5 part series where we will explore the tenets of the S.O.L.I.D principles.

In this episode we will take a look at the O (Open/Closed Principle) and see how following this principle can help us to create cleaner, more manageable code

S - Single Responsibility Principle
O - Open/Closed Principle
L - Liskov Substitution Principle
I - Interface Segregation Principle
D - Dependency Inversion Principle

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

3/2/2009

Level: Intermediate

Author: Derik Whittaker

Tags: NHibernate FluentNhibernate

Views: (9019) Watched: (5357)

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

# 88 Creating SOLID Code: Single Responsibility Principle (SRP)

2/25/2009

Level: Intermediate

Author: Stephen Bohlen

Tags: SOLID Principle

Views: (6486) Watched: (12402)

This is the first in a 5 part series where we will explore the tenets of the S.O.L.I.D principles.

In this first episode we will take a look at the S (Single Responsibility Principle) and see how following this principle can help us to create cleaner, more manageable code

S - Single Responsibility Principle
O - Open/Closed Principle
L - Liskov Substitution Principle
I - Interface Segregation Principle
D - Dependency Inversion Principle

# 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: (3768) Watched: (4388)

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.

# 85 Taking a look at how to separate out your WCF service project into multiple parts

2/15/2009

Level: Intermediate

Author: Donn Felker

Tags: WCF

Views: (3540) Watched: (3895)

In this episode we will take a look at how you can break your WCF service into multiple projects.

We will walk you though how it is possible to put your WCF contracts into a commong project which can be shared by others, as well as how to put you domain entities into their own project. Having the ability to split out these parts allows for cleaner code and better maintainability.

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

2/5/2009

Level: Intermediate

Author: Derik Whittaker

Tags: DSL

Views: (4707) Watched: (3933)

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: (3962) Watched: (5669)

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: (3394) Watched: (3981)

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

# 77 Learn how to consume a WCF Service

1/15/2009

Level: Intermediate

Author: Donn Felker

Tags: WCF

Views: (3672) Watched: (4181)

In this episode we will walk you though step by step on how to setup your .net application to consume as WCF service.

We will show you how you can Visual Studio to create your service proxy as well as how to use SvcUtil to create the proxy.

# 76 How to add ReCaptcha to your MVC Web Site

1/6/2009

Level: Intermediate

Author: Derik Whittaker

Tags: ASP.NET MVC

Views: (4296) Watched: (5055)

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.

# 75 Introdction to S#arp Architecture

1/6/2009

Level: Intermediate

Author: Kyle Baley

Tags: NHibernate ASP.NET MVC

Views: (5204) Watched: (7425)

In this episode we will give you an introduction to the S#arp Architecture for the ASP.NET MVC Framework.

This is a solid architectural foundation for rapidly building maintainable web applications leveraging the ASP.NET MVC framework with NHibernate. The primary advantage to be sought in using any architectural framework is to decrease the code one has to write while increasing the quality of the end product

# 74 Becoming a ReSharper Samurai - Part 3

12/26/2008

Level: Intermediate

Author: Derik Whittaker

Tags: ReSharper

Views: (3580) Watched: (4745)

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

# 73 Migrating from .asmx web services to WCF web services

12/26/2008

Level: Intermediate

Author: Donn Felker

Tags: WCF

Views: (3384) Watched: (4597)

In this episode we will walk you though the process of converting your company from using .asmx services over to wcf services.

The focus of this episode is how you can setup your environment to support both types of services and use the same back end. This will allow you to slowly convert over any consumers from .asmx to wcf.

# 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: (3270) Watched: (9855)

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.

# 71 Introduction to WCF: Creating your first Service

12/16/2008

Level: Intermediate

Author: Donn Felker

Tags: WCF

Views: (2958) Watched: (5960)

In this episode we will take a look at how to create your first WCF service. We will first walk you though the ABCs of what a WCF service is, we will then show you step by step how you can create a service

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

12/11/2008

Level: Intermediate

Author: Derik Whittaker
Kyle Baley

Tags: TDD New Feature

Views: (3394) Watched: (4424)

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.

# 69 Introduction to NHibernate: Intermediate NHibernate Usage (Part 6)

12/9/2008

Level: Intermediate

Author: Chad Myers

Tags: NHibernate ORM

Views: (4108) Watched: (4057)

In the 7th and final episode of this series, you’ll see some code examples of working with collections of related objects and how lazy loading and cascade operations work from a code perspective.

We’ll also discuss object lifecycle management in NHibernate as well as guidance on how to manage lifecycle and cascade operations on collections of related objects. Finally, we’ll discuss how to perform ad-hoc queries with NHibernate including simple as well as aggregate projection queries using both the Hibernate Query Language (HQL) and the ICriteria API.

Check out Episode #50 for an Introduction to NHibernate
Check out Episode #51 for an Setting up your mappings
Check out Episode #53 for an Configuring NHibernate
Check out Episode #54 for an CRUD and Basic Transparent Cascading
Check out Episode #57 for an More Basic Usages
Check out Episode #63 for an Collection Releationships

# 68 Becoming a ReSharper Samurai - Part 2

12/4/2008

Level: Intermediate

Author: Derik Whittaker

Tags: ReSharper

Views: (3222) Watched: (4738)

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

# 67 Implementing a REST service with WCF (part 1)

12/2/2008

Level: Intermediate

Author: Donn Felker

Tags: WCF

Views: (3418) Watched: (4793)

In this episode we will be taking a look at how to implement a RESTful service using WCF (Windows Communication Foundation). We will start off by taking a look at what a RESTful service is and the move on to actually creating one with WCF

# 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: (3412) Watched: (4374)

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: (3754) Watched: (5591)

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: (3178) Watched: (3435)

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: (3617) Watched: (4842)

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.

# 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: (3685) Watched: (4698)

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.

# 57 Introduction to NHibernate: More Basic Usages (Part 4)

10/23/2008

Level: Intermediate

Author: Chad Myers

Tags: NHibernate ORM

Views: (3913) Watched: (3926)

In this episode we will continued our dive into how to use NHibernate.

We will continue taking a look at various load/fetch strategies that NHibernate offers.

Check out Episode #50 for an Introduction to NHibernate
Check out Episode #51 for an Setting up your mappings
Check out Episode #53 for an Configuring NHibernate
Check out Episode #54 for an CRUD and Basic Transparent Cascading

# 56 Creating Live Templates with Resharper

10/16/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Dev Tools

Views: (3873) Watched: (4034)

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: (4247) Watched: (4586)

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.

# 54 Introduction to NHibernate: CRUD and Basic Transparent Cascading (Part 3)

10/13/2008

Level: Intermediate

Author: Chad Myers

Tags: NHibernate ORM

Views: (3837) Watched: (4802)

In this episode you will learn about you will learn how to perform basic CRUD operations with NHibernate as well as dive into some of its transparent cascading features such as save (insert) and update.

Check out Episode50 for an Introduction to NHibernate
Check out Episode #51 for an Setting up your mappings
Check out Episode #53 for an Configuring NHibernate

# 52 Creating and Applying patches with Subversion (SVN)

10/6/2008

Level: Intermediate

Author: Derik Whittaker

Tags: SVN

Views: (3564) Watched: (4612)

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.

# 47 Using Linq2Objects to perform list conversions

9/22/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Linq

Views: (3236) Watched: (4168)

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.

# 46 Setting up Continuous Integration for your Application with Team City

9/17/2008

Level: Intermediate

Author: Kyle Baley

Tags: Brownfield Team City Continous Integration

Views: (5727) Watched: (10238)

In this episode we will walk you though how setup and manage a Continuous Integration system using Team City for your application.

You will get a guided tour on the various steps needed to get your CI enviornment up and running in no time flat.

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

9/16/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Dev Tools

Views: (4702) Watched: (4096)

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.

# 38 Diving Deeper into Ninject -- Binding Lifetimes

8/21/2008

Level: Intermediate

Author: Justin Etheredge

Tags: IoC Ninject

Views: (4114) Watched: (6539)

In this episode we take a deeper look into the Ninject IoC container.

We will review the various ways to set and determine a Types lifetime inside of Ninject. By the end of this episode you will be able to set your types lifetime to either Transient or Singleton.

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

8/19/2008

Level: Intermediate

Author: Derik Whittaker

Tags: MVC

Views: (6370) Watched: (3845)

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: (3137) Watched: (3902)

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

# 32 Harnessing the Power of Linq2Sqls Delayed Execution

8/4/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Linq2Sql

Views: (3111) Watched: (3627)

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.

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

7/22/2008

Level: Intermediate

Author: Derik Whittaker

Tags: New Feature

Views: (2615) Watched: (3319)

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: (3511) Watched: (5263)

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.

# 22 Introduction to LinqPad

7/10/2008

Level: Intermediate

Author: Derik Whittaker

Tags: LinqPad

Views: (3663) Watched: (5923)

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!

# 21 Creating an Automated Build for your Application

7/9/2008

Level: Intermediate

Author: Kyle Baley

Tags: Brownfield NAnt

Views: (3866) Watched: (5750)

In this episode we will walk you though how create and setup a basic automated build script for your application.

We will be using various tools in this episode such as Tree Surgeon and NAnt.

# 20 Testing Abstract classes with Rhino Mocks

7/8/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Unit Testing Rhino Mocks Mocking

Views: (3633) Watched: (5036)

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: (6011) Watched: (3992)

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.

# 18 Learning the Check-in Dance

7/2/2008

Level: Intermediate

Author: Kyle Baley

Tags: SVN Brownfield

Views: (6151) Watched: (5517)

In this episode we will walk you though the various steps that make up the Check-in Dance.  The steps of the check-in dance are below:

  • Compile your local copy of the code
  • Test your local copy of the code
  • Get the latest version from source control and merge
  • Compile the merged version
  • Check the code into source control

# 17 Performing Subselects with Linq2Sql

7/1/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Linq2Sql LinqPad

Views: (2894) Watched: (4657)

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: (3245) Watched: (4476)

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.

# 13 Querying XML Data using XLinq

6/19/2008

Level: Intermediate

Author: Derik Whittaker

Tags: XLinq

Views: (2654) Watched: (3806)

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

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

6/3/2008

Level: Intermediate

Author: Derik Whittaker

Tags: Linq2Sql

Views: (2511) Watched: (4138)

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: (3783) Watched: (4970)

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