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

  • ASP.NET MVC 5
  • XAML-based programming
  • Entity Framework - code first
  • NoSQL with MongoDB
  • Thread safety
  • Task parallel programming APIs
  • Async and Await with C# 5
  • OWIN / Katana
  • 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
  • Roslyn / C# 6
  • Node.js / Grunt
  • The elusive 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:

1. ASP.NET MVC 5.0: Beyond the Basics

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

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

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

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

Day 2

5. Thread Safety

Asynchronous programming requires careful attention to detail since unless an object has been specifically designed for concurrent access their state will get corrupted when used concurrently. This module introduces the importance of thread synchronization and looks at the different primitives that .NET provides to do this safely and efficiently.

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

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

8. OWIN / Katana

OWIN is a fairly new specification for modeling a HTTP server API for hosting web applications. The intent is to decouple the host from the application with the goal of providing a simpler programming model with potentially better performance than traditional web servers. While OWIN is a specification, Katana is Microsoft?s implementation of an OWIN host. In this session we will discuss OWIN, Katana and how to write applications and middleware that take advantage of this new and exciting hosting environment.

Day 3

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

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

12. Securing ASP.NET Web API

ASP.NET Web API is the framework for building HTTP-based services and these services will need to be secured. This session introduces how security (confidentiality, integrity and authentication) is typically performed for HTTP-based services. We?ll also look at the modern approaches to authentication and authorization using OAuth and how to implement these approaches in your Web API application using Microsoft?s Katana authentication middleware. Once authentication has been established we'll then turn to authorization and how you can control access to the resources your Web API is exposing.

13. Windows Phone / Windows 8 Universal 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.

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

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

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

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

18. C# 6 and Roslyn

This section will introduce the new features of C# 6 as well as discuss a major update to the .NET compiler system: Roslyn. Roslyn is turns the compiler into an API which your applications can leverage for new functionality.

19. Node.js development with Grunt and Bower

What is Node.js and how do you use it? That will be the focus of this module. We will download Node.js, install it, write our first script, use its REPL (read-eval-print-loop), import some modules, download and use third-party, and explore a bit of the Node.js ecosystem so that we can be familiar enough to get started diving deep into the platform and implementing applications. You will also learn how tools like Grunt and Bowser make working with Node.js a breeze.

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