Building High-Performance Windows 8 Applications

This course covers the different aspects of performance in Windows 8 applications, a definite must for any Windows 8 developer. Learn about the impact of how your XAML is structured, working with large collections & virtualization, async, analytics, and much more.
Course info
Rating
(38)
Level
Intermediate
Updated
Aug 30, 2013
Duration
2h 39m
Table of contents
Introduction
Application Lifecycle Performance
XAML General Performance
XAML Animation Performance
Media Performance
Data Performance
Task Performance
File System Performance
Analyzing Performance
Description
Course info
Rating
(38)
Level
Intermediate
Updated
Aug 30, 2013
Duration
2h 39m
Description

Performance is one of those aspects of application development everyone agrees on is important, but it often isn't so easy to achieve - especially when your app gets larger & more complicated. In this course we cover a huge variety of performance-related aspects, from perception versus reality over PLM, XAML, data, media and file system performance & strategies, using virtualization, using async to your advantage, right up to tooling & analytics. Whether you're just starting to build a Windows 8 (LOB) app or you're already well underway and hitting a performance issue, this course will help you out.

About the author
About the author

Kevin Dockx is a freelance solution architect (mobile/web), author & consultant, living in Antwerp (Belgium).

More from the author
Building an Async API with ASP.NET Core
Intermediate
2h 42m
Aug 14, 2018
More courses by Kevin Dockx
Section Introduction Transcripts
Section Introduction Transcripts

Introduction
Hello, and welcome to this Pluralsight course on Building high-performance Windows 8 applications. My name is Kevin, and I'm going to guide you through the rest of this course. This is the first module, which is a bit of an introduction to what's coming. So let's have a look at what we're going to talk about in the next few moments. We're going to start with a few words about why we should care about performance. It's one of those aspects of an application everyone agrees upon is important. Everyone wants a snappy app, no one likes to wait. That's what we feel, but how exactly does this measure up to our applications? What are some of the facts about performance? That's what that part of the module is about. Next, we're going to say a few words about how we can care about performance, and we're going to round it up with a short summary.

Application Lifecycle Performance
Welcome to the Application Lifecycle Performance module of the Building High-Performance Windows 8 Applications course on Pluralsight. My name is Kevin, and I'll guide you through the rest of this module. Let's have a look at the Outline. We'll start with a few words on the application lifecycle and its impact on performance, from which we can immediately go to the first of three big parts of which this lifecycle consists. The first one being considerations for starting up. We'll talk about how we can extend the splash screen and what its impact or relation to performance is. We'll talk about minimizing XAML parsing at startup, minimizing managed assembly references, and minimizing web requests. The second big part is considerations for suspending. We'll look into how we can reduce our app's memory footprint and we're going to look at why we should consider when we save our data. We'll end up with considerations for resuming and how we can ensure a fast resume. And, of course, to round it all off, we'll have a short summary.

XAML General Performance
Welcome to the XAML General Performance module of the Building High-Performance Windows 8 Apps course at Pluralsight. My name is Kevin, and I'll guide you through this module. Let's have a look at the Outline. We'll start out with a general overview on the XAML architecture. In this part, you'll learn what's going on beneath the covers, which is of course important to understand when talking about performance. We'll also focus on two very important threads - the UI thread and the composition thread. After that, we'll dive into some performance strategies on general XAML usage. We'll learn about the impact of element count, brushes, redrawing, CacheMode, and the default styles on performance, and how we can use this knowledge to get the most out of our apps. We'll also learn about two built-in ways of knowing what's going on - the framerate counter and the overdraw heatmap. Up next, our Resource Dictionary strategies, and after that, we'll get to a very important part of this module - UI virtualization. We'll start with a general overview explaining what it is, its possibly huge performance impact, and how we can achieve that. We'll also talk about another yet related concept - the viewport. And, of course, we'll end with a short summary.

XAML Animation Performance
Hello, and welcome to the XAML Animation Performance module of the Building High-Performance Windows 8 Applications course. Almost all Windows 8 Applications use animations to make them appear more vivid, more alive, and sometimes to create a perception of performance. A lot of these animations are built in the default controls and styles. That's quite easy. You use them without having to write any kind of code. Other animations are designed by you, or your designer, to create a unique feel or because some of the built-in animations simply don't fit the scenario you're envisioning. But beware, because these animations might also cause performance problems if you don't use them correctly. In this module, we'll look into how we can avoid that. We look at what dependent and independent animations are; how and where they are executed; and what they're impact on performance might be. We'll also look into how you can leverage the built-in animations, which are about as native as it gets. They're more optimized than any animation you might create yourself. After that, we'll have a look at some animation-related things you might want to avoid and we'll end this module with a short summary. At the end of this module, you will have a good understanding of the different ways of animating your user interface and how you can avoid animation-related performance problems.

Media Performance
Welcome to the Media Performance module of the Building High-Performance Windows 8 Apps course at Pluralsight. My name is Kevin, and I'll guide you through the rest of this module. Media, like video, audio, and images, are more often and regularly used these days than they were in the past. Video and audio integration in an app is often expected, and who can even imagine an app without images these days. XAML builds on the Windows 8 Media Engine, so every feature that has been added to those are available to us as developers out-of-the-box. However, there are some more things we can do to improve media usage in a Windows Store app. We'll start out with video and audio and move over to images after that. First, we'll learn a few things on media streams and working with video in general, moving on to the MediaElement after that. Then, we'll look at how we can improve image handling, and of course, we'll end with a short summary.

Data Performance
Hello, and welcome to the Data Performance module of the Building High-Performance Windows 8 Applications course. My name is Kevin, and I'll guide you through this module. In the XAML General Performance module, we talked about UI virtualization, i. e. ensuring only the necessary item containers are generated instead of all of them. However, that meant we still needed all our data in place. That's where this module comes in. In this module, we'll learn about working with large sets of data and what our impact on performance is. We'll see that loading all data at once isn't exactly good for performance, especially not when you're working with large sets of data, so we'll learn how we can virtualize those. This translates to only loading the data we need instead of all the data. Needless to say that the performance impacts of these techniques can be huge. And, of course, data virtualization can be combined with UI virtualization. We'll start out with a few general words on virtualization and then dive into the first type -- Random Access virtualization. After that, we'll talk about Incremental virtualization. And, of course, we'll end with a short summary. At the end of this module, you should have a good understanding of how you can ensure data is only noted when needed and what the impact of this could be.

Task Performance
Welcome to the Task Performance module of the Building High-Performance Windows 8 Applications course. I'm Kevin, and I'll guide you through this module. Let's start with an overview of what we'll talk about in this module. As with all modules, the techniques here are focused on getting the best possible performance for your Windows 8 Apps. We start out with learning how we can offload work to the background to keep our UI thread responsive, and related to that, how to use the dispatcher to avoid invalid thread exceptions. Next, we'll dive into a few task-related topics. We'll learn how to cancel running tasks that are no longer needed, thus freeing up resources, and we'll see how we can wait for one or more tasks to complete before continuing with other application code. Of course, we'll end with a short summarization of these performance enhancing techniques.

File System Performance
Welcome to File System Performance Module. My name is Kevin, and I'll guide you through the rest of this module. Let's have a look at the outline. We'll start out with a few words on using the file system in general, after which we'll immediately look into a few options we have and can use to speed up file system access by using QueryOptions. After that, we'll look into how we can optimize working with streams, and we'll end with a short summary.

Analyzing Performance
Welcome to the Analyzing Performance module. My name is Kevin, and I'll guide you through the rest of this module, but let's start by having a look at the outline. Some of the techniques we'll talk about will already be partially covered in the previous modules, so if you follow the complete course, you should already have a good idea of what your options are. That said, it's always a good idea to get an overview of what tools are available to you. There's lots of different ways of measuring performance, and there's a lot of tools on the market. In this module, I'll give an overview of the most useful ones, and how to use them. We'll start out with a few general guidelines. After which, we'll talk a bit about NGEN. We'll talk about using the framerate counter again, as we've seen in a previous module, and we'll talk about using the overdraw heatmap. We'll also look into a few options you have for performance profiling, and when it might be useful, and we'll do the same for memory profiling. And to end, we'll look into some other options you have, ending with a short summary, and the course round-up.