Design Patterns On-Ramp

In this course, we'll take a look at several everyday programming scenarios that are implementations of Design Patterns.
Course info
Rating
(894)
Level
Beginner
Updated
Sep 26, 2013
Duration
3h 31m
Table of contents
Description
Course info
Rating
(894)
Level
Beginner
Updated
Sep 26, 2013
Duration
3h 31m
Description

You already use Design Patterns but probably don't know it. In this course, we'll take a look at several everyday programming scenarios that are implementations of Design Patterns. Once we start to recognize patterns, we're well on our way to using them effectively. Our goals are to get comfortable with the basic concepts, to see how they are useful, and to discover that design patterns are relevant to all programmers, not just architects and system designers. When we're done, you'll be ready to explore the rich and wonderful world of Design Patterns -- particularly in the Pluralsight Design Patterns Library.

About the author
About the author

Jeremy Clark is an application developer, technical speaker, and Microsoft MVP with over 13 years of experience in all aspects of the development lifecycle. After hours, he puts together demos and technical articles for JeremyBytes.com, a website focusing on .NET technologies.

More from the author
Abstract Art: Getting Things "Just Right"
Intermediate
2h 8m
6 Oct 2014
Practical Reflection in .NET
Intermediate
3h 23m
21 Nov 2013
More courses by Jeremy Clark
Section Introduction Transcripts
Section Introduction Transcripts

Patterns You Already Use: Observer and Proxy
It turns out we already use implementations of design patterns all the time. We'll start by taking a look at two of those patterns, Observer and Proxy. For both of these patterns, we'll look at the Gang of Four description, consider a real world example that shows the concept of the pattern, and then take a look at a common C# implementation that's right in the code we use regularly. Once we've seen the everyday usage, we'll look at a more specialized example and consider the consequences of the pattern. Taken together, these will help us become more comfortable with the design patterns we already use. Once we're able to recognize the patterns, we can start to use them more intentionally based on the problems that we face in our programming environment.

Patterns You Already Use: Iterator
We'll continue our exploration of Patterns That We Already Use by taking a look at the Iterator pattern. As with previous patterns, we'll look at the Gang of Four description and then take a look at a common C# implementation that's right in the code we use every day. We run across the iterator pattern all the time and implementation of the iterator is included in pretty much every collection in. NET. We'll take a closer look at the interfaces that make up this implementation. Then we'll create our own classes that use the iterator pattern.

Patterns You Already Use: Chain of Responsibility and Facade
We'll continue our exploration of patterns that we already use all the time by taking a look at the Chain of Responsibility and Facade Patterns. As with the previous patterns, we'll look at the Gang of Four description, consider a real world example that shows the concept of the pattern, and then take a look at a common C# implementation that's right in the code we use regularly. Once we've seen the everyday usage, we'll look at some more specialized examples and consider the consequences of the patterns. This will help us become more comfortable with the design patterns that we already use. Once we're able to recognize the patterns, we can start to use them more intentionally based on the problems that we face in our programming environment.

Useful Patterns
We've looked at five of the Gang of Four design patterns that we use regularly in our code, probably without even realizing it, and many of these patterns have implementations that are built in to the. NET Framework. Now that we're more comfortable with patterns, we can start to look at some of the less common scenarios. What we'll see is that design patterns can help us with solutions to these problems as well. Specifically, we'll take a look at the Factory method pattern, the decorator pattern, and the adapter pattern, all very useful tools and a great addition to our toolbox.

Where To Go Next
We've seen quite a few of the Gang of Four design patterns in action, and we've dispelled some of the mystery that surrounds design patterns. For our final stop, we'll review some of the topics that we saw at the beginning and take a look at them in light of our newfound understanding. We'll spend some time looking at further places to explore. There are myriads of patterns beyond the Gang of Four, and now that we've got a good handle on the basics of design patterns, we're ready to start taking a deeper dive. We'll start with a review of our initial definition.