Cast Topics
Cast Authors
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
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.
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
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
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.
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
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.
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.
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.
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
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.