Author: Raffaele Garofalo
Publisher: Apress
Pages: 352
ISBN: 978-1430234708
Aimed at: Neither beginners nor anyone wanting a hand-on approach
Rating: 3
Pros: Discussion of higher architectural and design considerations
Cons: Imbalance of levels
Reviewed by: Mike James

For a book called "Applied WPF in Context" your first though has to be "what context?"

The context isn't made clear anywhere I can locate in the book, but from reading it it seems that the default is a sort of high-level agile, domain-driven design, MVC, object-relational context. It is the sort of context that you associate with programmers who have learned all there is to know about the simple stuff and have moved on to a higher plane - I guess you could call it architecture.

What is surprising then is that is book opens with a chapter that introduces WPF and XAML to a reader that presumably has never encountered the like before. It is very basic and doesn't even seem to assume that you are a .NET programmer. This said, the level ramps up fairly quickly and it is fairly dry so if you are a beginner you need to be prepared to put some work in and read the text carefully. The final part of the chapter outlines the tools you can use VS 2010, Expression Blend and the free Express editions. Again these are introduced as if you were completely new to .NET development and had never heard of Visual Studio.

Chapter 2 explains the a single example is going to be used to show off WPF - a time tracker. Next comes a detailed discussion of the architecture - with an introduction to multi-tier, user stories and DDD (domain-driven design). From here we move on to looking at how to use Expression Blend - you can use the 30-day trial to follow the example.

Chapter 4 is about creating "views" - in fact they are ViewModels as in the MVVM pattern. The book is very heavily into the MVVM model and this isn't unreasonable, but leaving a detailed discussion of it until Chapter 12 is less justifiable. Later in the chapter we are introduced to inversion of control and a simple implementation. The next chapter adds controls to the views, using themes and data validation.

Chapter 6 moves on to database and not just any approach to database but Entity Framework a system that is a lot easier to use than it is to read about. Then on to data binding the model to the view and command handling and event routing.

At this point the book takes small jump to consider the role of Test Driven Development in general and in WPF in particular. Next we go into SQL reporting services - not something that everyone will have to couple to WPF and hence a topic that is generally overlooked.

Chapter 11 is on deploying the application using ClickOnce and you know you must be nearing the end of the journey. Chapter 12 attempts to put it all into the context of patterns MVP, MVC and MVVM, but rather than being an overview this should have been an earlier chapter to make the context of the entire design clear.

The final few chapters aren't really part of the same story. There is a chapter on WPF and threading. This is mostly a general look at threading but it does have some specific ways of working with the WPF UI. It uses the dispatcher directly to solve the cross thread access to the UI problem, which is interesting, but doesn't mention the Invoke method that most controls have as a simpler. alternative. It also covers the new Task object but doesn't cover the new await command in .NET 4.0. Overall an interesting chapter but incomplete.

The book closes with a very short look at WCF - and it is difficult to see why it was included. It is relevant to WPF, it isn't that WPF applications are not going to make use of it but they are going to make use of most other .NET facilities - so why pick on this one? Why not for example go into details of how to use generics in a WPF application?

This is a book that you are going to have to work quite hard to follow. It seems to imagine that the reader will be sophisticated enough to want to deal with architectural issues, but will also be fairly innocent when it comes to .NET and WPF. Unfortunately the book doesn't do much to deal with the innocence problem and skims over a lot of ideas inherent in the WPF system. The book could also do with some trimming down - either that or the chapters that deal with only loosely connected topics need to be expanded and the connections made clearer and the discussion more relevant to WPF.

Overall it is easier to say what this book is not. It is not a beginner's book and it is not a book for anyone wanting to learn the mechanisms of WPF. It is more about the way WPF fits into higher architectural and design considerations. If this is what you are looking for then you might get some value from this book.