Day 1
Entity Framework Introduction
The Entity Framework is an Object Relational Mapping (ORM) layer released in .NET 3.5 SP1. The module looks at the ideas behind ORM and shows how you can remove data access code from your codebase by working with objects that the ORM translates into database queries. Along the way we will look at how LINQ can be used to query and manipulate this data.
Silverlight basics
Silverlight is fast becoming Microsoft's next generation UI technology for business applications. In this module we look at the Silverlight architecture and how user interfaces are designed using a markup language XAML.
Unit Testing
Using unit testing comprehensively within software development is a growing movement. Unity testing allows refactoring and maintenance with the confidence that existing functionality is not broken. In this module we will look at techniques for writing good unit tests and integrating them into testing frameworks to automate the unit tests.
C# 4.0 with a Sneak Peek at 5.0
As with most releases of .NET, the accompanying version of C# has seen important new features. The big headlining feature is the introduction of dynamic typing via the dynamic keyword. This enables a much smoother integration with dynamically typed languages such as JavaScript and Ruby as well as cleaner COM interop. But being able to resolve methods and properties at runtime also introduces new ways of parsing data with natural APIs. This module will look at the new dynamic aspects of C#4 and will also cover other new features of the language such as generic variance, optional and named parameters. We will also take a look at the new async support in the language for C# 5.
Day 2
Entity Framework and the Repository Pattern
Prior to Entity Framework 4.0 EF relied on generating entity classes that were tightly coupled to EF. 4.0 introduces the idea of POCO classes - bringing your own classes to EF. This module shows how POCO support works and how you can use the repository pattern to keep your application code and the data access layer cleanly separated and testable.
ASP.NET MVC 3.0
Since .NET 1.0, ASP.NET has used server sided controls to build "web forms". However, there is now a new approach with leverages the Model/View/Controller design pattern that has worked so well in frameworks such as Ruby on Rails. This new approach is called ASP.NET MVC and creates code that is much easier to unit test than web forms and so lends itself well to Test Driven Development. This module focuses on the latest release of Asp.NET MVC including the new Razor view engine.
Inversion of Control and Mocking
In this module we look at how we can design for testing using dependency injection and how Inversion of Control (IoC) containers can make dependency injection manageable. Once we have dependency injection we can then use mocking frameworks to simplify the job of making unit tests truly test only a single unit.
Silverlight, Data and MVVM
Moving data between the UI and underlying objects can be a laborious task. Databinding is a technology that hugely simplifies this process. But more than that, in Silverlight databinding is a fundamental skill for creating rich user interfaces with minimal code. Databinding is the core technology that enables the use of the Model-View-ViewModel presentation layer pattern which we also introduce in this module.
Day 3
PFx: Task - a Unified Threading API
When the Parallel Framework Extensions (PFx) were first announced it looked as though it was going to target a narrow set of requirements around parallelizing processor intensive code. However, over time the scope of the library has grown significantly such that it will become the main model for building asynchronous code. The pivotal type enabling this transition is the Task class. This is a functionally very rich type allowing the creation of both short and long lived asynchronous work, Tasks can have dependencies on one another and support cancellation. In this, the first of the PFx modules we look specifically how this class gives us a unified framework for building multithreaded code.
Thread Safety
Asynchronous programming requires careful attention to detail since most objects are not designed with multithreaded access in mind. This module introduces the importance of Interlocked and Monitor-based synchronization.
PFx: Synchronization Primitives and Concurrent Data Structures
Ever since its inception .NET has had support for a number of synchronization primitives (such as Interlocked, Monitor and Mutex). However, on their own these primitives do not provide support for more complex synchronization situations and so people have had to use them as building blocks to build things like efficient Semaphores. PFx finally brings to the library a set of richer primitives such as lazy initialization, a lightweight semaphore and a countdown event. But more than this, it also introduces a set of high performance concurrent data structures that allow you to use them without you having to provide your own synchronization logic around them. This module looks at this new set of tools in your synchronization toolbox.
PFx: Parallelizing CPU Intensive Algorithms
The original goal of PFx was to provide support for splitting computationally intensive jobs across multiple processor cores. Even though the scope of the library has expanded, this is still an important part of this infrastructure. In this talk we look at the tools PFx gives you to aid parallelizing algorithms but we also shows that without care PFx isn't necessarily the free lunch it appears.
Day 4
Windows Workflow Foundation 4.0 Architecture
The next version of Windows Workflow Foundation (WF 4.0) is a radical change to the existing version. This allows a much more efficient execution model and greater flexibility. In this module we look at what issues drove the changes and how the new infrastructure works to provide an environment for assembling applications from execution building blocks that have the ability to automatically manage state over long running execution.
Windows Communication Foundation Architecture
The shift from object oriented development to component oriented development made it possible to build more loosely coupled and flexible systems where individual components evolved independently without impacting the overall system. The Windows Communication Foundation continues those practices by providing a model which is based on interfaces and contracts. This talk will introduce you to the WCF model and how to utilize it to build service-oriented and distributed applications.
WF 4.0 Services
One of the goals of WF 4.0 was to create a powerful library for building WCF services that are purely declarative in nature - deployed as XAML files. In this module we'll talk about how to use the new library, how to build services declaratively and how we can use a new correlation infrastructure to build services that manage state over lengthy execution.
Building REST based services with WCF
Service Orientation and SOAP are often seen as going hand-in-hand. However, there is another architectural style for building services - that or REpresentational State Transfer, or REST. REST uses the design principles that have made the web so hugely scalable: resources are identified by URI, operations defined by HTTP verbs, links used to move to the next stage of processing. In this module we look at how WCF can be used to build REST based systems.
Day 5
Inside the Garbage Collector
The garbage collector has been part of .NET since its inception. However, exactly how the GC works is often shrouded in mystery. Also the fact that memory management is automated doesn't release the developer from caring about memory issues - it's just those memory issues appear in a different guise. In this module we take the lid of the GC, look at how it works and is optimized and then assess what this means for you when you are writing your code: things you do that can help the GC and things that cause it problems.
Power Debugging with WinDBG
For many developers debugging tools start and end with Visual Studio. However, there are a large number of problems that Visual Studio provides very little support - particularly threading and memory management issues. WinDBG and the plugin SOS.DLL bring a new set of tools to .NET developers that can provide insights that help you solve bugs that you see during testing but also allow you to diagnose issues occurring in production systems where the only data you can get is a crash dump file.
Introducing the Reactive Framework (Rx)
Reactive Framework is a new library that uses the .NET 4.0 IObservable interface and LINQ to create a compelling new programming model that allows you to build "event" based code with declarative LINQ statements. This module introduces the Reactive Framework and shows how it can greatly simplify your code.
