This first episode is a build-up toward using LINQ within C#. However, before we can get into that, we need to cover some other basic concepts.
Now that you understand implicit typing, enumerables, and extension methods, we can take a look at delegates, and finally look at how to use LINQ.
With a clear understanding of how lambdas work, we are able to finally turn our attention to LINQ. This videos demonstrates how to use LINQ with various examples.
After closing out our discussion of LINQ, Nelson LaQuet now provides a bit more in-depth discussion over delegates, their usefulness, and expanding into the world of events.
This video takes a look at using ReSharper to aid in your programming projects, along with some helpful tips to get started in making the most of ReSharper's capabilities.
in this first video over Design Patters, we cover some basic fundamental topics that will be needed before we really start looking at individual patterns.
With the preliminaries out of the way, we can now take a look at some actual patterns! In this video, we take a look at implementing the MVC pattern!
In this video we delve into the use of the Singleton design pattern, showing how it can be applied to your programs.
This video diverges away from the current ongoing discussion of design patterns, focusing on some special topics including automatic properties, a look at Reflector, anonymous types and more.
A second bonus video, this one adds some specialized discussion that focuses primarily on expressions and how you can save a great deal of code when using them properly.
Zak starts his very first C# application while trying to implement some of the concepts discussed thus far. This video is intended for the beginner-level programmer and/or those who are looking for a little help with some of the concepts covered in Nelson's Corner.
After reaching a stopping point in the last video, Zak now continues developing his simple program. Once again, this video is intended for a more beginner-level audience.
Now that Zak has finished off his simple program, Nelson takes over, rewriting the code in a more optimized and efficient manner, showing how the original could be improved and prepared for future expansion.
This video' focuses on how many of the LINQ operators are working under the hood. See how we can make use of 'yield' statements, as well as create our own LINQ-like methods.
We now look at our next Nelson's Corner project: a trading card game simulator! For inspiration and to help research nuances of such games, we base our first attempt on the existing popular card game, Magic: The Gathering.
Before we can really dig into the code for our card game engine, we need an understanding of how Magic: The Gathering is played. In this video, Nelson and Zak use the Magic Workstation application to run thorugh a sample game using 2 decks.
Before we can start coding, we need to have a solid understanding of the systems we're about to create. This video gives a "big picture" overview of the architecture.
Now that we understand the basics of the system as a whole, we can now look at our first target. This will be the pre-game systems which assemble the card decks.
We now get into the intial stages of coding for the Card Game Engine. In this video we lay out the base classes and interfaces we will need for the pre-game process.
We now continue working on the coding portion of the pre-grame. In this video we focus on setting up how cards and decks will be tranferred into the engine.
In this video we move on toward wrap up of the pre-game portion of the engine, including a quick test of using a simple Boo script to generate a few cards.
This video covers a bit of refactoring as we remove several of the GUIDs that had been in place, instead using a more descriptive set of properties.
In this video we focus on giving a high-level overview of the classes that we will need as we set up the card game engine's deck system.
In this video we implement the AttachProperties class and the AttachProperties.Tests.
In this episode we take a look at a bug that was coded into the project. As a solution, we code a test that can be used to track down the source, then fix the problem.
With this episode, we look at the event publishing system for our card game engine, implementing the ICanHandleEvents, IEventChain, and IEventPublisher interfaces.
Continuing along, we now look at implementing the command dispatcher, which is a simple interface allowing us to abstract the idea of objects in our program giving commands to other objects.