[Tekpub] C# design strategies (design patterns) [2012]

This production is In Process which means we are actively recording new episodes. There are 12/10 Episodes Planned, Currently, BUT there Might be More ... Advanced In this series, Jon Skeet (Stack Overflow of fame) DIVES INTO Various Strategies and Patterns you Might Want to Consider When Building your Application.

Topics covered include Gang of Four core design Patterns such as the Singleton, Strategy, State and others as well as Good habits such as using interfaces, Dependency Injection and Inversion of Control. Rob and Jon Have a Habit of going off on Small Tangents - and we have a habit of recording what Jon goes off on. In addition to the core Episodes, Also we'll be Releasing outtakes - such as Jon writing HIS Own IoC container from Scratch! This is an Advanced series and Understanding of C # and How IT Works is a very Good idea

Content
1 - singletons
We start the series off with a Bang - tackling a design pattern Plagues That 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.

Released on April 26 2012 - 35 minutes

2 - Interfaces
Using interfaces is Accepted by many as something "you just do Should". 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 (OSS Project HIS) Shows you How and the use of interfaces HIM Has helped surmount the Perils of System.DateTime in. NET.

Released on April 26 2012 - 20 minutes

3 ??- Dependency Injection
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.

Released on April 26 2012 - 15 minutes

4 - Inversion of Control
Our code is looser and Getting our hard-Coded dependencies are making less-Future Maintenance 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.

Released on April 26 2012 - 15 minutes

5 - Outtake: Skeet Builds an IoC Container
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!

Released on 28 April 2012 - 16 minutes

6 - Meaning And Type Single Responsibility
Designing a Conceptual Model is not Easy, and quite Often Engineer Ourselves We CAN INTO a very tricky Spot with multiple types do Things That 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 Type and Clarity.

Released on April 30 2012 - 20 minutes

7 - Open, Closed and Substitution
Working our way through SOLID Principles, Jon tackles the Open / Closed Principle Liskov's Substitution and. Along the way We discuss How to facilitate Change and extension in an API's Inheritance scheme.

Released on May April 2012 - 22 minutes

8 - Factory Pattern
In this Episode Jon talks about Various Ways to create an object instance, ANS Shows you How you CAN Solve the Confusion That Occur When you CAN Have too many Overloads constructor - using the Factory Pattern.

Released on May 14 2012 - 12 minutes

9 - Builder Pattern
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.

Released on May 16 2012 - 15 minutes