Cast Topics
Cast Authors
Dot Net Episodes
# 203 Introduction to the Async/Await CTP
10/12/2011
Level: Beginner
Author:
Derik Whittaker
Tags: Visual Studio Dot Net
Views: (4614) Watched: (3974)
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
# 179 Parallel Programming w/ Task Parallel Library
7/15/2010
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net
Views: (4852) Watched: (4429)
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.
# 176 Going Lazy<T> with System.Lazy
5/25/2010
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net
Views: (4721) Watched: (4930)
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
# 175 Code Contracts: Learning to use Interface Contracts
5/19/2010
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net Code Contracts
Views: (3387) Watched: (5053)
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
# 172 Code Contracts: Validating state with Assert, Assume, ForAll, Exists
4/29/2010
Level: Beginner
Author:
Derik Whittaker
Tags: Dot Net Refactoring
Views: (4031) Watched: (6132)
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.
# 161 A deeper look into AutoMapper: Custom Type Resolvers
2/2/2010
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net AutoMapper
Views: (4862) Watched: (4632)
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: (4016) Watched: (4642)
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
Views: (4287) Watched: (4506)
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: (4084) Watched: (4454)
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.
# 153 Exploring .Net 4 Features - Named and Optional Parameters
11/24/2009
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net
Views: (4520) Watched: (3801)
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
Views: (3821) Watched: (5071)
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: (4024) Watched: (4860)
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
# 148 Validating your XML Documents w/ XSD Schema
10/20/2009
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net
Views: (4641) Watched: (3816)
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: (4829) Watched: (6746)
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
Views: (4469) Watched: (4409)
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
Views: (4686) Watched: (4912)
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.
# 140 Using Reflection to Invoke members
9/15/2009
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net Reflection
Views: (5192) Watched: (3794)
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.
# 137 Exploring Reflection: Using Reflection to find Markers
9/1/2009
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net
Views: (3486) Watched: (3323)
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.
# 133 Learning how to Read & Write to the windows registry
8/6/2009
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net
Views: (3305) Watched: (3324)
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.
# 129 How to read from Performance Counters
7/23/2009
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net
Views: (4328) Watched: (3219)
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.
# 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: (5812) Watched: (3947)
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.
# 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: (4278) Watched: (4243)
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.
# 114 How to Create a Custom Performance Counter
6/2/2009
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net
Views: (4757) Watched: (5555)
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.
# 111 Introduction to AutoMapper
5/19/2009
Level: Beginner
Author:
Eric Polerecky
Tags: Dot Net AutoMapper
Views: (5171) Watched: (6396)
In this episode we will take a look at how we can simplify our entity mapping by using AutoMapper.
AutoMapper uses a fluent configuration API to define an object-object mapping
strategy. AutoMapper uses a convention-based matching algorithm to match up source to destination values. Currently, AutoMapper is geared towards model projection scenarios to flatten complex object models
to DTOs and other simple objects, whose design is better suited for serialization, communication, messaging, or simply an anti-corruption layer between the domain and application layer.
# 105 Getting your Func<T> along with your Action<T> on
4/28/2009
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net
Views: (4914) Watched: (3981)
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.
# 79 Learning how to use the XML Serializer
1/22/2009
Level: Beginner
Author:
Derik Whittaker
Tags: Dot Net
Views: (3810) Watched: (3854)
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.
# 64 Learning how to turn an Anonymous object into a Dictionary
11/17/2008
Level: Intermediate
Author:
Derik Whittaker
Tags: Dot Net
Views: (3419) Watched: (3597)
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.
# 49 Using Reflection to Populate a ComboBox from an Enumeration
9/29/2008
Level: Beginner
Author:
Derik Whittaker
Tags: Reflection Dot Net
Views: (3503) Watched: (4460)
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.