What’s wrong with the following piece of code?

It might seem just fine to you, but if you try to run it, it will throw a NotSupportedException in the last line: Collection is read-only. How come?

If you read closely the documentation for the constructor used, it might become clear. When you pass an instance of IList<T> to the constructor, the BindingList<T> doesn’t create its copy. It serves as a wrapper for it, supporting only the operations also supported by the underlying collection. Since an array implements IList<T> as a read-only collection, BindingList<T> throws the above mentioned exception when you try to modify it in any way. Interestingly enough, array doesn’t implement non-generic IList as read-only:

Anyway, keep in mind that BindingList is only a wrapper for the collection you pass it, therefore any changes made to BindingList will automatically also be applied to the underlying collection. This might be okay if you’re aware of it, otherwise make sure you pass a copy of your list to the BindingList to keep it unchanged:

As far as passing an array to BindingList constructor goes: I can’t think of a case when this would be useful.

Recently I encountered strange and inconsistent behavior in exceptions being thrown by different file operations in WinRT. Let’s start with a snippet:

Although there is a file named Text.txt in Assets folder of the application package, the above code throws an exception. If you were paying close attention while reading the code you might have even noticed the problem. There’s no exception thrown in the first line, though. Instead the second line throws an ArgumentException: Value does not fall within the expected range. Strange, isn’t it?

Let’s take a closer look by putting a breakpoint on the second line. The problem lies in the value of file.Path property: C:\Users\Username\Documents\Visual Studio 2012\Projects\SlnName\ProjName\bin\Debug\AppX\\Assets\Text.txt. Did you notice the two backslashes before the Assets folder? They’re causing the problem. CopyAsync method can’t find the file because of it and throws the non-descriptive exception which doesn’t really help pinpointing its cause. Calling ReadTextAsync on the file instead would’ve make it much easier:

In this case the second line throws FileNotFoundException: The filename, directory name, or volume label syntax is incorrect. Definitely much clearer. Too bad, CopyAsync doesn’t throw the same exception. It would have made troubleshooting the original issue much easier.

That’s not all, though. I still think the exception should already be thrown in the first line. If we replace the filename with a non-existent one (e.g. Text1.txt), it does throw FileNotFoundException as expected: The system cannot find the file specified. It seems that for some reason GetFileAsync can handle paths with double backslashes. It even sets file.DateCreated correctly, so there can be no doubt about that. The other methods don’t seem to support this same syntax. That’s not a problem per se, but in my opinion all methods should behave the same to avoid confusion: either support the syntax or not. Until that happens, I’ll keep in mind the described anomaly, just in case I stumble upon it again.

On the final day of NT Conference 2013 I had my last session. This time I was speaking about my experiences with building LOB (line of business) applications for Windows Store. As always, slides and samples are available here and from the conference web site.

At NT conference 2013 I hade 3 sessions in 2 different PreCon tracks. Apart from the one on connected apps for Windows 8 and Windows Phone 8 I had 2 consecutive ones, both covering the topic of design patterns, focusing on client application development.

In the first one I was comparing the three main approaches to developing user interfaces: MVP (Model-View-Presenter), MVC (Model-View-Controller) and MVVM (Model-View-ViewModel). Here are the slides and the sample apps.

In the second one I took the WPF sample app for MVVM design pattern from the previous session and modified it for injecting dependencies using an IoC container, arguing why this is useful and generally a good thing. Slides and samples from this session are available for download as well.

You can also find all the my slides and samples at the conference web site.

At NT conference 2013 I opened the Windows 8 and Windows Phone 8 Developer Tales from the Tranches PreCon track with a session on Building Connected Apps. I addressed all aspects of network communications, focusing on available APIs but also spending some time on the expectations for mobile applications in respect to network usage.

Although the session materials are already on the conference web site, I’m also publishing them here to keep them available after the conference site is closed down: both slides and samples.

The latest Packt publishing book I received a free review copy for was .Net Framework 4.5 Expert Programming Cookbook by A.P. Rajshekhar.

As soon as I glanced over the table of contents it stood out to me that this book doesn’t really have a prevailing theme even though it’s pretty thin. It’s a collection of mostly unrelated recipes, i.e. short  snippets of code focusing on a single problem accompanied by detailed explanation. In spite of the title, not of all of them are really .NET 4.5 specific, many of the features used have been available in previous versions as well. The book does mention that for each individual recipe.

Most of the sample code also includes much plumbing (mostly UI setup) which doesn’t really have anything to do with the problem at hand. I found that pretty distracting during reading. I think it would be a better idea to include full sample programs as download only and focus more on the actual recipe in the book. This might not be completely in line with the cookbook approach but I doubt anyone is going to type the code from the book, anyway.

I’ve never really been a fan of recipe based books although I did like some of them if they provided enough value in the explanations to warrant reading the book as whole. This one does seem more like a collection of blog posts, although admittedly it has passed a much stricter review process. Still a couple of recipes are objectionable, such as the ones still manually handling threads in the age of .NET 4.5. Most of the recipes are well written, though. If enough of them are of interest to the reader they should provide enough value to be worth the purchase. Fortunately the complete table of contents is available online and I definitely suggest everyone to check it out before deciding whether to buy the book or not.

The book is available on Amazon and sold directly by the publisher.

In mobile applications there’s often a need for scrolling lists with large or even (for all practical purposes) infinite amounts of data which of course needs to be loaded incrementally. The canonical example for this is Twitter timeline, but any other long lists of posts such as RSS feeds, log entries etc. call for a similar implementation, as long as they provide an API for loading data in batches, i.e. it is possible to request a range of results between two indices.

Official support for implementing such a list is already available since Windows Phone 7.1 (Mango) release, although it still seems too much of hassle to me. Implementing such a basic functionality shouldn’t require modification of default ScrollViewer style and handling VisualStates in code behind.

Things got better with LongListSelector control, distributed with Windows Phone Toolkit for Windows Phone 7 and included in Windows Phone 8 SDK. Now it’s enough to handle either Link or ItemRealized event, depending on whether you’re using Windows Phone 7 or Windows Phone 8.

Still, you probably want to avoid this when using MVVM pattern and instead have a command being called when additional data needs to be loaded. That’s exactly what the following behavior does:

You can use it by simply adding it to the LongListSelector’s Behaviors collection:

Inside LoadCommand’s Execute method you just load the next batch of data. You can even change the return value of CanExecute method based on whether there’s any more data to load and thus prevent Execute from even being called.

Since I decided to use Caliburn.Micro as the MVVM framework in my latest Windows Phone project this solution turned out not to be really tailored to it. Caliburn prefers actions to commands for invoking methods in view models. Ideally this means no additional code needs to be written for connecting control events to view model methods. There’s even special syntax available to make this work:

Unfortunately this requires the logic for deciding between loading additional items or not to be moved to the view model - for each individual case of implementing this functionality. Additionally while testing this approach I noticed the view model method wasn’t really invoked for the first dozen of items or so (not really sure why, I assumed Caliburn’s messaging wasn’t initialized in time) which could introduce subtle bugs preventing further data to be loaded in some cases. A custom trigger turned out to be optimal solution addressing both of the concerns:

Similar to a behavior this trigger can be used by simply adding it to LongListSelector’s Triggers collection:

The only thing that needs to be added to the view model is LoadMoreItems method, which belongs there anyway.

Recently I received a free copy of Kinect for Windows SDK Programming Guide ebook by Packt publishing for review. I didn't do any Kinect development before, but it sounded interesting to me for quite some time, so having a book to review was a nice motivation to finally get into it. At the same time this allowed me to look at the book through a lens of an experienced developer getting into programming Kinect for the first time.

The book turned out to be a great introduction to Kinect in all aspects. It assumes no prior knowledge of either Kinect or the SDK and even starts out with an explanation of the hardware. Understanding it makes it easier to develop for it later on. Finding all this information elsewhere would've definitely proven challenging and much more time consuming. The section on setting up the development environment surprisingly gives some added value as well. It addresses common issues in a troubleshooting guide and even covers the subject of connecting and using multiple Kinects at the same time, along with the pitfalls to watch out for in this scenario. The author has quite some first hand experience with the subject and it shows.

Most of the book is focused on individual sensors built into Kinect and the APIs for using them. It soon becomes obvious that the book is aimed at novices. It not only explains the concepts behind the SDK classes but at times also delves into the basics of C# and .NET framework as well as WPF when setting up UI in sample apps. While this isn't necessarily a bad thing I did find it distracting and it occasionally made reading the book a bit of a hunt for Kinect related information inside the rest of the sample code. I did like the samples, though. There are many of them and most of the time they make sense on their own and get beyond a basic sample just for the sake of showing a particular feature. Also the accompanying download includes additional working apps with source code that are merely mentioned in the book.

The part of the book that I like the most is about audio processing and gesture recognition. Both of these two subjects are addressed in more depth. For audio processing this means explaining the concepts of speech recognition, and for gestures this is a detailed overview of many different approaches that are possible, starting out with simple ones and leading all the way to neural networks. Don't expect becoming a master of gesture recognition but it will definitely get you going.

All in all this book is a really nice introduction to Kinect programming. It is by no means perfect, most notably because it tries to do too much by making sure total beginners will be able to follow it, but it is a valuable resource, nevertheless. I can recommend it to anyone who is interested in writing his first Kinect application. It might bore you in certain parts but it will certainly save you time in the end.

The book is available on Amazon and sold directly by the publisher.

At the end of September Packt Publishing celebrated the publishing of their 1000th book by offering a free book to all their registered users. After I decided for Windows Presentation Foundation 4.5 Cookbook by Pavel Yosifovich they approached me if I could write a review for the book once I read it. It took longer than expected but I’m finally done with it and ready to share my impressions.

Taking a look at the table of contents is enough to realize that the author took on a task of covering a very broad range of topics. What could easily be a daunting set of disconnected code recipes, actually turned out to be a well structured and thoroughly explained overview of WPF. Although the cookbook approach makes it easy to read only individual recipes of interest, I can strongly recommend to take the time and read the complete book. There are many small nuggets of knowledge given throughout it which are not directly related to the current recipe and you are bound to miss them otherwise.

I was also pleasantly surprised by the fact that the code snippets are accompanied by in depth explanations of related topics. They often even include alternative approaches to solving the same problem with pros and cons for each one of them. Due to the nature of WPF with many ways of achieving the same I find this very valuable. Since the book has only been written recently, it can take advantage of all the practices and experiences that have accumulated since the original release of WPF. As a bonus it doesn’t forget about the new features included in .NET framework 4.5 and C# 5.

On the other hand the book is not all that friendly to novices and you really need to have some previous experience with WPF before you start reading it. The wording is often very concise and in my opinion it could be challenging to get into without understanding at least the basics. Because of that I found it really strange that a couple of times the author starts explaining how to use certain Visual Studio features, such as code snippets and smart tags. I don’t think this is really necessary for the intended audience.

All in all I still like the book very much. In spite of all my previous experience with WPF, I’ve learned a couple of new tricks while reading it. I’m sure I’ll be returning to it from time to time to read up on certain details. I also feel the need to mention that I’ve encountered a couple of typos and even other minor mistakes in code and screenshots. They never really bothered me, but your mileage may vary.

The book is available on Amazon as well as sold directly by the publisher.

Today our local Microsoft DPE team organized ReBuild, a one day recap of the recent Build conference which was taking place in Redmond a little over a month ago. I had the last session of the day and focused on Windows Store apps: what they were and how to develop them.

As always I’m publically sharing the resources from the session: slide deck and sample source code.