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 and Windows 10. Learn to write code using .NET class libraries like Entity Framework, ASP.NET MVC, and even the new Windows Runtime (WinRT). You will also dive into many of the important technologies used to build the web including ASP.NET Web API, JavaScript, NoSQL databases, and Cloud Computing.

You will learn:

  • How does C# 5.0 and .NET 4.5 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 earlier versions of .NET?
  • How is ASP.NET MVC different from building WebForms-based web applications?
  • 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 / Windows Phone / Windows Store 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, Modern Web, and NoSQL / MongoDB.

Course highlights

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

  • XAML-based programming
  • Entity Framework - code first
  • NoSQL with MongoDB
  • Thread safety
  • Task parallel programming APIs
  • Async and Await with C# 5
  • DNX
  • HTTP services with ASP.NET Web API
  • Cloud Computing
  • Mobile development with C#
  • ASP.NET Web Security
  • Windows Store Universal Apps (Windows 8 & Windows Phone)
  • MVVM – Model-View-ViewModel
  • Design Patterns for unit testing
  • Challenge Session (student presentations)
  • JavaScript deep dive
  • The elusive topic X

Course outline and topics

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

The topics covered include:

Day 1:

Deep Dive Language Mechanics
In the early days of C# there was virtually a 1-1 mapping between C# and IL. Much has changed since C# 1, the developer is encouraged to simply describe their intent and the compiler builds the appropriate code. This module will dive under the hood and show how various C# features like iterator methods, anonymous methods, extension methods, LINQ and dynamic all result in code gen by the C# compiler. These layers of abstractions initially make us more productive, but sometimes they hide those hard to find bugs, and can add a deluge of performance implications that once we understand how the mechanics of the features work we can quickly fix.

Entity Framework 6 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.

WPF Basics
WPF is Microsoft’s UI technology for building smart client applications. In this module we look at the WPF architecture and how user interfaces are designed using a markup language called XAML. XAML is at the heart of all of Microsoft’s frameworks for building rich user interfaces: WPF, Silverlight and Windows 10 App Store applications.

ASP.NET MVC: Beyond the Basics
This release of .NET sees the inclusion in the core framework of ASP.NET MVC. 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 Razor view engine syntax introduced in ASP.NET MVC 3.0 as well as the new performance features added to MVC.

Day 2:

Unit Testing
Using unit testing comprehensively within software development is a growing movement. Unit 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. We will also introduce Test Driven Development (TDD) to show how writing tests first delivers not just well tested code but also more loosely coupled code.

Entity Framework 6 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.

WPF, DataBinding 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 WPF 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.

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.

Day 3:

Applied NoSQL with MongoDB and C#
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#.

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. 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.

C#5 Async/Await
C# 5 builds on the Task API introducing async and await keywords which bring asynchronous execution as a first class concept in the C# language. These new keywords create a very elegant model for all sorts of async work and this module explains not only how to use them but also how they work under the covers.

Day 4:

JavaScript Deep Dive
JavaScript is a deceptive language. Its name suggests that it?s a scripting version of Java but that is not the case. In this module we will take a look at some of the JavaScript features that are important to understand when working with a framework like AngularJS and Node.js.

Building Asynchronous Web Applications With SignalR
SignalR is a framework for building asynchronous web applications. SignalR consists of two parts, server and client that work together to allow the server to push data to the client. The server code is built around Microsoft's ASP.Net MVC framework while the client will use the best technology available to do it's work, that could be Web Sockets, Long polling, forever frame or some other technique. Anywhere that you need to use asynchronous updates to multiple clients SignalR can help. We will cover how to set up and initialise SignalR and how to use it to call into the browser and get the browser to show updates.

AngularJS Introduction
This module provides an overview of the AngularJS Model View Controller framework. After this module you will have a basic understanding of the different parts of the AngularJS architecture and how to use them.

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:

C# 6
The next evolution of C# is coming this year. This module will take you on a tour of the new features: features that will simplify your code; features that remove constraints that were previously there; and some features that will leave you scratching your head wondering why you would ever need them.

DNX (the artist formally known as ASP.NET vNext)
Server side programming in .NET is about to change radically. Some frameworks are updated – MVC and WebAPI are unified, SignalR is moved to version 3; others are put out to pasture – WCF is not part of the platform. But the most radical changes are in the form of platform and deployment. Server side .Net is going to be cross platform: it will run on Windows, Linux and OS X. The framework is no longer a monolith but split into a myriad of smaller packages – you only need to deploy the parts of the framework that you are using. In fact the entire runtime gets XCopy deployed with your application so new platform version will no longer break your code. This module shows you the new server side platform in action.

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!