TekPub - C# Design Strategies with Jon Skeet

1 - Singletons 35:04
We start the series off with a bang - tackling a design pattern that plagues most developers - no matter the language. The Singleton is reviled by many - mostly because it's nearly impossible to do it correctly. In this episode Jon takes it on and shows you not one, not two - but SIX different ways to do a Singleton. And talks about various pitfalls along the way.

2 - Interfaces 20:52
Using interfaces is accepted by many as something "you should just do". But why? What do interfaces do for you? How are they better then just using basic object construction? In this episode Jon uses Noda Time (his OSS project) and shows you how the use of interfaces has helped him surmount the perils of System.DateTime in .NET.

3 - Dependency Injection 14:49
Using interfaces is a great way to loosen up your code's various dependencies - but how do you go about putting together an application that effectively uses that interfaces? One pattern than many developers like is Dependency Injection, and Jon explains how this patterns works in a real-world project: Noda Time. You get to see how this pattern is used in the wild to make code more flexible and maintainable.

4 - Inversion of Control 15:10
Our code is getting looser and our hard-coded dependencies are making future maintenance less-frightening - but we are now faced with a new problem: getting a new object is becoming a bit of a pain as we need to pass in all the dependencies! This can be a nightmare - and it's a good thing we have Inversion of Control containers to help us out. In this episode Jon refactors his code to make use of a home-spun IoC container, and shows concisely how he's helping his future self maintain his large Noda Time project.

5 - Outtake: Skeet Builds an IoC Container 16:58
During the recording of Episode 4 (Inversion of Control) we asked Jon to "lead people along and show them the need" for using Inversion of Control with Dependency Injection. We expected a rough, hard-coded factory-style of thing, but no, Jon built a small, functional IoC container from scratch. We decided to include it here because it's fascinating to watch and… he's Skeet!

6 - Type Meaning And Single Responsibility 20:57
Designing a Conceptual Model is not easy, and quite often we can engineer ourselves into a very tricky spot with types that do multiple things for multiple reasons. In this episode, Jon takes apart System.DateTime - the poster child for "doing too much" (even the name has two concepts) in an effort to drive home the need for Single Responsibility and Type Clarity.

7 - Open, Closed and Substitution 22:51
Working our way through SOLID principles, Jon tackles the Open/Closed principle and Liskov's Substitution. Along the way we discuss how to facilitate change and extension in an API's inheritance scheme.

8 - Factory Pattern 10:03
In this episode Jon talks about various ways to create an object instance, ans shows you how you can solve the confusion that can occur when you have too many constructor overloads - using the Factory Pattern.

9 - Builder Pattern 12:21
In this episode Jon explores what happens when constructors and factories start getting a bit too complex and you need to formalize options for creating an instance of your exciting business object.

10 - Strategy Pattern 09:00
In this episode Jon shows the simplicity and power of the Strategy Pattern, creating his own comparison strategy for a list of people and their birthdays.

11 - Composition with the Decorator 15:27
Jon likes composition vs. inheritance - and one pattern that really helps with this is the Decorator pattern, which allows you to add behavior (or "decorate") objects at execution time.

12 - State Pattern. Disposal Pattern, and Final Thoughts 11:19
In this episode Jon discusses the State Pattern and when you should use it - which is almost never. We tried to come up with an example that wasn't meaningless and overkill - and failed! Jon wraps things up with a discussion on what pattern use should mean to you - using the State Pattern as a punch line.

General
Complete name : 01 - Singletons.mp4
Format : MPEG-4
Format profile : Base Media
Codec ID : isom
File size : 167 MiB
Duration : 35mn 4s
Overall bit rate mode : Variable
Overall bit rate : 667 Kbps
Encoded date : UTC 2012-04-24 10:00:00
Tagged date : UTC 2012-04-24 10:00:00
Writing application : Lavf53.6.0

Video
ID : 1
Format : AVC
Format/Info : Advanced Video Codec
Format profile : Main@L3.0
Format settings, CABAC : No
Format settings, ReFrames : 5 frames
Codec ID : avc1
Codec ID/Info : Advanced Video Coding
Duration : 35mn 3s
Bit rate : 580 Kbps
Width : 1 280 pixels
Height : 720 pixels
Display aspect ratio : 16:9
Frame rate mode : Constant
Frame rate : 30.000 fps
Color space : YUV
Chroma subsampling : 4:2:0
Bit depth : 8 bits
Scan type : Progressive
Bits/(Pixel*Frame) : 0.021
Stream size : 141 MiB (84%)
Writing library : x264 core 116
Encoding settings : cabac=0 / ref=5 / deblock=1:0:0 / analyse=0x1:0x111 / me=dia / subme=7 / psy=1 / psy_rd=1.00:0.00 / mixed_ref=0 / me_range=16 / chroma_me=1 / trellis=1 / 8x8dct=0 / cqm=0 / deadzone=21,11 / fast_pskip=1 / chroma_qp_offset=-2 / threads=1 / sliced_threads=0 / nr=0 / decimate=1 / interlaced=0 / bluray_compat=0 / constrained_intra=0 / bframes=0 / weightp=2 / keyint=90 / keyint_min=25 / scenecut=40 / intra_refresh=0 / rc_lookahead=40 / rc=abr / mbtree=1 / bitrate=580 / ratetol=1.0 / qcomp=0.60 / qpmin=10 / qpmax=51 / qpstep=4 / vbv_maxrate=1200 / vbv_bufsize=1200 / nal_hrd=none / ip_ratio=1.41 / aq=1:1.00
Language : English
Encoded date : UTC 2012-04-24 10:00:00
Tagged date : UTC 2012-04-24 10:00:00

Audio
ID : 2
Format : AAC
Format/Info : Advanced Audio Codec
Format profile : LC
Codec ID : 40
Duration : 35mn 4s
Bit rate mode : Variable
Bit rate : 99.2 Kbps
Maximum bit rate : 128 Kbps
Channel(s) : 2 channels
Channel positions : Front: L R
Sampling rate : 48.0 KHz
Compression mode : Lossy
Stream size : 24.9 MiB (15%)
Language : English
Encoded date : UTC 2012-04-24 10:00:00
Tagged date : UTC 2012-04-24 10:00:00