What you will learn in this course

Guerrilla .NET provides a deep exploration of .NET design philosophy and practical advice. You learn a myriad of patterns and best practices, and you get hands-on experience developing applications using Visual Studio 2012 and Windows 8. Learn to write code using new .NET class libraries like Entity Framework 5, MVC 4, and even the new Windows Runtime (WinRT).

You will learn:

  • What has changed in the .NET runtime and how does it affect my applications?
  • How does C# 5.0 meld the parallel programming concepts introduced .NET 4 with the C# language itself?
  • How do I build Windows 8 applications for tablet aspect of Windows 8 and how do I publish my applications to the Windows Marketplace?
  • What can I do with C# 5.0 now that asynchronous programming is built directly into the language?
  • Learn how Entity Framework has shifted towards a code-first programming model to empower developers to build, and test, great data-access layers.
  • How does ASP.NET 4.5 dramatically improve the (perceived) performance of your web applications by optimizing JavaScript and CSS content?
  • What is NoSQL and why are so many developers excited about it? Is it right for my project?
  • Which service-framework should I use? ASP.NET Web API or WCF?
  • What are the main building blocks of a WPF application and how do I use them?
  • What is MVVM and how do I use it?
  • How can I cleanly separate my behavior, UI design and resources using XAML and data binding?
  • What does PFx give me that I couldn't do in .NET 3.5?
  • How is ASP.NET MVC different from building WebForms-based web applications?
  • Debugging: Come and learn to build robust .NET applications including tools and techniques for monitoring and debugging applications in a production environment.
  • Build modern web applications and services using JavaScript, jQuery, AJAX, REST, ASP.NET MVC, and more.
  • Use powerful OO design patterns and techniques to build loosely-coupled, testable, and maintainable applications including Dependency Injection (DI), Inversion of Control (IoC), and unit testing.
  • Learn advanced WPF / Silverlight design patterns and techniques including MVVM (Model-View-ViewModel).
  • Explore the rapidly evolving world of cloud-computing from a .NET developer's perspective. Learn about IaaS, PaaS, and design patterns for scalable cloud-based applications.

The Guerrilla Experience means total immersion in social coding. Multiple instructors keep you engaged throughout the entire learning process collaborating, competing, and coding. In addition to the latest core .NET topics, we'll be covering cutting-edge content that you simply cannot get at other courses including multi-touch programming, WinDBG, and NoSQL / MongoDB.

Course highlights

Guerrilla .NET covers the following topics and more! See the course details for more information.

  • Windows 8 For The Developer
  • LINQ and Entity Framework 5
  • XAML-based Programming
  • ASP.NET MVC 4.0: Beyond the Basics
  • Introduction to jQuery
  • Model-View-ViewModel for WPF and Metro
  • Building RESTful Services with The ASP.NET Web API
  • Programming Win8 Apps: Metro / WinRT
  • Entity Framework 5 and Code First
  • PFx: Task: a Unified Threading API
  • PFx: The Parallel Class and Concurrent Data Structures
  • C# 5.0
  • What's New in .NET 4.5
  • Cloud Computing for the .NET Developer: IaaS, PaaS, and Patterns
  • Applied NoSQL with LINQ, and MongoDB
  • KnockoutJS
  • Open Session
  • Challenges
  • Power Debugging
  • Design Patterns for Testable Applications
  • Topic X

Course outline and topics

This course covers is a deep exploration of .NET 4.0 and beyond and is intended for developers familiar with C# and .NET and with Windows or Web development.

The topics covered include:

Day 1:

Windows 8 For The Developer
One of the great things about Guerrilla .NET is gaining hands-on experience with cutting-edge technology and that includes the operating system. Guerrilla .NET will be using Windows 8 and Visual Studio 2012 for exercises and presentations. This short session introduces you to Windows 8. We cover the types of use-cases that a typical developer needs to be productive while developing web and windows applications.

LINQ and Entity Framework 5
Entity Framework 5.0 is built on top of .NET 4.5 and represents a stable and mature platform for representing relational data in a way that more closely resembles the real world. There is a built-in object-relational mapper, with a Visual Studio designer and support for stored procedures. The latest version incorporates numerous performance improvements with query pre-compilation and caching. You can stream data with a reader and dynamic SQL, perform batch updates, or use LINQ to generate entities that can be updated with changes persisted to the database.

XAML-based Programming
In this module, you will learn about a WPF (Windows Presentation Foundation) and XAML, Microsoft's premier UI technology . We will quickly introduce everything you need to know in order to get started with either technology. Subsequent topics and examples throughout the class will build on this foundational knowledge including Windows 8 Applications (AKA Metro Apps).

ASP.NET MVC 4.0: Beyond the Basics
This release of .NET sees the inclusion in the core framework of ASP.NET MVC 4.0. Platforms such as Ruby on Rails have shown that Model/View/Controller (MVC) is a highly productive and very testable pattern for building web applications. In this module we look at the basic anatomy of an MVC application, looking at models, views and controllers. We also show how data binding fits into this world and how the MVC infrastructure maps requests on to controllers using the Routing infrastructure. Having introduced the core concepts of the MVC framework we look now at integrating AJAX functionality into your MVC applications, how you can build REST based services on the framework and how you build reusable components, similar to custom controls that fit with the MVC model. We will also explore the new Razor view engine syntax introduced in ASP.NET MVC 3.0 as well as the new performance features added to MVC 4.0.

Introduction to jQuery
jQuery is a popular open source JavaScript library used to enhance AJAX style web pages and improve developer productivity. We will introduce the query and document manipulation capabilities of jQuery. It is virtually a requirement for being productive with most web frameworks, including ASP.NET MVC, HTML5, Single-Page Applications etc.

Day 2:

Model-View-ViewModel for WPF and Windows 8 Applications
Many years of experience tell us that interleaving code and presentation leads to unmaintainable, untestable, and designer-unfriendly code. The strongest pattern to emerge in WPF to overcome this is the Model-View-ViewModel pattern, and in this module you will gain a deep understanding of what it is; how to structure your code to support testing, "blendability" and maintainability; how to work with ICommand; and how to support designers effectively.

Building RESTful Services with the ASP.NET Web API
With modern web development REST services have some big benefit over SOAP services. In this module we will take a look at these benefits as well as how to get started building REST services using the ASP.NET Web API framework. We will explore how REST services use standard HTTP constructs like resources URLs, methods and status codes.

Windows 8 Applications and WinRT with C# and XAML
In this module you will get inside the thinking of Windows 8. You will see how Metro relates to WinRT, gain an understanding of the driving principles behind Windows 8 and Metro-style applications and learn the core ideas that make a great Windows 8 application. WinRT underpins all Windows 8 application development. With a history that extends back to the days of COM, it is very important that Windows 8 developers understand how to create and consume WinRT types; what their limitations are; how the use of metadata and language projections work; and how applications and types are registered. This module will give you the core skills in WinRT that are needed by all developers, no matter which language they intend to use.

Entity Framework Code-First
'Code-First' describes an approach to developing applications with Entity Framework where the entity model is inferred by the runtime based on class definitions. No need to create (or maintain) a model using the designer. By default, EF code-first supports a "convention over configuration" approach that enables you to rely on common mapping conventions instead of having to explicitly configure mappings. But if you have an existing database and need to specify mappings, you can either place "data annotations" attributes on entity classes or use a fluent API.

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.

PFx: The Parallel Class and Concurrent Data Structures
The initial goal of PFx was to simplify the parallelization of processor intensive tasks and this remains a key feature. This part of its functionality is focused on the Parallel class and it's For and ForEach members. In this module we look at the simplified model but also highlight that parallelizing algorithms is never as simple as it might first seem. We show you some of the pitfalls that you should be aware of when trying to parallelize functionality using the Parallel class. Additionally, PFx 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 also looks at this new set of tools in your synchronization toolbox.

C# 5.0
Along with the release of .NET 4.5, Microsoft has made major changes to the most important .NET language: C# 5.0*. The previous version of .NET build a solid foundation for building parallel / multi-threaded applications with the PFx Task API. C# 5 (and VB 11) take this to a higher level of abstraction with the introduction of the async and await keywords. At first glance, this appears to be simply syntactic sugar poured over top the Task classes. But as we'll see in this session, this represents a deep change to the way we build concurrent applications and goes far beyond the PFx framework of .NET 4.0.

* Don't let the version inconsistencies throw you - C# 5 comes with .NET 4.5.

The .NET 4.5 Runtime and Visual Studio 2012
The release of .NET 4.5 upgrades the core runtime with significant new changes. At the same time, Visual Studio 2012 is a major release for Microsoft's IDE. This module explores these important changes. We start with the performance improvements in the runtime including new GC and JIT capabilities as well as new NGEN options to improve startup time of your .NET applications. Next we'll that the .NET runtime has been updated to integrate with WinRT (Windows Runtime) which allows you to build Windows 8 applications (AKA Metro applications) in .NET. Finally, we'll cover a whole host of great changes in Visual Studio. This includes features inspired by the Visual Studio Power Tools brought into VS 2012, its new Metro UI, the CSS3 and HTML5 editors, the new JavaScript editor, the improved unit testing capabilities, and more.

Day 4:

Cloud Computing for the .NET Developer: IaaS, PaaS, and Patterns
This module will explore the differences between two major paradigms for developing cloud applications: Infrastructure as a Service (IaaS), and Platform as a Service (PaaS). To demonstrate IaaS we will take a look at setting up an Amazon EC2 instance. PaaS will be demonstrated using the various roles of the Windows Azure platform. We will then take a look at some of the common patterns and anti-patterns for cloud development.

Applied NoSQL with LINQ, and MongoDB
The RDBMS has been a pillar of software development since the 80's. However, a lot has changed in both the type and scale of data our applications work with since 1980. This module explores the rapidly growing NoSQL class of databases that have been gaining mainstream acceptance over the past few years. In order to make our presentations concrete, we'll pick the popular NoSQL data MongoDB. We'll learn how to leverage MongoDB to build .NET applications using LINQ as the data access language. From there we will build out a .NET application using LINQ and MongoDB in a series of interactive demos using Visual Studio and C#.

Knockout.js
Knockout brings data binding and MVVM to the (web) client. It provides the necessary abstraction layer to build the user interface from a data source using a concise syntax. It automatically maps changes from the UI back into the data source and keeps the UI in sync when the data source changes. In addition, Knockout provides a simple and convenient templating library for nested UIs derived from a data source.

Open Session
At this point in the course, your brain will be entirely full of information, but also full of ideas you'd love to try out back on your real projects. We use this 1-2 hour block of time to allow you to experiment with the topics we've seen so far. Rather than waiting until you're back at the office, you can try things out with the instructors and fellow students around to help so you are ready to roll when you get back on Monday. Students who share their ideas at the end of this session also compete for some sweet prizes.

Day 5:

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. We'll also look at advances in Visual Studio 2010 that allow direct, source-level debugging of crash dumps within the IDE.

Design Patterns for Testability (DI, IoC, and unit testing)
This session will present several key object-oriented design principles that facilitate agile software development. These general design principles promote the creation of testable, maintainable, and reusable software. This includes principles such as the Open Closed Principle. The interaction between Agile Development and these principles will be demonstrated using several code samples.

The Elusive Topic X
While the topic list above is broad, fresh, and exciting, there is always a topic or two that the majority of the class would love to cover but we can't know to add it until we meet you on Monday morning. That's Topic X. As a group, we'll discuss the outline and decide if there is a consensus for another topic or two and we'll cover it wherever it makes the most sense throughout the week!