For me, however, I need a small camera app sitting on my desktop so I can see the hallway leading to my office. I call it the heart-attack preventer, as it makes it difficult for my children to sneak up on me when I'm heads-down at work. This is because I'm surrounded by displays and simply can't see over them. My home office is in the basement, with a combined TV room and play room (plus a bunch of storage) surrounding it, so the kids often sneak in here to say "Hi".

I installed the latest version of the LifeCam software, and it doesn't install the desktop camera app at all. Bummer. I quickly checked, and this is a common observation about that install.

Rather than spend all afternoon looking for a solution, I figured it would be easier to code my own in 15 minutes. I considered using WPF 4.5, but WebCam access in WPF requires third-party toolkits or DirectX code (or Win32 API calls), so that wouldn't do it. Coding a solution as a Windows Store app wouldn't do, as I need a very tiny window on my desktop, not a snapped app. I sometimes snap other apps and wouldn't want the webcam app to limit that, or take up that amount of room.

Silverlight has always had extremely simple WebCam APIs that are quick to use. (WinRT's APIs are just as easy if not easier).

I created a quick Silverlight 5 project in Visual Studio 2012. Made it an out-of-browser app with elevated permissions, and put this as the MainPage.xaml markup

<UserControl x:Class="SimpleWebcamSL.MainPage"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

    mc:Ignorable="d"

    d:DesignHeight="300" d:DesignWidth="400">



    <Grid x:Name="LayoutRoot" Background="White">

        <Rectangle x:Name="VideoOutput"

                   HorizontalAlignment="Stretch"

                   VerticalAlignment="Stretch" MouseLeftButtonDown="VideoOutput_MouseLeftButtonDown_1" />

    </Grid>

</UserControl>

And this as the code-behind:

using System;

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Linq;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;



namespace SimpleWebcamSL

{

    public partial class MainPage : UserControl

    {

        public MainPage()

        {

            InitializeComponent();



            Loaded += MainPage_Loaded;

        }



        ReadOnlyCollection<VideoCaptureDevice> _devices;



        void MainPage_Loaded(object sender, RoutedEventArgs e)

        {

            _devices = CaptureDeviceConfiguration.GetAvailableVideoCaptureDevices();



            // specific to my system. Camera 1 is the one that points

            // out of my home office. Camera 0 points at me.

            if (_devices.Count > 1)

                SetCaptureDevice(_devices[1]);

            else if (_devices.Count > 0)

                SetCaptureDevice(_devices[0]);

        }





        private void SetCaptureDevice(VideoCaptureDevice device)

        {

            var source = new CaptureSource();

            source.VideoCaptureDevice = device;



            var brush = new VideoBrush();

            brush.Stretch = Stretch.UniformToFill;

            brush.SetSource(source);

            VideoOutput.Fill = brush;



            source.Start();

        }



        private void VideoOutput_MouseLeftButtonDown_1(object sender, MouseButtonEventArgs e)

        {

            Application.Current.MainWindow.DragMove();

        }



    }

}

I set the project properties for out of browser, no window border, and elevated permissions (all covered in my Silverlight 5 book) and then installed the app. All done in about 15 minutes. It took longer to write this post than it did to create the app.

This is hard-coded to my specific situation (second camera is the camera which points away from my desk). I didn't bother with icons, camera switching, or anything beyond what I needed for this specific situation.

As a woodworker, I find it's sometimes quicker for me to build something as opposed to search stores to find what I'm looking for. As a programmer, sometimes it's faster just to code your own solution rather than search the internet all day for workarounds. :)

Buy it Here

• http://www.manning.com/pbrown2/

Discount Code

Use this code starting at midnight tonight US eastern time (GMT-5:00)

• dotd0606au

Additional Material

While you are there, don't forget that in addition to the 965 printed pages, purchasers also have to access to 150 pages of downloadable content, including:

• Media basics
• Raw Media, Webcam, Microphone
• Introduction to WCF RIA Services
• WCF RIA Services Endpoints, Security, Logic and more
• WCF RIA Services MVVM

All the downloadable content went through the same quality and editing process, so it's real book material.

Silverlight 5 is a great platform, especially for building business applications. Among many other changes, the enhancements to trusted applications and the addition of p-invoke make it an excellent choice for building today's business applications. The addition of a built-in 3d engine make it great for cutting edge visualizations, interactive CAD-like tools, and even gaming.

Windows 95 was a big deal for users and developers alike. It had a brand new interface, and a new set of programming APIs, common controls (3d beveled gray the norm!), navigation patterns and more. For most developers, this was their first taste of a 32 bit operating system, and the first taste of the Win32 API. That stuff's all old hat now, but it was new and exciting at the time.

This excitement is a lot of what drove me to move to my new role at Microsoft.

Get the Windows 8 Release Preview here. Be sure to watch the video at the top of the page. It's really well done and shows a really well-rounded (if quick) view of the consumer side of Windows 8. Read more about the release preview in Steven Sinofsky's post.

Overall, this release feels smoother, faster, snappier, and more stable when compared to the consumer preview (which was already pretty good), as it should. As primarily a desktop user, the start screen has really grown on me. I have to admit that my initial reaction almost a year back was a bit "meh" and a lot "who moved my cheese", but once I started using it every day, I found that I really started to like it on my desktop. I switch back and forth between Windows 7 and Windows 8 constantly (my home office alone has 3 PCs running full time - soon to be four) so I get to make comparisons constantly. I also do a lot more than just a few apps. Lots of development, production, and much more. As much as I like it on the desktop, I can't wait to use it on a tablet, as I know it'll be even better there.

As primarily a desktop user, I especially like the changes the RP brings when it comes to using the mouse. The corners behave better now, for example. Also, as a person who uses multiple large displays (not yet running Windows 8 on that machine, but soon), I'm happy to see what we've done to support power users like us. BTW, in case you're curious, dual 1560x1600 30" backlit displays do a great job of heating your office on cold days :)

The Windows Store and Apps

At the same time, we've launched an updated store with TONS of great applications. You'll need the release preview to see these. My thanks to all the people who have submitted such great applications in time for this release, and to the folks in corporate and field evangelism who spent the time to help these customers deliver. I joined the team a little late to be heavily involved here, but just watching the process (and lending a small hand here and there) has been great.

To learn more about the developer changes to the store for the release preview, watch the Windows Store for Developers blog.

Developing for Windows

I'm a Windows user, but like you, I'm also a developer. There are a number of cool new things for developers in this release, primarily centering on the new Visual Studio 2012.

Visual Studio 2012 RC

Today we released a new version of Visual Studio, now branded Visual Studio 2012. If you think about it, this is some serious stuff. All at once, as a company, we have Web teams, Client teams, Framework teams, Developer Tools teams, Windows Teams, Windows API Teams, Windows Store teams, MSDN content teams, and more all shipping stuff on the same day. I'm impressed if I can manage to get both of my kids dressed and out the door at the same time when we have a deadline. Imagine driving most of an entire company towards a single date, and with no mismatched socks.

Among other things, I really like what we've done with the theming since the Consumer Preview / Beta. This is the tool I've been using daily for a while now. Like Windows 8 RP, this is more stable and reliable, and generally just feels more "done". I've been using this for a bit now, and am really happy with where we've taken it. Kudos to all the teams involved in developing Visual Studio, including the .NET 4.5 framework teams.

(I don't usually run it at 1366x768 - the minimum full tablet resolution, but I needed to for some screenshots/demos. I also use this via remote desktop from my main PC.)

I've been using various builds of Visual Studio 2012 RC for some time now. With the latest set of UI changes, I really do find that my eyes naturally focus on the code or markup far more than the chrome. Sure, when you first see it, your eyes will want to take in the whole picture, but after that, it's all code. To the Visual Studio team, I say "Mission Accomplished".

Jason Zander listed a number of enhancements to the Metro style templates and tooling for this release. Among the highlights:

• A new Windows Runtime template so you can create WinRT components using C# and VB
• Better tooling support in Blend
• Better keyboard and mouse navigation in the templates, by default
• A go-live license just like with the beta.

If you install one of the appropriate SKUs, you can develop for WPF, Silverlight, ASP.NET, WinRT/Metro and more all on Windows 8. Even on Windows 7, you get the new tooling UI, which I find to be pretty nice. You can also find information on the new UI here, and on the dark theme here.

Get Visual Studio 2012 RC here. It works on Windows 7 and Windows 8, as well as on our 2008 and 2012 server products.

As you would expect, there are some breaking changes from the consumer preview/beta, as you would expect. The full list of what has changed for application developers can be found in this blog post. Of course, the very best place to go to get started with Windows 8 programming is the Windows Dev Center. For Visual Studio 2012 development in general, visit MSDN.

Aside on DPI

Developers typically have laptops with high DPI screens. I have a 1920x1080 laptop. If you do a clean install (and the driver has appropriate support at install time) you'll likely see that your DPI settings in Windows are higher than you've had in the past. On my Lenovo, it defaulted to 125%. I actually like the higher DPI, but I did turn it off when I went down to 1366x768 presentation settings.

This also happened with clean installs of Windows 7, but due to better driver support and other factors, you're likely to see more of it in Windows 8. Feel free to change this, but also consider that your users may have high DPI selected by default. I'm happy to see us making these little steps towards a future of higher resolution, higher DPI displays. This is not the same as the scaling you get when you pick a lower resolution than your laptop supports, this is true high DPI.

My Windows 8 XAML Book

Yes, I'm still working on my Windows 8 XAML book :)

Silverlight 5 in Action showed up in boxes this week, so Manning (and I) can completely concentrate on the Windows 8 book now during my should-be-sleeping time. My apx 1200-1300 pages (including download content) from the Silverlight book is probably responsible for more overtime at Manning than most anything else :)

Manning is working on getting the MEAP (Manning Early Access Program) site set up for my Windows 8 XAML in Action book. They just need me to wrap up some things today and tomorrow before they can launch it. I'm only slightly better than Douglas Adams when it comes to deadlines, but I do have several cool chapters to be released. Based on feedback from folks internally, I think you'll be pleased.

Go Install It

I've been running the release preview/candidate builds for a week or so. My 6yo son's laptop is going to get Windows 8 tonight or tomorrow. I know he'll love it, as well as the cool games and other kid-oriented apps in the store. The UI will be easier for him to navigate, and the full-screen approach in Metro far more appropriate to his use, and IE10 now has much better support for the sites he visits on a regular basis.

Oh, and now that I can show screen shots, expect more posts here :)

Go get it all and write something cool.

Here are my four boxes, just delivered today. The UPS man probably hates it when he has to deliver books to my place. At 968 pages each, they're pretty heavy. That top box: 1 book. Plus, there are another 200-300 pages of good material, freely downloadable for people who have purchased the print book (ebook purchasers should find the chapters included automatically, but if not, the chapters are available to you as well.) The additional material went through the same editing process as the printed material, it was just too much to include in the print edition.

If you have a copy, and like it, I encourage you to post a review on Amazon.com. Every little bit helps. Thanks!

The key thing to note here is that the work is done by the compiler, not the runtime. That means that if you can use the latest C# compiler, you can take advantage of this new feature. A grasp of the async pattern and these two keywords will also help prepare you for Windows Metro development. Note that Silverlight doesn't have the same "asynchronous everywhere" set of APIs that you'll find in WinRT or .NET 4.5 so async and await won't be quite as useful here as they are there, but there's some help for that too (read on). You can still create your own async methods, however, which is especially useful if you plan to share code with a WinRT XAML application.

I'll focus on Silverlight 5 here, but understand that this works with .NET 4 in VS11 as well. Note also that I'm using Visual Studio 11 beta for this post, so final details may change when VS11 is released. Also, Visual Studio 11 and the compiler which supports async/await requires Windows 7 or Windows 8. This will not work on Windows XP or a Commodore 128.

In Visual Studio, create a new Silverlight application.

Choose all the normal options in the project creation dialog (yes, create a new site, no on RIA)

For the MainPage.xaml, add a single button and wire up an event handler.

<UserControl x:Class="SilverlightAsyncDemo.MainPage"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

    mc:Ignorable="d"

    d:DesignHeight="300" d:DesignWidth="400">



    <Grid x:Name="LayoutRoot" Background="White">

        <Button x:Name="TestAsync"

                Content="Press Me!"

                FontSize="25"

                Width="200"

                Height="75"

                Click="TestAsync_Click" />

    </Grid>

</UserControl>

The next step is to add the Async Targeting Pack. I'll use NuGet to grab it.

Pick your favorite way to use NuGet. Some prefer the console. I'm going to use the project's context menu and select "Manage NuGet Packages". From there, I'll search for AsyncTargetingPack.

Once you see it, click "Install", accept the terms (maybe even read them first), then close the NuGet package manager. You'll notice that the Silverlight project now includes a reference to the Microsoft.CompilerServices.AsyncTargetingPack Silverlight 5 library.

A simple example using await

If you have a call which uses the async callback pattern, such as with a WebClient in Silverlight, using await is pretty easy, due to the built-in extension methods:

private async void TestAsync_Click(object sender, RoutedEventArgs e)

{

    var uri = new Uri("http://localhost:10697/SilverlightAsyncDemoTestPage.html");

       

    var client = new WebClient();



    var results = await client.DownloadStringTaskAsync(uri);



    Debug.WriteLine(results);

}

Note that the event handler must be marked as async in order to use the await keyword.

These extension methods, DownloadStringTaskAsync in this example, are included in the AsyncCompatLibExtensions installed with the async targeting pack.

The extension methods mimic many of the same async functions already available in .NET 4.5. That's great for compatibility and to help reduce how many different approaches you need to learn.

Give me something to wait on

"Hey teacher! I've got my pencil! Now give me something to write on." - Pre-geriatric David Lee Roth

Let's do something a little more typical. In this case, I'm going to create a web service that we'll use asynchronously.

In the web project, create a "Services" folder and in that, create a new Silverlight-Enabled Web Service named CustomerService.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.Serialization;

using System.ServiceModel;

using System.ServiceModel.Activation;



namespace SilverlightAsyncDemo.Web.Services

{

    [ServiceContract(Namespace = "uri:demo.silverlight.async")]

    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]

    public class CustomerService

    {

        [OperationContract]

        public List<Customer> GetCustomers()

        {

            string[] firstNames = new string [] {"Pete", "Joe", "Ima", "John", "Jim", "Scott", "George", "Frank", "Al", "Jeremy", "Jason", "Alex", "Bob", "Bill", "William", "Severus", "Johnny", "Albus", "Han", "Harry", "Chris", "Christine", "Kristen", "Amy", "Leia", "Erin", "Heather", "Melissa", "Abby", "Ben", "Alice", "Morgan", "Chip"};

            string[] lastNames = new string [] {"Brown", "Jones", "Braxton", "Huxley", "Solo", "Organa", "Vader", "Skywalker", "Potter", "Dumbledore", "Snape", "Avatar", "Cranks", "Bravo", "Grime", "Gee", "A.", "B.", "C.", "D.", "E.", "Z.", "X.", "Walker", "Franklin", "Moore", "Less"};



            Random rnd = new Random();

            const int CustomerCount = 200;



            var customers = new List<Customer>();



            // generate a bunch of dummy customer data

            for (int i = 0; i < CustomerCount; i ++)

            {

                int firstIndex = rnd.Next(0, firstNames.Length-1);

                int lastIndex = rnd.Next(0, lastNames.Length-1);



                customers.Add(

                    new Customer()

                        {

                            FirstName = firstNames[firstIndex],

                            LastName = lastNames[lastIndex]

                        });

            }



            return customers;



        }

    }



    public class Customer

    {

        public string LastName { get; set; }

        public string FirstName { get; set; }

    }

}

Build the solution, and then add a service reference from the Silverlight client. When creating the service reference, name the namespace "Services". But before you leave this dialog, we have one VERY important thing to check. Click the "Advanced" button

Foiled! We can't generate task-based service references. Why? Well, Silverlight didn't have the necessary support until the async targeting pack. So, we'll have to do this manually. If you were using .NET 4, you could simply generate Task-based operations and be done with it.

NOTE

If we were using RESTful calls, the "add service reference" stuff doesn't come into play at all - it's all just POST/GET/DELETE/PUT/PATCH with a URL. SOAP, which is what many folks use behind the firewall, is more difficult to work with, so the service reference helps. I'm a big fan of the ASP.NET Web API and RESTful services. You should check them out.

Creating an async-friendly wrapper for the service reference

Making your service method awaitable certainly makes it easier to consume by other developers, and easier to work into your own application workflow (especially if you have service calls that rely on the results of other service calls). The code to make it awaitable is not very complicated at all. However, I like to put this type of code into a separate service proxy or client class in the Silverlight project.

I created a new project folder named "Services" in the Silverlight project. In that, I added a new class named "CustomerServiceProxy". The code for the proxy is as follows:

using System.Collections.ObjectModel;

using System.Threading.Tasks;



namespace SilverlightAsyncDemo.Services

{

    public class CustomerServiceProxy

    {

        public static Task<ObservableCollection<Customer>> GetCustomers()

        {

            var tcs = new TaskCompletionSource<ObservableCollection<Customer>>();



            var client = new CustomerServiceClient();



            client.GetCustomersCompleted += (s,e) =>

                {

                    if (e.Error != null)

                        tcs.TrySetException(e.Error);

                    else if (e.Cancelled)

                        tcs.TrySetCanceled();

                    else

                        tcs.TrySetResult(e.Result);

                };



            client.GetCustomersAsync();



            return tcs.Task;

        }

    }

}

The code for this was adapted from the Task-based Asynchronous Pattern whitepaper listed under "Additional Information" below. The task is set up to return an ObservableCollection of Customers, which is (by default) what the service reference code generation created for me in the CustomerServiceClient class. (I also love how we managed to get both spellings of Canceled into the same method O_o.)

Once you have the proxy created, it may be used from the ViewModel, or any other code. Here it is in the button-click code on MainPage. As before, the event handler has been marked with the async modifier in order to support using the await operator.

private async void TestAsync_Click(object sender, RoutedEventArgs e)

{

    var customers = await CustomerServiceProxy.GetCustomers();



    foreach (Customer c in customers)

    {

        Debug.WriteLine(c.FirstName + " " + c.LastName);

    }

}

This can serve as a good starting point for your own code. Not only will it make your async code easier to work with when using Visual Studio 11, but it will also help you bridge towards and share code with .NET 4.5 WPF, and to Metro style XAML applications.

Additional Information

• Download: Task-based Asynchronous Pattern
• Simplifying Async Networking with Tasks in Silverlight 5
• Under the covers of the async modifier and await operator in .NET 4.5 and C# Metro style applications

TL;DR:

XAML. Windows. Developers. 'nuf said.

A little (optional) history

I've been working for Microsoft for a bit over two and a half years now. In that time, I've learned that the old cliché about the only constant being change is more true for Microsoft than just about any other place I've seen. Mixing up teams, offices etc. from time to time helps make the orgs more efficient, and injects new ideas into groups.

When I was hired by Scott Hanselman in fall 2009, my primary focus was to create a lot of content for WindowsClient.net and Silverlight.net, as well as my blog. In addition to Scott, the team I joined included Tim Heuer, Rey Bango, Joe Stagner, Jesse Liberty and Jon Galloway. A few months later, Tim Heuer fulfilled a personal dream and moved to the one of the product teams. Ten months after I joined, Scott moved to the Web team, and Rey Bango moved to another org to focus on some initiatives that he had been leading. Some of this was due to the reorg that created the brand new organization (with all brand new leadership) my team was moved to.

The people I worked with and for in that org were awesome. I've enjoyed that role, and particularly enjoyed working closely with patterns & practices, MSDN, and more.

When Scott moved to the web team, I was given the lead of the Community Team which by then included me, Jesse Liberty, Jon Galloway, and Joe Stagner. We accomplished some really great things, but at the same time, found ourselves focusing on tasks and priorities which didn't quite fit the emerging mission, or in some cases the capabilities, of our new org. Joe and Jesse moved on for their own reasons, and are both now doing awesome stuff. Jon and I stayed in the org, but a team of two is hard to keep effective and impactful, despite excellent management support and an org full of passionate and interesting people.

Jon and I agreed that he should pursue his interests and move to the Azure/Web evangelism team, a move that really fit what he wanted to do, and does best. Jon is an awesome guy, and I really enjoyed having him work for me. We continue to work together of course; the only big change for us with his move is that I no longer need to approve his expense reports (yay!). I was certainly able to stay where I was, but once I was sure Jon was well-settled, and I no longer had any direct reports, I was free to pursue something I was truly excited about.

My interests and passions

I love working with XAML. Most of you have probably figured that out. It's not my only interest by far, but it is a strong one. My technical passions, in no particular order are:

• Client application development, primarily on Windows (I don't own a Mac, and it's been around 12 years since I last ran a Linux box)
• Open source hardware (and general maker / electronics / CNC / 3d Printing and more)
• Open source software
• User experience and (to my limited ability) graphics design

I especially enjoy writing and speaking about C# + XAML, although I'm starting to dabble in C++ + XAML (say that out loud) as well. I've always liked working with Silverlight and WPF, and the communities of people building awesome stuff using them. Lately, I've been working a lot more with Windows 8 as well. I'm really excited about what I see coming for Windows, and for Windows 8 devices like tablets/slates. In fact, some time ago, I committed to creating a Windows 8 XAML book with Manning (the first MEAP chapters will be out very soon - promise!).

I enjoy building applications and gadgets. I also love speaking to developers, and wanted to speak more at larger events. I like helping to represent the product teams at Microsoft, as I've done for Silverlight and WPF. I wanted to join an org where I can work with the technologies I love, the communities I know and respect, and one which would allow me to continue the personal policies of honesty, openness, transparency, clarity, and authenticity that were so important when working in Hanselman's (and later my) team.

The new role

To that end, I've taken a very cool role working for Giorgio Sardo as a corporate Technical Evangelist on the Windows Platform Evangelism team, focusing on XAML. (This is the current incarnation of the team John Papa was on and that Brian Keller, Jaime Rodriguez, and Giorgio Sardo, among others, are currently on.) I will continue to be a remote employee, working out of my house near Annapolis, MD (between Baltimore, Washington and the Chesapeake Bay). I will also continue working with the Silverlight and WPF community, but will add to that a much larger focus on Windows 8 XAML going forward, and possibly some phone work too. Metro style apps have huge potential both short term and long term in all areas of client development from consumers to line of business. I want to be a part of their success, part of your success.

Among the many things I'm going to try to accomplish are to help find ways, for those who want to, to make it easier for today's XAML developers to prepare for and migrate apps to WinRT XAML if appropriate for their application. No forcing. You use the technology that best meets your business and application goals and requirements. I'll continue to do this in a wide-reaching way through events, articles, toolkits, samples, books, twitter, blogs and much more, and also add to that working much more closely with people in the field, folks in the community, and with some individual customers.

During my interviews, I made it very clear that I am a horrible sales person. Gladly, that's not this role. Some community folks I speak with consider evangelism synonymous with sales, but like so many roles at Microsoft, the role is really what you make of it as an individual. The team I'm part of is full of high-integrity individuals who all believe in the same things I do. During the day of interviews, the ideas I proposed, ideas that I believe many of you will find match with or support your own goals, were received with enthusiasm and excitement.

I'm really happy to continue with XAML, and to continue working with the community, now with more Metro. My first task? Helping to build a cool and relevant keynote demo. EXACTLY the type of thing I've wanted to do for a long time :)

In addition to that, last week I had VSLive NYC where I had three sessions covering Silverlight, WPF, and Windows 8, a Saturday code camp session in Philly on Windows 8 XAML, and coming up in June, a Tech Ed session on WPF 4.5. Oh, and in August I'll be speaking at thatConference on Windows 8 for Silverlight and WPF devs, and also on open source hardware, and again at VSLive on WPF and Windows 8 XAML. You can see that I have quite a mix there, with good representation from all the client members of the XAML family.

And, of course, I will continue with my NETMF and gadget work. That's always been as much a personal passion as anything. I often find a way to work it in with my primary focus, and will be doing that here for sure.

FAQ (or at least the Qs I think will be F)

Forgive me if any of these are pretentious. I've jut made a best guess as to the questions you may have.

Q: Are you abandoning Silverlight / WPF?

A: Nope. Those technologies are just as important now as ever. Silverlight 5 was an exciting and huge release. WPF 4.5 is an equally interesting release. I will focus more on XAML in general and Windows 8 in particular, but I'm keeping my fingers in all the pots. My Silverlight 5 book should be back from the printers any day now, so you can enjoy all 1000 printed pages (and 200-300 downloadable pages) as well. I also have Silverlight and WPF sessions at upcoming conferences, and as long as folks keep showing up to learn, and I have something new to teach, I'll keep teaching.

Q: Are you going to focus exclusively on Windows 8 XAML

A: Not exclusively, but I will certainly focus more time and energy in that area. It's new. It's exciting, and I think it's going to be a big deal for every developer. See my list of events above for the current mix of sessions I'm doing, for example.

Q: What about your NETMF/Gadgeteer Stuff?

A: I'll still work on that, as I really enjoy it. It was always a hobby and will continue to be one. Also, I'm always looking for ways to sneak it into other technology demos. :)

Q: What happened to your Silverlight 5 book?

A: I wrote WAY too much, so it took forever to edit and print. It's out any day now. The delay is completely my fault.

Q: What is your next book?

A: Windows 8 XAML, of course. I've had this one in progress for quite some time, but the burden of editing 1300 pages of my SL5 book caused a bit of a delay :). Expect to see the MEAP soon, hopefully in time for our June Windows release. The next book will be, by Manning's insistence, much shorter but equally as useful :)

Q: Are you moving to Redmond?

A: Nope. I am very proud to be the first remote worker in this team at Microsoft. Working remotely sometimes limits the things you can do at Microsoft, but I'm really glad this org not only looked past that, but embraced it as a strength. Besides, working on the east coast lets me be a nightowl at home, but still appear to be a morning person to those in Redmond ;)

Q: Why Windows 8 XAML as a primary focus?

A: I'm a super ADD person, just ask my wife. (Squirrel!!) I need new and exciting things to keep me going. They also need to be new things that I'm genuinely excited about, and which I think will be a benefit to the community of developers. Metro and WinRT + XAML + .NET 4.5 definitely fits that criteria. I'm even excited about the HTML/JS side of Windows 8 Metro, but I have close to zero skills there currently.

Q: Why the corporate/platform evangelism team?

A: This is the team that builds the customer connections, creates the keynote demos, generally has earliest and best access to cool stuff, and has a bunch of very cool people I respect. It also helps that they wanted me to join :)

Q: Will you continue to help run the Silverlight and WPF/Client App Dev MVP programs

A: Yes, in the same capacity as today.

Q: Metro all the things?

YES :)

(Robot minifig photo source.)

A version of the database that is compatible with the examples in my Silverlight book can be found on this page:

http://msftdbprodsamples.codeplex.com/releases/view/4004

The top download, AdventureWorksDB.msi is what you want. It's dated May 7, 2007. It's maked as SQL Server 2005, but it works with more recent version. A later version of the database may work (pretty sure the one I used was dated 2009 or 2010), but this one is the only currently available compatible version we can find.

• Error 2 CA0055 : Could not unify the platforms (mscorlib, Version=2.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e, mscorlib, Version=5.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e) for 'MyProject.Silverlight\obj\Debug\MyProject.dll'.

More information on CA0055 may be found on MSDN.

How to Reproduce the Issue … in theory

In theory, all you need to do to reproduce the issue is reference a SL4-targeted DLL from an SL5 application. However, in practice, there are other factors in play. For example, it may matter which mscorlib version gets loaded first.

These steps won't repro the problem on my installation, but I'm putting them out here in case they help you visualize the issue (and also because I had already written them up when I realized they don't repro here -- I don't want all these bits to go to waste).

Create a Silverlight 4 class library. Make sure you target Silverlight 4. I named mine SL4ClassLibrary. The actual code is unimportant, but I set it to the following:

namespace SL4ClassLibrary

{

    public class Class1

    {

        public string Foo = "Bar";

    }

}

Next, add a Silverlight 5 Application project. Make sure it targets Silverlight 5. Here's what my solution looks like:

Build the solution.

Next, add a File Reference (not a project reference) from the Silverlight 5 client app to the Silverlight 4 DLL.

If you build it now, everything works fine. The key step here is to add code analysis. Many organizations have code analysis as a required part of their build process, using the compiler command-line arguments. If you don't, you can turn it on via the menu:

Then check the "Enable Code Analysis on Build" checkbox.

Now build the solution. In theory, you'll get a CA0055 error, but as I mentioned at the top, that doesn't happen on my install. Most of the people who have reported this issue on the connect bug have mentioned it in the context of the Business Application Template or third party controls.

Remember, this is a code analysis compile/build issue, not a runtime issue, so if you get past compiling your application, you're good.

The Workaround

This is already planned to be fixed in Visual Studio 11 RC. However, we do have a manual workaround for this to help you continue working if you're running into this scenario today. This will unblock using FxCop in Visual Studio 2010.

A high level walkthrough of how this works from the command line is:

• We will tell FxCop which version of the runtime it will be using by pointing it to Silverlight 5's installed mscorlib.dll using the /platform argument
• Tell FxCop where to find all of the referenced assemblies using /d (short for /directory) arguments: Use as many /d:<folder> arguments as necessary for FxCop to find all of the referenced assemblies.
• Use either /console to tell FxCop to output the results to the console window, or /out:<file> to tell FxCop to write the results to an .xml file

To run FxCop from the command line for a default Business Application:

• Add the %Visual Studio Install Directory%\Team Tools\Static Analysis\FxCop folder to PATH
• Run "fxcopcmd.exe /file:<SL Business Application binary> /platform:<SL5 Reference Assemblies Directory\mscorlib.dll> /d:<SL4 Reference Assemblies Directory> /d:<SL4 SDK Client Libraries Directory>"

An example of what this looks like on an x64 operating system with all of the default install directories is:

• SET PATH=%PATH%;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop
• fxcopcmd /file:BusinessApplication1.dll /platform:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\Silverlight\v5.0\mscorlib.dll" /d:"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\Silverlight\v4.0" /d:"C:\Program Files (x86)\Microsoft SDKs\Silverlight\v4.0\Libraries\Client" /out:results.xml
• NOTE: If you receive a CA0001 error: "The following error was encountered while reading module 'XXXX.YYYYY' : Assembly reference cannot be resolved…" this means that you need to find where that assembly is installed to on your machine and add an additional /d:<installed directory> argument pointing FxCop to where those assemblies are installed. 

My thanks to the Silverlight Team and to Andrew Hall for the information on this workaround.

Of course, the easiest and best solution, if you can do it, is to use libraries that specifically target Silverlight 5, and make sure all references from your Silverlight 5 project are to libraries targeting Silverlight 5.  We know that's not possible in all cases, including the specific reported business application case, which is why we documented this workaround.

This new version has the all important go-live license, and also extends the expiration date to June 20, 2013 (over a year from now)..

More information on the Expression Blend Team Blog.

The original question was about Silverlight, but the approach works in WPF, Windows 8 and more.

Given the following markup:

<StackPanel>

    <TextBlock x:Name="OriginalText"

               FontSize="72"

               FontFamily="Gabriola"

               Text="Hello World!" />



    <TextBlock x:Name="ExampleText"

               FontSize="72"

               FontFamily="Gabriola"

               Text="Hello World!" />

</StackPanel>

You can set an attached property such as Typography.StylisticSet5 by using the SetValue method like this:

private void SetTextOptions()

{

    ExampleText.SetValue(Typography.StylisticSet5Property, true);

}

The SetValue method comes from the DependencyObject base class. Typography.StylisticSet5Property is the name of a dependency property - an attached property in this case. This could easily have been the Canvas.Left property, the Grid.Row property or any number of other attached properties. The resulting display looks like this:

Note how the second TextBlock has had the stylistic set applied to it.

This approach used the SetValue method of the dependency object. There's also another way:

private void SetTextOptions()

{

    Typography.SetStylisticSet5(ExampleText, true);

}

This version uses the Set[dpname] method of the class which owns the property. Use the most convenient method. Both are equivalent.

I also cover dependency properties and attached properties in both of my Silverlight books, as well as in my upcoming Windows 8 XAML book.

Subsequent versions Silverlight added that capability and the converter. For example. Given an instance of the following model class as the data context:

public class Tweet

{

    public string Message { get; set; }

    public Uri Image { get; set; }

}

In Silverlight, you can bind in XAML like this:

<Image Source="{Binding Image}" />

In the current version of Windows 8/WinRT XAML, you can't bind image sources directly to Uris, but there's a nice way to do it by using property element syntax and and a BitmapImage class. It's more verbose, but may be just the ticket if you need to bind to Uris and not strings, and can't change, or don't want to change, your [view]model.

<Image>

    <Image.Source>

        <BitmapImage UriSource="{Binding Image}" />

    </Image.Source>

</Image>

The team is aware of this difference, and have it in their backlog of things to prioritize for future revs. In case you're sharing markup or anything between WinRT XAML and Silverlight, it's good to know this more verbose approach works in both.

Slides

• Attached to this post

Demos

It was all real-time stuff in this talk. No downloadable demos. I encourage you to use the Getting Started content on MSDN:

• Build your first Silverlight web application
• Build your first desktop RIA application with Silverlight

Both include downloadable code in both C# and Visual Basic.

My Silverlight Book

• Silverlight 5 in Action
• I also have a Windows 8 XAML book in progress. More on that when it gets closer to publication

Related Links

• Home: Silverlight.NET
• Windows Dev Center (for Windows 8 Metro XAML)
• The Official Microsoft WPF and Windows Forms Site

This talk shows how to share code between different versions of the framework, how to use the ASP.NET Web API from Silverlight, and how to integrate a Silverlight application into an MVC 4 site.

Powerpoint Slides

• Attached to this post

Demos and Examples

• Download the full source and my demo snippit text file here.

My Book

I cover this in my Silverlight 5 book. At the time of this writing, the MEAP has the MVC3 version. I'll update it for the print and ebook shortly.

• Silverlight 5 in Action

Related Links

• ASP.NET MVC 4 Beta Released! - Jon Galloway
• Web API: The Official Microsoft ASP.NET Site
• Creating a Silverlight 5 Helper for ASP.NET MVC3 Razor
• One ASP.NET - Making JSON Web APIs with ASP.NET MVC 4 Beta and ASP.NET Web API - Scott Hanselman
• WCF Community Site (for older WCF version)

Previous Versions

• Slides and Code from my VSLive Silverlight 5, REST, WCF Web API, MVC talk (MVC 3 version)

Powerpoint Slides

• Attached to this post

Demos and Examples

• The Big List of What's New or Improved in Silverlight 5 - Pete Brown's 10rem.net
• Threading Considerations for Binding and Change Notification in Silverlight 5
• Creating Big Silverlight Windows and Getting Monitor Resolutions and Positions with PInvoke
• Silverlight 5: Using the SoundEffect Class for Low-Latency Sound (and play WAV files in Silverlight)
• Silverlight 5: Working with Operating System Windows
• Silverlight 5: Working with Implicit Templates
• Silverlight 5: Debugging Bindings with Xaml Breakpoints
• Silverlight 5: Supporting Double and Even Triple Click for the Mouse
• • Supporting both Double and Triple Click in Silverlight 5 (article with the timer approach)
• Silverlight 5: Advancements in Text

My Book

• Silverlight 5 in Action

Downloads

• Download the 3D House Builder Demo Application
• See the Babylon 3d Engine on CodePlex

Related Links

• Silverlight 5 Page on Silverlight.net
• Announcing the Silverlight 5 Beta Release and the Silverlight.net Redesign

Previous Versions

• Slides, Videos, and Downloads from my Tech Ed Atlanta 2011 and Recent User Group Talks
• Updated Slides and Demos from VSLive Redmond 2011

Note that I've started breaking the Netduino, Electronics, Robotics, Synthesizer and similar content into a new roundup series called the Maker Geek Roundup.

Oh and you'll get Windows 8 Consumer Preview on February 29. Get ready to code (and design) :)

Windows 8 and WinRT/Metro General

• Improving power efficiency for applications (Sharif Farag and Ben Srour)

XAML Technologies (Silverlight, WPF, WinRT Metro XAML)

• Bad Entropy: MVVM and Multiple Selection - Part IV - DataGrid (Bad Entropy)
• Overwriting the default WebRequest used by WebClient (Morten Nielsen)
• Building A Multi-Touch Photo Viewer Control (Morten Nielsen)
• DOT NET TRICKS: Optimizing INPC Objects against memory leaks using WeakEvents (Abhishek Sur)
• • Also see my post on weak events.
• Using the Live SDK in Windows 8 XAML/C# Metro Applications - Michael Crump (Michael Crump)
• Reading and Writing text files in Windows 8 Metro (Morten Nielsen)
• A Simple Pattern for Creating Re-useable UserControls in WPF / Silverlight (Colin Eberhardt)

DirectX Technologies (DirectX, XNA, WinRT DirectX, GPU and Game Programming)

• The Starter2D and Starter3D tutorials now on the Marketplace (Dark Genesis)
• Large Scale Terrain Rendering (Coding4Fun)

C++ and Native Development

• C# to C++ - A Somewhat Short Guide (Bob Taco Industries)
• C++11 Conformance Survey (Vikas Bhatia)
• The Microsoft C++ Compiler Turns 20! (Visual C++ Blog)
• C++ AMP Open Specification (Soma)
• GoingNative 2012: All Sessions are now available On-Demand! (Channel 9)

Visual Studio and .NET General

• Bring Some Game To Your Code! (Visual Studio Blog)

NUI (Kinect, Surface, More)

• Kinect for Windows - Details of API Changes from Beta2 to v1.0 (C#/VB) (Rob Relyea)
• Microsoft® Surface® 2.0 SDK and Runtime Update (Luis Cabrera)
• Interactive Portfolio (Kinect Hacks)

Off-Topic Fun

• The Karate Rap (YouTube)

I leave you with only the one "off-topic" item today, because after watching that, nothing else will ever suffice. Ever.

Hi all -- I'm wondering if there is a maximum window size for Silverlight documented anywhere. For example if I had hardware that could support a 3x3 or 3x4 grid of 1920x1080 displays, can I make an SL5 OOB window that big? Can I make individual items in the window that big? Can I get hardware acceleration on all of it? Does the 3D API have any different limits than XAML? Or maybe Silverlight has no specific limit, but it's up to the hardware?

Curious about that, I decided to try it myself, and combine this with what Tom had requested. I don't have a 3x3 array of screens that size, however. It really is a serious number of pixels.

Cost of screens aside, most people don't have the video hardware to be able to run 6 displays. ATI has some displayport cards which will do that, but otherwise you're looking at a minimum of three video cards and a variety of connections. You're also looking at a shedload of video memory.

What I do have is a pair of 30" displays each running at 2560x1600. That's quite a bit smaller, but still much larger than most people have. It ends up being a bit less than half the requested pixels. I do get almost the right width, but the height is lacking.

I wouldn't want 3x3 of the HD res screens (too much bevel) unless they were big old TV-style ones and you were doing relatively low-res graphics. 3x3 of the 2560x1600 though? *drool*

In any case, my two combined are still quite a bit larger than the typical HD res 1920x1080 screen people have, with its 2,073,600 pixels, and is a valid test of creating big windows in Silverlight.

My displays are also oriented a little differently than you may expect:

That means that logical 0,0 is in the middle of the combined display. We'll need to know that for later.

Creating the Window

If you want to learn how to create out-of-browser windows in Silverlight 5, see my post here.

The first test is to see if I can create a window that fits the dimensions of my two screens. All sizes here will be hard-coded.

XAML

<UserControl x:Class="PeteBrown.SilverlightBigWindow.MainPage"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

    mc:Ignorable="d"

    d:DesignHeight="175

             " d:DesignWidth="800">



    <Grid x:Name="LayoutRoot" Background="White">

        <ListBox x:Name="DisplayList"

                 Margin="126,12,12,12">

            <ListBox.ItemTemplate>

                <DataTemplate>

                    <Grid>

                        <Grid.ColumnDefinitions>

                            <ColumnDefinition Width="150" />

                            <ColumnDefinition Width="50" />

                            <ColumnDefinition Width="150" />

                            <ColumnDefinition Width="150" />

                            <ColumnDefinition Width="75" />

                            <ColumnDefinition Width="75" />

                        </Grid.ColumnDefinitions>



                        <TextBlock Grid.Column="0"

                                   Text="{Binding MonitorName}" />

                        <TextBlock Grid.Column="1"

                                   Text="{Binding IsPrimary}" />

                        <TextBlock Grid.Column="2"

                                   Text="{Binding MonitorArea}" />

                        <TextBlock Grid.Column="3"

                                   Text="{Binding WorkArea}" />

                        <TextBlock Grid.Column="4"

                                   Text="{Binding Width}" />

                        <TextBlock Grid.Column="5"

                                   Text="{Binding Height}" />





                    </Grid>

                </DataTemplate>

            </ListBox.ItemTemplate>

        </ListBox>

     

     

        <Button Content="Open Full"

                Height="23"

                HorizontalAlignment="Left"

                Margin="12,12,0,0"

                Name="OpenWindow"

                VerticalAlignment="Top"

                Width="108"

                Click="OpenWindow_Click" />

        <Button Content="Open Primary"

                Height="23"

                HorizontalAlignment="Left"

                Margin="12,41,0,0"

                Name="OpenPrimary"

                VerticalAlignment="Top"

                Width="108"

                Click="OpenPrimary_Click" />

        <Button Content="Open Secondary"

                Height="23"

                HorizontalAlignment="Left"

                Margin="12,70,0,0"

                Name="OpenSecondary"

                VerticalAlignment="Top"

                Width="108"

                Click="OpenSecondary_Click" />

    </Grid>

</UserControl>

C# code

private void OpenWindow_Click(object sender, RoutedEventArgs e)

{

    Window w = new Window();



    w.Width = 5120;

    w.Height = 1600;



    w.Show();

}



private void OpenPrimary_Click(object sender, RoutedEventArgs e)

{

}



private void OpenSecondary_Click(object sender, RoutedEventArgs e)

{

}

This will allow me to click a button and have it open a giant window on the screen. The window has no content, so it'll appear as a plain white empty window.

Run it (remember, must be elevated trust out-of-browser app) and what do you see? No problem. One giant white window which fits across my screen.

The problem is, however, that it starts in the middle of my displays instead of over at the far left. I had to drag it to the far left to get it to take up the whole set of displays. How do we figure out how to position and size the window?

Positioning and Sizing the Window

On my setup, the monitor to the left is all in negative space. So, to move the window to the far left, I need to move it to -2560. Then we can open the window and then tell it to move to the top left, or to take up just a single display.

private void OpenWindow_Click(object sender, RoutedEventArgs e)

{

    Window w = new Window();



    w.Width = 5120;

    w.Height = 1600;



    w.Left = -2560;

    w.Top = 0;

    w.Show();

}



private void OpenPrimary_Click(object sender, RoutedEventArgs e)

{

    Window w = new Window();



    w.Width = 2560;

    w.Height = 1600;





    w.Left = 0;

    w.Top = 0;

    w.Show();

}



private void OpenSecondary_Click(object sender, RoutedEventArgs e)

{

    Window w = new Window();



    w.Width = 2560;

    w.Height = 1600;



    w.WindowStyle = WindowStyle.None;



    w.WindowState = WindowState.Maximized;



    w.Left = -2560;

    w.Top = 0;

    w.Show();

}

Ok, so we've verified that it can be done. Now we need to make it work for arbitrary resolutions and monitor configurations. Before we do that, though, did you notice that the sizing was off a bit? Both the width and height appear to be off by the measurements of the window chrome. It turns out this happens whether or not you're using custom chrome. I've reported a bug to the team and they're investigating, so for now we're going to have to ignore the size issues. If you work around the sizing in your own code, stick it in an conditional compilation block or something so you can easily change it if/when the bug is fixed.

Getting Display Informatin Using PInvoke

We're running in elevated OOB mode anyway, so as long as you only care about Windows, you can also throw in some P/Invoke. The main functions we're interested in are EnumDisplayMonitors and GetMonitorInfo.

The PInvoke.net example was enough to get me started, but it lacked a few necessary steps. Of course, it also needed some changes to work with Silverlight.

The first addition is the DisplayInfo class. We'll use this to hold information about a single monitor.

namespace PeteBrown.SilverlightBigWindow

{

    public class DisplayInfo

    {

        public string MonitorName { get; internal set; }

        public Win32Rect MonitorArea { get; internal set; }

        public Win32Rect WorkArea { get; internal set; }

        public int Width { get; internal set; }

        public int Height { get; internal set; }

        public bool IsPrimary { get; internal set; }

    }

}

Next, I need a way to populate this class. Here's where all the PInvoke action happens.

using System;

using System.Runtime.InteropServices;

using System.Collections.ObjectModel;



namespace PeteBrown.SilverlightBigWindow

{



    [StructLayout(LayoutKind.Sequential)]

    public struct Win32Rect

    {

        public int Left { get; set; }

        public int Top { get; set; }

        public int Right { get; set; }

        public int Bottom { get; set; }



        public override string ToString()

        {

            return string.Format("{0}, {1}, {2}, {3}", Left, Top, Right, Bottom);

        }

    }



    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]

    internal struct MonitorInfoEx

    {

        public int Size;

        public Win32Rect Monitor;

        public Win32Rect WorkArea;

        public uint Flags;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = DisplayManager.DeviceNameCharacterCount)]

        public string DeviceName;



        public void Init()

        {

            this.Size = 40 + 2 * DisplayManager.DeviceNameCharacterCount;

            this.DeviceName = string.Empty;

        }

    }



 

    public class DisplayManager

    {

        // size of a device name string

        internal const int DeviceNameCharacterCount = 32;





        private delegate bool MonitorEnumProcDelegate(IntPtr hMonitor, IntPtr hdcMonitor, ref Win32Rect lprcMonitor, uint dwData);



        [DllImport("user32.dll")]

        private static extern bool EnumDisplayMonitors(IntPtr hdc, IntPtr lprcClip, MonitorEnumProcDelegate lpfnEnum, uint dwData);



        [DllImport("user32.dll", CharSet = CharSet.Auto)]

        private static extern bool GetMonitorInfo(IntPtr hMonitor, ref MonitorInfoEx lpmi);



        private static ObservableCollection<DisplayInfo> _displays = new ObservableCollection<DisplayInfo>();

        public static ObservableCollection<DisplayInfo> Displays

        {

            get { return _displays; }

        }





        public static void LoadDisplays()

        {

            EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, MonitorEnumProc, 0);

        }



        [AllowReversePInvokeCalls]

        internal static bool MonitorEnumProc(IntPtr hMonitor, IntPtr hdcMonitor, ref Win32Rect lprcMonitor, uint dwData)

        {

            var monitor = new MonitorInfoEx();

            monitor.Init();



            bool success = GetMonitorInfo(hMonitor, ref monitor);



            if (success)

            {

                var display = new DisplayInfo();



                display.MonitorName = monitor.DeviceName;



                display.Width = monitor.Monitor.Right - monitor.Monitor.Left;

                display.Height = monitor.Monitor.Bottom - monitor.Monitor.Top;



                display.MonitorArea = monitor.Monitor;

                display.WorkArea = monitor.WorkArea;

                display.IsPrimary = (monitor.Flags > 0);



                _displays.Add(display);

            }



            return true;

        }

    }

}

This code calls EnumDisplayMonitors to enumerate the monitors on the system. For each monitor found, I then call GetMonitorInfo to pull back the details. From that call, I create a DisplayInfo class and populate it, ready to be used by the rest of the Silverlight application. The list of DisplayInfo classes is stored in a class-scope collection.

Note the "AllowReversePInvokeCalls" attribute on MonitorEnumProc. That attribute is required for any callbacks. It also means we couldn't use a simple anonymous delegate for the callback, as those can't have attributes.

Finally, a short call in MainPage.xaml and we're able to get the display sizes

public MainPage()

{

    InitializeComponent();



    DisplayManager.LoadDisplays();



    DisplayList.ItemsSource = DisplayManager.Displays;

}

Run the application. On my screen, it looks like this:

Ok, so now we know how to position a display using hard-coded values, and how to get the display list from windows. Now, to combine the two to help with sizing and positioning.

Positioning and Sizing the Window

Positioning the window can be tricky. There are any number of ways that monitors can be configured. Here are just a few interesting (and common) ones, in addition to the ones mentioned above:

If you look at the teal and the green examples, you can see where a rectangular pixel mapping puts some logical pixels out into never-never land. On systems like that, a single window spanning all displays is not particularly practical. In any case, most multi-display configurations are two, or at most, three displays because that's all you can typically drive from a single typical video card.

As an aside, I've run with all four examples shown above, plus a few extras. My current layout is 2x 30" displays side by side with primary on right and secondary on left, plus a 23" display on top of the primary. The 23" display is connected to a different computer, however, and shared using Input Director, so it doesn't factor into this discussion.

With just the two displays I have, it's easy to test a number of different scenarios simply by changing resolution and monitor position in display settings. First, some code to position the window on a specific screen.

Position Window on Primary Display

A PC can have only one primary display. Conveniently, the display is called out as such via the API.

private void PositionWindowOnSingleScreen(DisplayInfo screen, Window window, bool SizeToScreen = true, bool maximize = false)

{

    window.Left = screen.MonitorArea.Left;

    window.Top = screen.MonitorArea.Top;



    if (SizeToScreen)

    {

        window.Width = screen.Width;

        window.Height = screen.Height;

    }



    if (maximize)

        window.WindowState = WindowState.Maximized;

}





private void OpenPrimary_Click(object sender, RoutedEventArgs e)

{

    if (DisplayManager.Displays.Count > 0)

    {

        // find primary display

        DisplayInfo info = (from DisplayInfo di in DisplayManager.Displays

                            where di.IsPrimary

                            select di).FirstOrDefault();



        if (info != null)

        {

            Window w = new Window();



            PositionWindowOnSingleScreen(info, w, true, false);



            w.Show();

        }

        else

        {

            MessageBox.Show("No primary display. I suppose you won't see this message.");

        }

    }

    else

    {

        MessageBox.Show("Display list not yet loaded.");

    }



}

This example uses a little LINQ to find the primary screen and then a separate function to position the window on that screen. I can't think of a case where you'd have no primary display, but I check for it anyway.

Position Window on Secondary Display

Primary is cool. You can do that without any API calls. Secondary is normally a little more work, but I have you covered.

You can, of course, have more than one secondary display. In my case, I have only one, so I'm going to position this window in the first secondary display I have.

private void OpenSecondary_Click(object sender, RoutedEventArgs e)

{

    if (DisplayManager.Displays.Count > 0)

    {

        // find first secondary display

        DisplayInfo info = (from DisplayInfo di in DisplayManager.Displays

                            where !di.IsPrimary

                            select di).FirstOrDefault();



        if (info != null)

        {

            Window w = new Window();



            PositionWindowOnSingleScreen(info, w, true, false);



            w.Show();

        }

        else

        {

            MessageBox.Show("No secondary display available.");

        }

    }

    else

    {

        MessageBox.Show("Display list not yet loaded.");

    }

}

In this case, all I needed to change was the error message and add a little bang in the where clause of the LINQ query.

Make a window take up all Display Space

This goes specifically to the 3x3 screen scenario. As I mentioned, we'll need to assume rectangular window space here, as anything else is going to be pretty application-specific.

private void OpenWindow_Click(object sender, RoutedEventArgs e)

{

    if (DisplayManager.Displays.Count > 0)

    {

        Window w = new Window();



        w.Left = (from DisplayInfo di in DisplayManager.Displays

                  select di.MonitorArea.Left).Min();



        w.Top = (from DisplayInfo di in DisplayManager.Displays

                 select di.MonitorArea.Top).Min();



        w.Width = (from DisplayInfo di in DisplayManager.Displays

                   select di.Width).Sum();



        w.Height = (from DisplayInfo di in DisplayManager.Displays

                    select di.Height).Sum();



        w.Show();

    }

    else

    {

        MessageBox.Show("Display list not yet loaded.");

    }

}

Because we're assuming a reasonably logical rectangle, I can simply take the minimum left and top values and use that to position the window, and then sum the height and width values in order to size the window.

As an aside, Silverlight had no issues opening this window on my machine. I'm not sure I'd recommend stretching a video across it, though.

Well, actually, I can't let that lie out there like that. Let's try it. Add this code right after the w.Height setting and before the w.Show() line

MediaElement video = new MediaElement();

video.Width = w.Width;

video.Height = w.Height;

video.Source = new Uri("/pub/sl5iA/NetduinoRobot_SmallM.wmv", UriKind.Absolute);

video.Stretch = Stretch.UniformToFill;

video.AutoPlay = true;



w.Content = video;

I stretch the video so it takes up all space (UniformToFill) and clips the video so the aspect ratio stays correct. It works, and works well, If the the video was high enough resolution, it would even look good.

Sweet! Big video. That's almost like IMax or UHDTV :)

Position Main Window on a Named Display

This is particularly useful if you're restoring windows when starting up a new session. You could store the display device name and then do some checks on startup and if the device name and resolution are still valid (they could have swapped displays, bought new ones, got rid of one, etc.) position the window on that display. If not, position it on the main display.

In this case, I'm simply going to position the main Silverlight window on to the display you click on in the ListBox. The code is simple enough. First, add a button to the MainPage, under the other buttons.

<Button Content="Move to Selected"

        Height="23"

        HorizontalAlignment="Left"

        Margin="12,115,0,0"

        Name="MoveToSelectedButton"

        VerticalAlignment="Top"

        Width="108"

        Click="MoveToSelectedButton_Click" />

Next, the event handler and work function in the code-behind. There are many ways I could have done this (especially using SelectedItem), but I specifically want to show using the device name. I know it's extra work, but I'm doing it on-purpose; the value you store upon exiting is not going to be an object instance, it's going to be a screen device name string.

private void MoveMainWindowToSelectedDisplay()

{

    // see comments in blog post as to why I went with strings

    string deviceName = ((DisplayInfo)DisplayList.SelectedItem).MonitorName;



    DisplayInfo display = (from DisplayInfo di in DisplayManager.Displays

                            where di.MonitorName.ToLower() == deviceName.ToLower()

                            select di).FirstOrDefault();



    var mainWindow = Application.Current.MainWindow;



    // center on the display



    mainWindow.Left = display.MonitorArea.Left + (display.Width - mainWindow.Width) / 2;

    mainWindow.Top = display.MonitorArea.Top + (display.Height - mainWindow.Height) / 2;



}



private void MoveToSelectedButton_Click(object sender, RoutedEventArgs e)

{

    if (DisplayList.SelectedItem != null)

    {

        MoveMainWindowToSelectedDisplay();

    }

    else

    {

        MessageBox.Show("Please select a screen from the list");

    }

}

The code moves the window to the selected monitor and then centers in that monitor. Some additional checking to make sure the window isn't wider than that monitor would be a good idea.

Summary

The intent of this post was to give you the foundation you'll need in order to do window manipulation in Silverlight. Once you start doing multi-monitor window manipulation, you probably have a good idea of what you want to do with it. I'll leave it up to you to take this code and run with it to suit your specific application needs.

I went back to the latest version of the Frodo C64 emulator source code and decided to port some of their changes over to this version. Frodo is written in C and C++, and makes very heavy use of pointers (and not always safe use of them, as there was at least one logical overrun). In the previous version, I had replaced pointers with array manipulation, but I did it in a way that resulted in an awful lot of array copies floating around. The arrays were small, so this wasn't a big deal memory-wise, but the copies all took time in an otherwise time-critical application.

Silverlight doesn't support pointers or unsafe code. Of course, in elevated trust mode, with a not-really-supported hack, you can have pointers in Silverlight. However, I wanted to stay away from that for now as it only works in Silverlight 5, only on Windows, and won't port to any other sandboxed XAML platforms.

So, I decided to finish what I started and build out some decent almost-pointerish safe analogs in Silverlight. It was a fairly large amount of effort, but I thought it might also be interesting to read about here.

How Pointers Work

If you've never written any C/C++ code, there's a better than zero chance that you haven't done any explicit pointer manipulation in your own code. That's not a bad thing, really, as the typical business application (and many other types) simply doesn't need to do pointer arithmetic. It's not worth the inherent danger for the small performance increase. That said, an understanding of how pointers work is  fundamental computer science, and is important for all developers to know.

It's only when you have to do a lot of memory walking in a performance-critical application that you run into this. Programming for microcontrollers like the AVR is a great way to refresh your memory as to how pointers work and what they bring to the table.

A pointer is an address in memory and an associated type size. For example, if we have some fictional 6 byte memory chunk and declare a pointer to a byte, we end up with something like this (bonus points if you can figure out the significance of the 5 bytes starting at 0x01):

In this case, our byte pointer points to the 8 bits starting at the address 0x01. You can then manipulate memory using pointer arithmetic:

byte* p = 0x01;    // declare pointer to memory address 0x01



*p = 0x30;         // changes value at 0x01 to 0x30 from 0x78



*(p+3) = 0x00;     // changes value at 0x04 to 0x00 from 0x7A



while (p < 0x06)   // clear rest of memory

  *p++ = 0x00;

This is very fast because there really is no indirection. You're telling the compiler exactly what address to manipulate - it doesn't have to look anything up.

The size of the pointer variable has to do with the architecture of the system and its addressing scheme (8 bit, 16 bit, 32 bit, 64 bit), as well as compiler options you select. (In the case of the Commodore 64, it's all 8 bit.).

You're not limited to the smallest memory unit size, though. If you wanted to declare a pointer to a 16 bit integer, you'd get this (assuming "short" is 16 bits on your system):

Now, depending on the endian-ness of your system, the resulting 16 bit number may be 0x7879 (big endian) or 0x7978 (little endian).

It starts to get really powerful when you consider that a pointer to a structure could also be considered a pointer to a number of bytes. That allows you to, for example, read a bunch of bytes from a disk, look at the first couple bytes to figure out what you have, and then cast the remaining X bytes as the pointer a directory structure or something. The original C++ C64 emulator code does a ton of that.

How pointers are used in Frodo

In addition to pointers to structures in byte buffers, frodo does a lot of string parsing using pointers. In particular, the 1541 drive emulation code uses this for command parsing. In that code, the first character is often some command identifier, the next is a delimiter (like a colon) and then some number of comma-separated values.

In our normal pointer-less code, we'd typically parse the string and then make copies for each of the individual components. Another way to deal with it is to simply provide pointers to each of the sections therefore avoiding making copies of memory. That's typically how the Frodo code works.

In my first version of the code, I used array indexes to simulate this. However, that code got incredibly nasty to work with. I needed another solution.

The Simulated Pointer

You can simulate pointers by simply passing around arrays, making copies, or even using array indexes. But, as I mentioned, that code tends to get pretty messy as you have lots of dependent variables. Instead, I needed a way to encapsulate all of this and provide pointer-like functionality to handle the majority of the cases.

• The primary goal of this effort is to make it easy to have code which is close to 1:1 with its C++ counterparts. For example, if the C++ code increments a pointer and then assigns a value, I want to be able to do something similar without having to worry about which array the pointer points to, or what index value is. The code won't be 1:1, but I want it as close as possible.
• Another goal of this effort is to minimize the number of times I copy arrays around. Primarily this is for performance reasons as the emulator code needs to loop at least one million times a second (1MHz). Minimizing array copies and object instances helps keep GC under control as well.
• A non-goal of this effort is efficient use of actual memory. In fact, my pointer structures use more memory than a pointer just to simulate a pointer. I'm ok with that.
• Another non-goal is the ability to cast a pointer to a structure or other complex type. I'd love to do that, but that's not sandbox-friendly and it's not going to happen that way in this code.

The C64 code has a number of places where it has memory allocated in chunks. The most obvious is the main memory of the system (64K), but there's also 2K in the VIC-1541 drive. Beyond those, there are several chunks of ROM code which get loaded up and then mapped into various address locations (cartridges too). In the emulator code, these are just large arrays of bytes.

If you ever had to simulate an operating system in college, you've done this before.

Here's an example of two pointers "A" and "B". Pointer A points to address 0x01 in the memory array. Pointer B points to address 0x05.

The code to create these looks something like this:

SystemRam ram = new SystemRam();



var a = new RamBytePointer(ram, 0x00);

var b = new RamBytePointer(ram, 0x05);

The RamBytePointer structure represents the pointer. It has a member Value which can be used to get/set the value at that position. It also has a number of other helper methods to do things like copy values from arrays, comparisons with other pointers, etc. Note that the pointer structure takes a reference to the memory it is allowed to manipulate. A real pointer has pretty much free run of memory, so you need to keep the RAM pretty broadly defined if you need that flexibility.

Here's the current version of the structure. It doesn't do quite everything I want yet (for example, nothing with comparisons between pointers, for example), but it does a fair bit.

using System.Diagnostics;

using System.Text;

using System;



namespace PeteBrown.C64.Core.Memory

{

    public struct RamBytePointer

    {

        public RamBytePointer(RamBase memory, int address)

            : this(memory)

        {

            _address = address;

        }



        public RamBytePointer(RamBase memory)

        {

            _memory = memory;

            _address = 0;

        }





        private RamBase _memory;

        private RamBase Memory

        {

            [DebuggerStepThrough]

            get { return _memory; }

            [DebuggerStepThrough]

            set { _memory = value; }

        }



        private int _address;

        public int Address

        {

            [DebuggerStepThrough]

            get { return _address; }

            [DebuggerStepThrough]

            set { _address = value; }

        }



        public byte this[int offset]

        {

            [DebuggerStepThrough]

            get { return _memory[_address + offset]; }

            [DebuggerStepThrough]

            set { _memory[_address + offset] = value; }

        }



        public byte Value

        {

            [DebuggerStepThrough]

            get { return _memory[_address]; }

            [DebuggerStepThrough]

            set { _memory[_address] = value; }

        }



        public byte[] GetValues(int length)

        {

            return _memory.Read(_address, length);

        }



        public void SetValues(byte[] values)

        {

            _memory.Write(_address, values);

        }





        public void CopyFrom(byte[] values, bool incrementPointer)

        {

            for (int i = 0; i < values.Length; i++)

            {

                _memory[_address + i] = values[i];

            }



            if (incrementPointer)

                _address += values.Length;

        }



        public void CopyFrom(char[] characters, bool incrementPointer)

        {

            for (int i = 0; i < characters.Length; i++)

            {

                _memory[_address + i] = (byte)characters[i];

            }



            if (incrementPointer)

                _address += characters.Length;

        }



        public void CopyFrom(string characters, bool incrementPointer)

        {

            for (int i = 0; i < characters.Length; i++)

            {

                _memory[_address + i] = (byte)characters[i];

            }



            if (incrementPointer)

                _address += characters.Length;

        }



        public RamBytePointer NewPointerAtOffset(int offset)

        {

            return new RamBytePointer(_memory, _address + offset);

        }





        public static RamBytePointer operator +(RamBytePointer p, int offset)

        {

            return new RamBytePointer(p.Memory, p.Address + offset);

        }





        public static RamBytePointer operator -(RamBytePointer p, int offset)

        {

            return new RamBytePointer(p.Memory, p.Address - offset);

        }





        public static RamBytePointer operator ++(RamBytePointer p)

        {

            p.Address += 1;



            return p;

        }



        public static RamBytePointer operator --(RamBytePointer p)

        {

            p.Address -= 1;



            return p;

        }





        public int IndexOf(byte value, int count)

        {

            return _memory.IndexOf(value, 0, count);

        }



        public int IndexOf(char value, int count)

        {

            return _memory.IndexOf(value, 0, count);

        }



        public bool Contains(char value, int count)

        {

            return _memory.Contains(value, 0, count);

        }



        public bool Contains(byte value, int count)

        {

            return _memory.Contains(value, 0, count);

        }





        public string ToString(int startIndex, int length)

        {

            StringBuilder builder = new StringBuilder();



            for (int i = startIndex; i < length; i++)

            {

                builder.Append((char)_memory[i]);

            }



            return builder.ToString();

        }



    }

}

The memory array itself is always created and maintained outside of this class. It must be valid when the pointer is created.

Operator overloading and Offsets

Of interest is the operator overloading. This allows me to do things like p++ or p += 1 in order to modify the address that the pointer is pointing to. That's an important part of keeping the C# code as similar as possible to the C++ code. However, it doesn't allow everything the C++ code allows. For example, I can't do the exact equivalent of this code:

*(p + 5) = 0x05;

*(p - 7) = 0x0A;

If I try to do the equivalent of that, the compiler will barf at me as it needs an actual LValue on the left side. Instead, code like that must use something like this:

p[5] = 0x05;

p[-7] = 0x0A;

The code is similar enough that I'm happy with it, although developers new to the code may raise a few eyebrows at the p[-7] version.

Converting Strings

Because much of the C++ code treats characters and bytes as interchangeable (something you can't really do with arrays in C# on Windows), I also have a few overloads that can take characters or bytes. This helps clean up the consuming code so it doesn't have so many casts.

I have helper functions in there to copy from strings. This helps me easily translate code such as this:

*p++ = 'B';

*p++ = 'L';

*p++ = 'O';

*p++ = 'C';

*p++ = 'K';

*p++ = 'S';

*p++ = ' ';

*p++ = 'F';

*p++ = 'R';

*p++ = 'E';

*p++ = 'E';

*p++ = '.';

Into a nice single-liner like p.CopyFrom("BLOCKS FREE.", true);

A Structure, not a Class

Note that this is a structure, not a class. Why? Having it as a structure lets me make copies easily. It's common practice in C/C++ code to have a pointer passed into a function, and then make a copy of it to increment yourself. For example:

void DoSomething (byte * baseAddress)

{

    byte * p = baseAddress;



    while (p++ != 0x0A)

        ...

}

In this example C++ function, p starts off at the same address as "baseAddress", but then increments it. The value for baseAddress must be left alone.

Reference types like class in C# are themselves pointers. So, due to the level of indirection this has, we'd end up modifying the original value:

class RamBytePointer { ... }



void DoSomething (RamBytePointer baseAddress)

{

    RamBytePointer p = baseAddress;



    p += 5;



    Debug.WriteLine(p.Address);

    Debug.WriteLine(baseAddress.Address);

}



// ---------------------------------------



struct RamBytePointer { ... }



void DoSomething (RamBytePointer baseAddress)

{

    RamBytePointer p = baseAddress;



    p += 5;



    Debug.WriteLine(p.Address);

    Debug.WriteLine(baseAddress.Address);

}

The first example doesn't work like pointers in C++ at all. Incrementing p also increments baseAddress. The second example, however, works as we would expect because p is a copy of baseAddress, not a reference to it.

The downside of using a struct is there's no inheritance. So, I instead put a fair bit of the potentially reusable code into the memory classes instead, and simply call that from the pointer class.

Summary

Simulating pointers in pointer-free sandboxed platforms is a bit unorthodox, but can make translating code easier.

This isn't something you're likely to need to do in your own code, but it an interesting exercise in any case. There's no downloadable source code yet, as I'm still refining this implementation. You'll be able to get a version of these classes in the SilverlightC64 code when I post it in the next week or less. It's taking longer to swap out all this code than I had intended :)

If you've ever had to do anything like this in your own code, I'd love to hear about it.

Note that I've started breaking the Netduino, Electronics, Robotics, Synthesizer and similar content into a new roundup series called the Maker Geek Roundup.

Shout-Outs

• Give us your feedback on Visual Studio 11 etc. and receive a gift! (Visual Studio Blog)

Windows 8 and WinRT/Metro General

• Windows 8 - First Apps Contest (Dave Isbitski)
• When Metro design falls off the tracks (Kelly Sommers)
• SharpGIS | Make your Windows 8 Video App use the PlayTo feature (Morten Nielsen)

XAML Technologies (Silverlight, WPF, WinRT Metro XAML)

• "Physamajig" for Windows 8 (Andy Beaulieu)
• Building an Augmented Reality XAML control (Morten Nielsen)

WinJS / JavaScript and HTML Applications for Windows Metro

• Setting up your first use of the Animation library in WinJS (Adam Kinney)
• No Alert in WinJS! Use console or MessageDialog instead (Adam Kinney)

Direct X Technologies (DirectX, XNA, WinRT DirectX, General GPU and Game Programming)

• Getting started with Metro style DirectX (Bob Taco Industries)
• XNA 4.0 Shader Programming #1-Intro to HLSL, Ambient light (digitalerr0r)
• XNA 4.0 Shader Programming #2-Diffuse light (digitalerr0r)
• XNA 4.0 Shader Programming #3-Specular light (digitalerr0r)

C++ and Native Development

• Compiler Security Enhancements in Visual Studio 11 (SDL Team)

Visual Studio and .NET General

• Visual Studio 11 Platform Tooling Advances (Soma)
• • Good DirectX content in this one as well
• ManagedMsiExec sample app shows how to use the Windows Installer API from managed code (David Anson)

NUI (Kinect, Surface, More)

• Microsoft Kinect coming to Windows on February 1st, up for pre-order now! (KinectHacks)
• Kinect Apps - ensuring Kinect Runtime is installed (Rob Relyea)
• Examples of depth API improvements coming in v1 (Rob Relyea)
• Kinect + 3D = Fusion4D (Greg Duncan)
• Connecting your Netduino to your Kinect (Greg Duncan)
• Kinect Fundamentals #4: Implementing Skeletal Tracking | digitalerr0r (digitalerr0r)
• Kinect & HTML5 using WebSockets and Canvas (Vangos Pterneas)

Off-Topic Fun

• Poorly Drawn Lines - When It's Cold (for all the ADD types)
• xkcd: Game AIs (xkcd)
• Benoit Mandelbrot: Master of seduction (SMBC)
• • and Saturday Morning Breakfast Cereal 
  • and Saturday Morning Breakfast Cereal 
• Grammar! (SMBC)
• Lego Skeleton inside Mini Figure (for the purists) (MoistProduction)

Background

The user interface in Silverlight runs on a thread commonly known as the UI Thread. Any code you create in the code-behind, and any code it calls all the way down the chain, unless it explicitly creates another thread, runs on this same UI thread. It's not at all uncommon to see Silverlight and WPF applications which never explicitly create a second thread, but do make calls to other services which create background threads for processing.

There are many other examples, but networking is one place where the Silverlight .NET Framework explicitly creates (or uses) different threads. Not all calls return on the UI thread.

Threads other than the UI thread are not allowed to access or manipulate UI objects. If they attempt to do so, the runtime throws an Invalid Cross-Thread Access exception. It looks like this:

But wait! I wasn't accessing any UI objects from my code. What gives?

It's not always obvious that you're interacting with UI objects on the UI thread, though. Here's the stack trace from this particular exception:

{System.Reflection.TargetInvocationException: Exception has been thrown by the target of an invocation. --->

  System.UnauthorizedAccessException: Invalid cross-thread access.

   at MS.Internal.XcpImports.CheckThread()

   at MS.Internal.XcpImports.GetValue(IManagedPeerBase managedPeer, DependencyProperty property)

   at System.Windows.DependencyObject.GetOldValue(DependencyProperty property, EffectiveValueEntry& oldEntry)

   at System.Windows.DependencyObject.UpdateEffectiveValue(DependencyProperty property, EffectiveValueEntry oldEntry, EffectiveValueEntry& newEntry, ValueOperation operation)

   at System.Windows.DependencyObject.RefreshExpression(DependencyProperty dp)

   at System.Windows.Data.BindingExpression.SendDataToTarget()

   at System.Windows.Data.BindingExpression.SourcePropertyChanged(PropertyPathListener sender, PropertyPathChangedEventArgs args)

   at System.Windows.PropertyPathListener.ReconnectPath()

   at System.Windows.Data.Debugging.BindingBreakPoint.<>c__DisplayClass4.<BreakOnSharedType>b__3()

   --- End of inner exception stack trace ---

   at System.RuntimeMethodHandle.InvokeMethod(Object target, Object[] arguments, Signature sig, Boolean constructor)

   at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture, Boolean skipVisibilityChecks)

   at System.Delegate.DynamicInvokeImpl(Object[] args)

   at System.Delegate.DynamicInvoke(Object[] args)

   at MainPagexaml.BindingOperation(Object BindingState, Int32 , Action )}

This stack trace was generated by trying to raise a PropertyChangedNotification when I manipulated a model object from a background thread. So, it was obvious that I was working with an object on the background thread, but it wasn't obvious that I'd get a cross-thread exception (well it was in this case, as I contrived the example). If you consider a larger application where you have division of ownership for different pieces, a client-side developer may simply work with your viewmodel, but not realize you're farming some work out to another thread.

I wrote a blog post back in 2010 ( Essential Silverlight and WPF Skills: The UI Thread, Dispatchers, Background Workers and Async Network Programming) explaining some of the ways to work with threads and dispatching. I didn't have SynchronizationContext in there at the time, but it's something I tend to use a lot these days.

Let's take a look at a few of the common scenarios and how it works with threading.

Common Scenarios

All of these scenarios make use of a simple Customer class with a single property:

namespace SilverlightThreadingExample.Model

{

    public class Customer : Observable

    {

        private string _firstName;

        public string FirstName

        {

            get { return _firstName; }

            set { _firstName = value; NotifyPropertyChanged("FirstName"); }

        }

    }

}

The customer is observable that is, it notifies any listeners when properties change. While not necessary, I encapsulated the observable code in this base class. You could, instead, put the implementation in a partial class if you wanted to make sure your model object's signature from your ORM or whatever remains the same as it was on the server.

using System.ComponentModel;



namespace SilverlightThreadingExample

{

    public class Observable : INotifyPropertyChanged

    {

        public event PropertyChangedEventHandler PropertyChanged;



        protected void NotifyPropertyChanged(string propertyName)

        {

            if (PropertyChanged != null)

                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

        }

    }

}

This is actually a pretty typical approach to handling INotifyPropertyChanged. There are even more robust versions out there which use lambdas and reflection to help avoid passing in strings, but they ultimately come down to raising the PropertyChanged event. Many of them also fail to work properly in cross-thread situations.

I expose the Customer class and a collection of customers from a ViewModel class.

namespace SilverlightThreadingExample.ViewModel

{

    public class CustomerEntryViewModel : Observable

    {

        private Customer _currentCustomer;

        public Customer CurrentCustomer

        {

            get { return _currentCustomer; }

            set { _currentCustomer = value; NotifyPropertyChanged("CurrentCustomer"); }

        }



        private ObservableCollection<Customer> _customers = new ObservableCollection<Customer>();

        public ObservableCollection<Customer> Customers

        {

            get { return _customers; }

        }



        public void LoadCustomersOnSameThread()

        {

            LoadDummyData();

        }



        private void LoadDummyData()

        {

            _customers.Add(new Customer() { FirstName = "Pete" });

            _customers.Add(new Customer() { FirstName = "Jon" });

            _customers.Add(new Customer() { FirstName = "Tim" });

            _customers.Add(new Customer() { FirstName = "Scott" });

            _customers.Add(new Customer() { FirstName = "Andy" });

            _customers.Add(new Customer() { FirstName = "Blaine" });

            _customers.Add(new Customer() { FirstName = "Jesse" });

            _customers.Add(new Customer() { FirstName = "Rey" });



            _currentCustomer = _customers[0];

        }



    }

}

Finally, the UI is bound to those classes. The DataContext for the UI (which will be set in code-behind) is the ViewModel.

<UserControl x:Class="SilverlightThreadingExample.MainPage"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

    mc:Ignorable="d"

    d:DesignHeight="400" d:DesignWidth="600">



    <Grid x:Name="LayoutRoot" Background="White">

        <Grid Width="500">

            <Grid.ColumnDefinitions>

                <ColumnDefinition Width="*" />

                <ColumnDefinition Width="250" />

            </Grid.ColumnDefinitions>



            <ListBox x:Name="CustomerList"

                     Grid.Column="0" Margin="10"

                     ItemsSource="{Binding Customers}"

                     SelectedItem="{Binding CurrentCustomer, Mode=TwoWay}">

                <ListBox.ItemTemplate>

                    <DataTemplate>

                        <TextBlock Text="{Binding FirstName}" />

                    </DataTemplate>

                </ListBox.ItemTemplate>

            </ListBox>



            <StackPanel Grid.Column="1">

                <TextBox x:Name="FirstNameField" Margin="10"

                         DataContext="{Binding CurrentCustomer}"

                         Text="{Binding FirstName, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />



                <Button x:Name="AddCustomer"

                        Content="Add Customer from UI Thread"

                        Height="30" Margin="5"

                        Click="AddCustomer_Click" />

                <Button x:Name="AddCustomerSecond"

                        Content="Add Customer from Second Thread"

                        Height="30" Margin="5"

                        Click="AddCustomerSecond_Click" />

                <Button x:Name="ChangeNameFromSecondThread"

                        Content="Change Name from Second Thread"

                        Height="30" Margin="5"

                        Click="ChangeNameFromSecondThread_Click" />

            </StackPanel>



        </Grid>

   

    </Grid>

</UserControl>

The code-behind looks like this

using System.Windows;

using System.Windows.Controls;

using SilverlightThreadingExample.ViewModel;

using System.Threading;

using SilverlightThreadingExample.Model;



namespace SilverlightThreadingExample

{

    public partial class MainPage : UserControl

    {

        CustomerEntryViewModel _vm;



        public MainPage()

        {

            InitializeComponent();



            CreateViewModelOnUIThread();

        }





        private void CreateViewModelOnUIThread()

        {

            _vm = new CustomerEntryViewModel();



            _vm.LoadCustomersOnSameThread();



            DataContext = _vm;

        }





        private void AddCustomer_Click(object sender, RoutedEventArgs e)

        {

        }





        private void AddCustomerSecond_Click(object sender, RoutedEventArgs e)

        {

        }





        private void ChangeNameFromSecondThread_Click(object sender, RoutedEventArgs e)

        {

        }





    }

}

The methods are named to keep the context clear in this example. I wouldn't expect you to name your VM instantiation/locator method "CreateViewModelOnUIThread", for example.

Now let's look at those scenarios.

Changing a property value from a background thread

Often in an application, you have a class which is used in UI binding (an entity/model object) but still need to modify a property from code. Sometimes, you need to do that from a background thread. For example, you make a network call to get an updated price for an item. You will get a cross-thread access error when the class raises change notification events from that property setter. If the class is truly POCO (Plan Old CLR Object) and doesn't do any change notification or other event raising, you'll be fine. If, however, change notification is involved, you'll get the cross-thread exception.

Assuming the same Customer and Observable classes defined above, and the same XAML UI, the following code in the code-behind will throw that exception.

private void ChangeNameFromSecondThread_Click(object sender, RoutedEventArgs e)

{

    Thread t = new Thread((o) =>

        {

            _vm.CurrentCustomer.FirstName = "UpdatedFromSecondThread";

        });



    t.Start();

}

The exception doesn't happen when you set the property value; that's perfectly acceptable. It happens here, at the highlighted line:

protected void NotifyPropertyChanged(string propertyName)

{

    if (PropertyChanged != null)

        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

}

So, what are the options for working around this? Let's consider two common approaches.

Approach 1

The first approach is to do the whole property change from the UI thread. To do this, simply wrap the property set code with a call to the dispatcher. You can use either the Dispatcher object, or if you keep a copy of the SynchronizationContext around, use that.

Here's some example code which implements this. The code looks a bit silly because I'm forcing a background thread. However, pretend that the background thread is a given and you need to work from it (again, the callback from a network call or something.)

private void ChangeNameFromSecondThread_Click(object sender, RoutedEventArgs e)

{

    Thread t = new Thread((o) =>

    {

        Deployment.Current.Dispatcher.BeginInvoke(() =>

            {

                _vm.CurrentCustomer.FirstName = "UpdatedFromSecondThread";

            });

    });



    t.Start();

}

This approach works well, but requires the calling code to handle all the dispatching. If you have a number of properties to change in different bits of code, it gets a bit cumbersome. Let's look at another approach.

Approach 2

The real problem is the property change notification, so the the second approach is to dispatch just the change notification to the UI thread.

You can put this code into the Observable base class in order to avoid repeating it throughout all your classes.

// Code-behind

// ----------------------------------------------





// this version throws an exception if the Observable base class isn't doing thread checking

private void ChangeNameFromSecondThread_Click(object sender, RoutedEventArgs e)

{

    Thread t = new Thread((o) =>

        {

            _vm.CurrentCustomer.FirstName = "UpdatedFromSecondThread";

        });



    t.Start();

}





// Observable

// ----------------------------------------------





using System.ComponentModel;

using System.Windows;



namespace SilverlightThreadingExample

{

    public class Observable : INotifyPropertyChanged

    {

        public event PropertyChangedEventHandler PropertyChanged;



        protected void NotifyPropertyChanged(string propertyName)

        {

            if (PropertyChanged != null)

            {

                if (Deployment.Current.Dispatcher.CheckAccess())

                {

                    PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

                }

                else

                {

                    Deployment.Current.Dispatcher.BeginInvoke(() =>

                    {

                        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));

                    });

                }

            }

        }

    }

}

Note how I first check to see if we have access to the UI thread using the CheckAccess call. If we do, there's no reason to incur the overhead and delay of a dispatcher call. However, if we are running on the background thread, then the call is dispatched to the UI thread. In either case, we avoid the errors cause by cross-thread property change notification.

Next up: Collections

Populating an ObservableCollection from a networking return call

A more robust Observable base class like this won't help with collection change notification (WPF 4.5 has a great solution for that using BindingOperations.EnableCollectionSynchronization, but unfortunately Silverlight does not).

Most applications make networking calls to get information from some resource on an intranet or out on the web. In Silverlight (and WPF), it's common practice to populate an ObservableCollection with the results from those calls. The ObservableCollection class is nice because it implements INotifyCollectionChanged and raises an event whenever items are added to or deleted from the collection, or when the collection is cleared. It's this notification that enables the various items controls and grids in the UI to stay in sync with the items in the collection.

This version is very similar to what we saw with individual properties earlier. That's because, it's really the same problem: we're trying to notify the binding system across threads.

private void AddCustomerSecond_Click(object sender, RoutedEventArgs e)

{

    Thread t = new Thread((o) =>

    {

        var cust = new Customer() { FirstName = "AddedFromSecondThread" };

        _vm.Customers.Add(cust);

    });



    t.Start();

}

Note that the problem exists regardless of where you actually create the customer. For example, this code will also fail:

private void AddCustomerSecond_Click(object sender, RoutedEventArgs e)

{

    var cust = new Customer() { FirstName = "AddedFromSecondThread" };



    Thread t = new Thread((o) =>

    {

        _vm.Customers.Add(cust);

    });



    t.Start();

}

The reason is, again, it's not the object access that is causing the cross-thread exception, it's the collection changed notification that's full of hate here.

So, how do you get around this? Unless you want to create your own ObservableCollection type class for Silverlight, you'll need to dispatch all collection add calls. Luckily, you'll typically have fewer of these scattered throughout the application, so it's not quite so onerous.

The code to implement this is just another easy call to the dispatcher (or SynchronizationContext, if you prefer).

private void AddCustomerSecond_Click(object sender, RoutedEventArgs e)

{

    // you can create customer on any thread

    var cust = new Customer() { FirstName = "AddedFromSecondThread" };



    Thread t = new Thread((o) =>

        {



            // dispatch to UI thread to add it to the collection. You can't

            // access the observable collection x-thread

            Deployment.Current.Dispatcher.BeginInvoke(() =>

                {

                    _vm.Customers.Add(cust);

                });

        });



    t.Start();

}

If you're going to run from an unknown state, be sure to call CheckAccess to see if you really need to do the dispatching. In this case, I know I'm always going to be on a background thread, so I don't bother.

Summary

The intent here was to show a few of the common threading pitfalls in Silverlight (and WPF) applications, specifically in the context of change notification. In most code, it's easy to tell when you're accessing objects cross-thread, but change notification is a somewhat behind the scenes operation, so it's not always obvious.

For property change notification, the solutions were:

• Dispatch the entire property change operation to the UI thread
• Update the NotifyPropertyChanged code to check to see which thread it's running on, and then dispatch the event as appropriate

Either way works, but I prefer the update to the NotifyPropertyChanged method.

For collection change notifications in Silverlight, the solutions are:

• Create (or find) an implementation of ObservableCollection which does the cross-thread checking. The reason this isn't built-in is change notification happens often, and dispatching each and every change notification can be a real performance drain. That's also why WPF has a separate and optimized solution. You'd need to enable batching to avoid the overhead of hundreds of dispatch calls.
• Dispatch the entire collection update when you're running on a background thread.

In contrast to the property change notifications, for collection change, I prefer to dispatch the entire call. If you're adding 1 object or 100, you'll still get only one dispatch call, so performance is better.

The Task Parallel Library in WPF, and the subset of it in Silverlight also offer some alternative approaches to handling cross-thread work. Similarly, the async and await keywords in .NET 4.5 and Windows 8 XAML can also come into play. More on those in the future.

This project, a unofficial project by Pete Brown of Microsoft, provides a a very basic framework for building simple, short, multi-page reports using Silverlight 5.

The intent is not to be an all-encompassing reporting solution, or a solution for large reports. Instead, this is a set of code you can build upon to create short (2-5 page) reports from your Silverlight applications.

Currently the sample consists of the full source code of a simple report writer. It includes:

• automatic pagination
• support for line items of varying height
• total page count
• templating
• page headers and footers
• report footer with support for calculated fields
• events to allow hooking into printing at various stages

Latest Release

Version information changed to use semantic versioning. This vesion is numbered: 1.0.0-alpha.3

• Now targets Silverlight 5
• Added ability to specify postscript (vector) printing. The selected driver must support PostScript or this setting will have no effect.
• Fixed issue with not being able to re-print the report. (and fixed leaky event handlers)
• Added null check on templates

This is still alpha, and is a minor project. Expect bugs. Report them when you do. Offer fixes if you can :)

Get the latest release here.