Pete Brown's Blog (POKE 53280,0) for tag Silverlight

Using async and await in Silverlight 5 and .NET 4 in Visual Studio 11 with the async targeting pack

Pete Brown — Tue, 22 May 2012 21:13:39 GMT

Last September, I introduced the idea of Tasks in Silverlight. One of the things I really like about .NET 4.5, and the C# compiler that comes with it, is the ability to simplify asynchronous code by using the async modifier and await operator. Just yesterday, I posted a bit on how these two keywords are used by the compiler to take care of all the heavy lifting of asynchronous code.

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

My new role at Microsoft

Pete Brown — Tue, 22 May 2012 18:27:40 GMT

This past Monday (May 14th), I officially started a new role at Microsoft. I like to be as transparent as possible, so I thought I'd share with you all the details of this role as well as where I was before I moved to it.

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

The correct AdventureWorks database to use for Silverlight 5 in Action (and Silverlight 4 in Action) book examples

Pete Brown — Tue, 22 May 2012 01:33:45 GMT

A reader tipped me off that the AdventureWorks schema has changed since I (and my tech reviewers) last downloaded a copy. Some of the schema changes make the database unworkable with the in-book examples for Silverlight 4 in Action and Silverlight 5 in Action. In particular, the Person table is no longer there in recent versions.

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.

Workaround for CA0055 Error with Silverlight Projects in Visual Studio 2010

Pete Brown — Tue, 17 Apr 2012 19:07:46 GMT

This connect bug describes an issue with creating certain types of Silverlight projects in Visual Studio. If you're referencing Silverlight 4 DLLs from a Silverlight 5 project, you may run into this code analysis/FXCop issue yourself if code analysis is part of your process. The core of the problem is a versioning decision in Silverlight 5 which results in compile-time violation due to loading two different versions of mscorlib in the same project. It manifests as the following error:

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.

Released: New Version of Expression Blend for Silverlight 5

Pete Brown — Thu, 29 Mar 2012 18:32:38 GMT

You may have noticed that your current copy of Expression Blend for Silverlight 5 expires in the next day or two. A new version of Expression Blend Preview for Silverlight 5 is now out. Get it here.

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.

XAML Tip: Setting Attached Properties from Code

Pete Brown — Thu, 29 Mar 2012 17:36:39 GMT

Recently, a reader asked how they should go about setting the Typography properties from code-behind.

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.

Tip: Binding an Image element’s Source property to a Uri in WinRT XAML

Pete Brown — Tue, 27 Mar 2012 19:00:23 GMT

Over the years, I've conditioned myself to use the Uri class when surfacing web URLs in my application. Early versions of Silverlight couldn't bind an image source directly to an instance of a Uri because they lacked an appropriate type converter; the usual workaround was to change the property to a string type.

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.

Getting Started with XAML: Slides and demos

Pete Brown — Mon, 27 Feb 2012 00:22:17 GMT

At the South Florida Code Camp last week, I gave an early morning talk titled "Getting Started with XAML". In this talk, I covered the basics of XAML, the property system, layout, and other things you need to know as a XAML developer for WPF, Silverlight, or Windows 8.

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:

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

REST with Silverlight 5, ASP.NET Web API, and MVC 4 Beta

Pete Brown — Sun, 26 Feb 2012 23:50:21 GMT

At the South Florida Code Camp I gave a newer version of the REST Silverlight talk using the just released MVC 4 Beta and ASP.NET Web API.

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

Previous Versions

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

A Lap Around Silverlight 5: Slides and Code

Pete Brown — Sun, 26 Feb 2012 23:30:47 GMT

At the South Florida Code Camp, I gave the "Lap Around Silverlight 5" talk. The slides and code are all available via the links below.

Powerpoint Slides

Attached to this post

Demos and Examples

My Book

Silverlight 5 in Action

Downloads

Previous Versions

Windows Client Developer Roundup 087 for 2/9/2012

Pete Brown — Thu, 09 Feb 2012 02:44:11 GMT

The Windows Client Developer Roundup aggregates information of interest to Windows Client Developers, including WinRT XAML, WPF, Silverlight, Visual C++, XNA, Expression Blend, Surface, Windows 7, Windows Phone, Visual Studio, WCF RIA Services and more. Sometimes I even include a little jQuery and HTML5. If you have something interesting you've done or have run across, or you blog regularly on the topics included here, please send me the URL and brief description via the contact link.

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) :)

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

Creating Big Silverlight Windows and Getting Monitor Resolutions and Positions with PInvoke

Pete Brown — Wed, 08 Feb 2012 03:59:11 GMT

While doing the (long!) tech review for Silverlight 5 in Action, my friend and former coworker Tom McKearney mentioned that we should put together some code to make handling windows across multiple monitors a reasonable task in Silverlight 5. Then, on a mailing list, I recently saw the question:

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.

The Commodore 64 Emulator: Emulating Pointers in a sandbox when the real thing is not allowed

Pete Brown — Tue, 07 Feb 2012 00:02:46 GMT

Late last week, I cracked open the Commodore 64 emulator code once again, in preparation to post it. However, I had to have a change made to the source control on CodePlex, so I had a few days to make some changes. So far, it's shaping up quite nicely:

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.

Windows Client Developer Roundup 086 for 1/11/2012

Pete Brown — Thu, 12 Jan 2012 01:02:35 GMT

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)

Threading Considerations for Binding and Change Notification in Silverlight 5

Pete Brown — Tue, 10 Jan 2012 16:48:00 GMT

A reader of my Silverlight 5 book recently reached out to me about threading and why I create some objects on the UI thread in the examples. We discussed some of the reasons, but I felt this would be a good topic to share with everyone. In fact, this is one area where it would have been fun to go into great detail in my book, but there simply wasn't the space. Threading and cross-thread exceptions can be a bit of a mystery to new Silverlight and WPF developers.

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.

Silverlight Reporting Open Source Printing/Reports Example Updated for Silverlight 5

Pete Brown — Mon, 09 Jan 2012 20:44:30 GMT

I recently posted an updated version of Silverlight reporting on codeplex. Here's the overview.

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.

Slides and Code from my VSLive Silverlight 5, REST, WCF Web API, MVC talk

Pete Brown — Thu, 15 Dec 2011 21:13:05 GMT

This talk was an adaptation of two chapters from Silverlight 5 in Action. I started with a brief explanation of REST, and then explained the solution we were going to build during the session. The idea was to show how you can use REST in place of the heavier Soap approach in many cases, and make your services accessible to far more clients.

I also showed how to share model objects between various implementations of .NET, using linked files and conditional compilation.

Without watching the session or reading the chapters, the source and slides are only somewhat useful as you miss the interim steps. So, if you happen to be at an event where I deliver this again (I've submitted it to several upcoming 2012 events), great. If not…buy my Silverlight 5 book ;)

In addition to what's covered in my book, I also showed how to create a basic Razor Helper to load Silverlight in the page. You can learn more at the linked blog post.
The WCF Web API may be found at the WCF CodePlex Site.
You can learn (a lot) more about ASP.NET MVC at our ASP.NET Community Site.
Of course, you can get all the Silverlight 5 bits at our Silverlight Community Site.

Everything else is attached to this blog post. The zip file is around 7mb.

Feel free to present this at your own internal or public events. I only ask that you not submit this as a session at VSLive, TechEd, DevConnections or other large events where I may be planning to present. When in doubt, ask.

Announcing the Release of Silverlight 5!

Pete Brown — Fri, 09 Dec 2011 19:30:14 GMT

Look what just came out, and well in time to beat the Christmas rush :) Yes, it's Silverlight 5. We had originally announced that Silverlight 5 would be out by the end of this year, and I'm glad to report that it has made it in in time to give everyone something interesting to play with over the holidays. My congratulations to the engineering, marketing, support, and documentation teams for pulling off yet another amazing release.

Get the Bits

The best place to go to get the bits is http://silverlight.net/downloads . Make sure you have Visual Studio 2010 SP1 (or Visual Web Developer) and then install the Silverlight 5 Tools. While there, be sure to install the latest version of the Silverlight 5 Toolkit - most of the XNA goodness is in the toolkit and SDK.

The version number for this release of Silverlight 5 is 5.0.61118. You can in-place upgrade from the RC. While not required, you can also uninstall the old bits first if you want.

Where to Get Help

The Learn section on Silverlight.net is the primary location for Silverlight 5 videos and tutorials. The beta and RC content still applies, and I've started creating more Release content for you as well.

We have a dedicated Silverlight 5 forum on Silverlight.net. Post any Silverlight 5-related technical questions there for peer support.

Of course, I can't help but throw out a plug for my book Silverlight 5 in Action. If you order it right now, you get the early access bits, which is 1200 pages of raw unedited writing from me. I think you'll like it.

Silverlight 5 RTM/RTW Features

Silverlight 5 adds a ton of new features over what we had with Silverlight 4. These are non-trivial features like a full 3d stack, parsing performance improvements, tons of enhancements to binding and much more. My favorite features have to be Implicit Templates and the XNA-Compatible 3d Stack. The official list of features is here, but I've also detailed some below with direct links to learning content (this is adapted from my RC post).

Binding and Related

ICustomTypeProvider (see Alexandra Rusina's post)
Custom Markup Extensions
Ancestor RelativeSource Binding
Implicit Data Templates
Binding in Style Setters
DataContextChanged Event
PropertyChanged now an UpdateSourceTrigger option

Graphics

XNA 3D API
Improved Graphics Stack
XNA 3D built-in effects
XNA 3D Project Templates with full XNA Content Pipeline
3D surface composition settings
3D multi-sample anti-aliasing

Media

Low-Latency Sound using XNA SoundEffect and SoundEffectInstance
Hardware decoding of unprotected H.264 media
Variable Speed Playback and Trick-play (new since beta)
Remote Control and Media Command (Keys) Support

Text

Operating System Integration

P/Invoke (also: My Printer Enum Example)
Multiple Windows
Unrestricted File System Access in Full Trust
Full Trust in-browser for enterprise scenarios
Default Filename in SaveFileDialog and OpenFileDialog
64 bit browser support for Windows
Power awareness for media apps (keep the PC alive while a movie is playing, for example)

Productivity and Performance

Network Latency Improvements
Databinding Debugging
Parser Performance Improvements
Multi-core JIT for improved start-up time

Controls

Double and n-click support
PivotViewer (with improved customization and more)
ComboBox type-ahead/incremental search

Other

In-browser HTML for trusted in-browser applications
PostScript Vector Printing
Tasks from TPL
C# Covariance and Contravariance

and more…

My Silverlight CodePlex Projects

For a number of reasons, I've let my CodePlex projects sit for a bit. The time has come for me to finally update them. I'll have new Silverlight 5 versions of the Commodore 64 Emulator with a new UI and sound support, and the Silverlight Printing/Reporting example both up shortly after I return from vacation with the family. Look for more info soon.

Go Get it

So go and check out the release. It is backwards compatible with your Silverlight 4 applications (it runs in quirks mode until you recompile the project for Silverlight 4), so feel free to target SL3, 4 or 5 using the Silverlight 5 bits.

Windows Client Developer Roundup 085 for 11/28/2011

Pete Brown — Mon, 28 Nov 2011 04:03:08 GMT

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

.NET Tutorial: Learn .NET and C# interactively (Motti Shaked)
Announcing GoingNative 2012 Conference (Visual C++ Team Blog)

Windows 8 and WinRT/Metro General

Try It Now: Use PPL to Produce Windows 8 Asynchronous Operations (Visual C++ Team Blog)
Debugging Contracts using Windows Simulator (Visual Studio Blog)
Handling orientation changes and setting preferred orientation in Metro style apps (Gus Class)
1360x768x32 Resolution in Windows 8 in VirtualBox (Michael Crump)

XAML Technologies (Silverlight, WPF, WinRT Metro XAML)

Windows Theme Fonts Redux & Sample Code (Quppa's Blog)
WPF 4.5 - Part 13 : binding to types that Implement ICustomTypeProvider (Jonathan Antoine)
Adding an Application Bar to your XAML Metro Applications. (Michael Crump)
An Introduction to Semantic Zoom in Windows 8 Metro (Colin Eberhardt)
Handling Extremely Large Data Sets in Silverlight (Jeremy Likness)

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

Game Debugging in Visual Studio 11 (Visual C++ Team Blog)
Stand still and they won't see you (Shawn Hargreaves)
Math Primer Series: Matrices III: Affine Transformations and Matrices (Reza Nourai)
Temporal sampling frequency (aka 'framerate') (Shawn Hargreaves)
XNA Light Pre-Pass: Instancing (J. Coluna)

C++ and Native Development

Inside the C++/CX Design (Visual C++ Team Blog)
GoingNative 3: Marian Luparu answers about C++/CX (Visual C++ Team Blog)
C++ code analysis in Visual Studio 2012 (BlogMFC)

Visual Studio and .NET General

Visual Studio 11 IDE Advances (Soma)

NUI (Kinect, Surface, More)

Our Kinect Controlled living room (Apeoholic's blog)
Kinect Controlled Treadmill and Robot Navigation (KinectHacks)
My shift from WPF-XAML to Kinect for Windows (Rob Relyea)
Information on upgrading Kinect Applications to MS SDK Beta 2. (Michael Crump)
Samsung SUR40 for Microsoft Surface Now Available for Pre-order! (Surface Blog)
Mobile developers and Kinect (Rob Relyea)
Samsung SUR40 for Microsoft Surface Receives "Best of What's New" Award from Popular Science (Surface Blog)
"Kinect with your Eclipse IDE" (Channel 9)

Off-Topic Fun

Graph of Life Satisfaction for nerds vs. everyone else (SMBC)
Walkable Roller Coaster (Toxel) (Watch out for the loop!)
xkcd: P*rn Folder (xkcd)

It’s a wrap! I’ve completed writing Silverlight 5 in Action

Pete Brown — Thu, 17 Nov 2011 07:51:07 GMT

Well, I've completed the initial writing anyway. Anyone who has written a book understands the, umm, pleasure of the multiple editing cycles which shall follow. I have my normal development editor review Thursday afternoon, and then it's turned over for tech review the following week. Tom is really going to have his hands full with the 1191 pages this book came in at before editing and production (which always reduces the page count by making images smaller etc.)

The last chapters I turned in were the two 3d chapters. I'm really pleased with how they came out. It was a struggle to fit all that 3d awesomeness in the 64 pages it took, but considering I had budgeted only 25 pages total for 3d coverage, I can't really make too much of a stink over that :)

For those of you who remember the Commodore Amiga, you'll get a kick out of the demo app we build across those two chapters:

Yep. It's not a 100% reproduction (no sound or good simulated physics), but it shows off modeling, texturing, cameras, matrices, the rendering system, multiple ways of dealing with vertices and triangles, and my own little keyframe animation system. Really cool stuff, and tons of fun too.

Here's the background of the original Amiga boing ball demo

The making of the Amiga Boing Ball demo

Thank you to everyone who has already purchased Silverlight 5 in Action. If you have yet picked up a copy, the Manning Early Access Program (MEAP) still allows you to get the work-in-progress chapters until the book is out in print. Go order it now and support my electronics junkie habits :)

Here's a taste (pre-editing) of what you can expect to find in the second 3d chapter:

Pete Brown's Blog (POKE 53280,0) for tag Silverlight

Using async and await in Silverlight 5 and .NET 4 in Visual Studio 11 with the async targeting pack

A simple example using await

Give me something to wait on

Creating an async-friendly wrapper for the service reference

Additional Information

My new role at Microsoft

A little (optional) history

My interests and passions

The new role

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

Q: Are you abandoning Silverlight / WPF?

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

Q: What about your NETMF/Gadgeteer Stuff?

Q: What happened to your Silverlight 5 book?

Q: What is your next book?

Q: Are you moving to Redmond?

Q: Why Windows 8 XAML as a primary focus?

Q: Why the corporate/platform evangelism team?

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

Q: Metro all the things?

The correct AdventureWorks database to use for Silverlight 5 in Action (and Silverlight 4 in Action) book examples

Workaround for CA0055 Error with Silverlight Projects in Visual Studio 2010

How to Reproduce the Issue … in theory

The Workaround

Released: New Version of Expression Blend for Silverlight 5

XAML Tip: Setting Attached Properties from Code

Tip: Binding an Image element’s Source property to a Uri in WinRT XAML

Getting Started with XAML: Slides and demos

Slides

Demos

My Silverlight Book

Related Links

REST with Silverlight 5, ASP.NET Web API, and MVC 4 Beta

Powerpoint Slides

Demos and Examples

My Book

Related Links

Previous Versions

A Lap Around Silverlight 5: Slides and Code

Powerpoint Slides

Demos and Examples

My Book

Downloads

Related Links

Previous Versions

Windows Client Developer Roundup 087 for 2/9/2012

Windows 8 and WinRT/Metro General

XAML Technologies (Silverlight, WPF, WinRT Metro XAML)

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

C++ and Native Development

Visual Studio and .NET General

NUI (Kinect, Surface, More)

Off-Topic Fun

Creating Big Silverlight Windows and Getting Monitor Resolutions and Positions with PInvoke

Creating the Window

Positioning and Sizing the Window

Getting Display Informatin Using PInvoke

Positioning and Sizing the Window

Position Window on Primary Display

Position Window on Secondary Display

Make a window take up all Display Space

Position Main Window on a Named Display

Summary

The Commodore 64 Emulator: Emulating Pointers in a sandbox when the real thing is not allowed

How Pointers Work

How pointers are used in Frodo

The Simulated Pointer

Operator overloading and Offsets

Converting Strings

A Structure, not a Class

Summary

Windows Client Developer Roundup 086 for 1/11/2012

Shout-Outs

Windows 8 and WinRT/Metro General

XAML Technologies (Silverlight, WPF, WinRT Metro XAML)

WinJS / JavaScript and HTML Applications for Windows Metro

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

C++ and Native Development

Visual Studio and .NET General