Tim Heuer's Blog

Build 2015 recap for XAML and native apps

Tim Heuer — Mon, 04 May 2015 17:33:29 GMT

Wow, what a week. I have to say even as employees of Microsoft, we get surprised when we go to our conferences and see some of the bigger announcements. There are things that are being worked on that are new or just in different divisions that we’re not focused on. This past week at the Build 2015 conference was an example of that for me. Lots of good stuff for developers from client to server!

Universal Windows Platform

At Build this year we introduced the Universal Windows Platform v10 with a set of new APIs and unified features for all Windows devices. Perhaps the best vision of this is the Day 2 Keynote where Kevin Gallo walked through an example of this and a single app running on tablet, phone, Surface Hub, HoloLens, etc.

Visit the keynote and watch the whole thing or if you want to jump to the start of this portion it starts at about 23 minutes in. A really well done, compelling demonstration of the Universal Windows Platform.

XAML Session Recap

For the XAML developer on Windows, there was a lot of goodness shown from my team. We’ve been working hard on a lot of internals and new API exposure for the Universal Windows Platform. Our team had some representation in some deep-dive sessions from Build and the recordings are all now available…here’s a list for you to queue up:

One of the things I was really happy to have is part of the Office team come and talk about how they build Office on the same platform we ask you to build apps on. It is good insight into a large application with lots of legacy and goals that might not be typical of smaller apps or smaller ecosystems. A big focus for XAML this release was performance given that customers like Office and the Windows shells themselves leveraging XAML for their UI.

I hope that if you are a XAML developer you take some time to look at what new features are available in the Universal Windows Platform for you in Windows 10.

Get the goods!

If you want to get started playing around, the best way is to be a part of the Windows Insiders program. Everything you need to get started you can find here https://dev.windows.com/en-US/windows-10-for-developers. You’ll want to join the Insiders program, then download the Visual Studio tools and get started creating/migrating apps! To help get you started after that here are some helpful links:

Give us feedback!

As you play around with the bits, please continue to give us feedback. The best way is to be involved in the conversation on the forums. Ask questions there, get help from the community, share learnings, etc. Secondarily the Windows Insider Feedback tool (an app that is installed on Windows already for you as ‘Windows Feedback’) is available for you to give direct feedback to the teams. Please choose categories carefully so that the feedback gets directly to the right team quickly.

Thanks for helping make the Windows Platform better. I hope these direct links help you jumpstart your learning!

tags: windows, visual studio, xaml, universal apps, uwp, blend, silverlight

This work is licensed under a Creative Commons Attribution By license.

Determining Portable Class Library compatibility

Tim Heuer — Tue, 27 May 2014 08:02:31 GMT

Recently I embarked on porting the TagLib# library to a Portable Class Library (PCL). In my efforts I noted some frustration I had of the “convert and compile” flow to find issues. Well, turns out I didn’t have to do that much pain as pointed out by Daniel in the comments! The .NET team has released a tool to help out us developers called the API Portability Analyzer (currently in Alpha). This tool basically looks at any existing .NET assembly and gives you a report to help you see where the APIs used are supported in the various .NET profiles available.

The tool is a single command-line exe and is as simple as launching:

ApiPort.exe path-to-your-assembly-file.dll

I recommend putting this in your path somewhere so you don’t have to remember the full path to launch. The output from the console tells you very little and only really about what you it is doing:

Microsoft (R) API Portability Analyzer version 1.0 (alpha)
Copyright (C) Microsoft Corporation. All rights reserved.

To learn more about how this tool works, including the data we are collecting, go here - http://go.microsoft.com/fwlink/?LinkId=397652

Identifying assemblies to scan. Done in 0.01s.
Detecting assembly references. Processed 1/1 files.Done in 0.23s.
Sending data to service. Done in 2.88s.
Computing report. Processed 508 items.Done in 0.02s.
Writing report. Done in 0.17s.

Replaced output file "c:\ApiPortAnalysis.xlsx"

You may notice that the tool says ‘sending’ and yes, it is communicating with a public service. The team notes this in the download:

NOTE: During the process of identifying the .NET APIs used by a binary Microsoft collects the list of .NET APIs used by the user submitted binaries. Microsoft also collects the names of various user created APIs. The tool does not collect the binary code, only names of APIs are collected. Microsoft will also collect assembly information such as assembly references for the binary & the Target Framework Moniker (TFM).

The real value is in the output data conveniently formatted into a pre-filterable Excel document. The process was fairly fast for me, but I suspect might take longer for larger libraries (duh). An example of the output is like the one here directly showing the TagLib# data that I used above.

If you read my previous post you will see that the areas I had frustrations about are clearly identified in the Unsupported columns for my target platform. The tool attempts to recommend some alternatives when it can. I can imagine this gets better over time as the recommendations for TagLib# were only two, whereas it should have provided recommendations for XmlDocument/XmlElement/etc. to the XLINQ equivalent areas.

In the end though, this is a helpful tool for those looking to convert. I wish I had known about it in advance, but now that I know it is in my toolbox and my PATH!

Hope this helps!

tags: pcl, apiport, portable, taglib, .net, framework, silverlight, wpdev, winrt

This work is licensed under a Creative Commons Attribution By license.

Working with Portable Class Libraries and porting TagLib#

Tim Heuer — Sat, 24 May 2014 04:51:21 GMT

A long while back I had written a quick sample when Silverlight introduced drag-and-drop into the framework. Then I decided to show dragging MP3 files into a Silverlight app and reading the metadata and album art. In order to accomplish this I had to read into the ID3 data from a Silverlight library. I found a few libraries but settled on TagLib# to do the job. I had to modify it a bit to get it working in Silverlight as the .NET profile wasn’t the same. Recently a surge of people have been emailing me for the code. I spent time searching and apparently I didn’t think the TagLib# modifications were that important because I never saved them anywhere! A conversation started on Twitter and I decided to devote some “20% time” to making these modifications and take it a step further and make it into a Portable Class Library (PCL). Here’s my journey…

Deciding to Fork

My first task was finding the source of truth for TagLib#. The main link on the Novell developer site was broken and stale. I found it on GitHub and started looking around. It really hadn’t been updated in a long while (after all, it really didn’t need to be fore core .NET framework) and the project is very stale. There is no open issues list on GitHub as you have to use Bugzilla, but that didn’t even look like it was getting much attention. I emailed the maintainer listed in the authors file in the repository and he indicated he’s not really the maintainer. This felt like a project kind of fizzling down (if not fizzled already).

In looking at the tests, the project structure, and taking into account that I may want to do some things different, I made the decision to fork rather than clone. I’m not totally married to the decision but I don’t think anyone is keeping the lights on to take a pull request either though. I forked the code and started with new projects and using Visual Studio 2013 as my tool of choice.

Using Shared Projects

At first I thought that I would be doing perhaps a few different flavors, portable and full .NET framework. Because I thought I would I decided to use the new Shared Project system in Visual Studio 2013 and the new Shared Project Reference Manager VS extension that allows me to add references from any project to shared code easily. This gives me the flexibility for the future and sets my project system up in advance. You’ll see in the end I haven’t actually needed to take that step and perhaps won’t even need the Shared Project anymore, but for now I’m keeping it as it does me no harm.

First Compile

Once I moved the code over and set my target profile for PCL, I hit build. Whoa. About 140 compile errors. Immediately I thought that I didn’t want to spend the time. I took a look at the issues and quickly realized that the base code had, in fact, changed a bit from when I messed with it in Silverlight. I started making a list of the things that weren’t compiling as I was targeting .NET 4.5, Silverlight 5, Windows 8+, Windows Phone 8+, and iOS/Android (Xamarin). The biggest errors came from the fact that the library was still using XmlDocument and hadn’t moved to XLinq. Beyond that there were things like Serializable, ICloneable, ComVisible and File IO that weren’t going to work. I got really frustrated quickly and about gave up.

Working at Microsoft I am fortunate to have access to try more things and indeed I reached out to some folks for help. I was able to get some things working continued with XmlDocument, but it didn’t feel right and starting to think about releasing this updated library I just realized this wasn’t going to work. I remained frustrated.

Helpful Friends

Sometimes when you are frustrated you just want to vent to the world. We call that Twitter these days. I was pulling some hair out and posted a comment, which was quickly replied by a member of the .NET team with a bit of a touché comment.

@timheuer Funny, because I spent the day trying to write Windows XAML from the millions of WPF examples in the wild. :)
— David Kean (@davkean) May 23, 2014

I chuckled but I also knew that David and others were going to be the key to helping me find the fastest path here. I started emails with the PCL team, including David and Daniel, who are incredibly knowledgeable and responsive. I finally got most working and then my colleague and I started chatting about my frustrations. He worked on XLinq for a bit and basically told me to suck it up and do the conversions and that it wasn’t that bad. We walked through a few of the scenarios and indeed it really ended up all being isolated into one area that I could quickly scan through. I could now remove my dependency on XmlDocument and have no other dependencies for this portable library.

Hooray for helpful people! Even when you vent, the good peeps will still help out!

Changes to TagLib# for portability

After the full conversion, a few things remain. Right now I have #ifdef’d out come of the interfaces and attributes that weren’t working. Once I get to a point of porting all the tests over, I’ll decide if they are even needed. Perhaps the biggest change though for users of this lib will be the removal of the default string path of file access. In discussing with some folks, I could have tried to make a portable storage layer work, but it started to make less sense quickly to do that in the library and leave that simple task to the app developer. This provides flexibility for the app to do what they want without the library trying to work around how different platforms do their file IO routines. What that means is that the default way of reading a file’s tags changes from:

var tagFile = File.Create("ironlionzion.mp3");
var tags = tagFile.GetTag(TagTypes.Id3v2);
string album = tags.Album;

' file is a StorageFile
var fileStream = await file.OpenStreamForReadAsync();
var tagFile = File.Create(new StreamFileAbstraction(file.Name, fileStream, fileStream));
var tags = tagFile.GetTag(TagTypes.Id3v2);
string album = tags.Album;

in a simple case. Yes, you as the app author have to write a bit more code, but it puts you in control of ensuring the file location you are reading. You can see here that I did add my StreamFileAbstraction class to my fork by default, which was the key in the Silverlight port and is actually the key for WinRT as well. Any app developer can create their own IFileAbstraction implementation and substitute it in the ctor of the create functions and be ready to read. I actually did this in the test project to re-implement a LocalFileAbstraction for test purposes and used the System.IO.File classes to achieve that, which are available when running VS unit tests.

Summary

What started out as a frustrating exercise turned out to be helpful for me to better understand PCLs and hopefully add value to those who have been asking for this. As mentioned, this isn’t fully tested and still a ways to go, so if you use it please log bugs (and help fix them) to complete the implementation. I won’t be working on this full time of course, but do hope to get the test suite ported over as well. Here are some relevant links:

TagLib.Portable – source code repository for my fork
TagLib.Portable NuGet Package

Hope this helps!

tags: taglib, id3, pcl, winrt, wpdev, silverlight, mp3

This work is licensed under a Creative Commons Attribution By license.

Code signing for the independent developer

Tim Heuer — Tue, 13 Dec 2011 02:01:10 GMT

One of the features introduced with Silverlight 4 was the out-of-browser feature, enabling you to create an application that can be installed, run offline, automatically updated, etc. As a part of that feature, some of the major code signing certificate vendors (for Authenticode certs) provided our team with test certificates so that we could go through the same process as a developer would to acquire the cert and apply it to an app…and, of course, validate it works.

During that time some of those vendors had promotional codes for the first year for Silverlight developers, providing reduced-rate (but not reduced quality) code-signing certificates for their apps. Still during this time there were a lot that questioned why some providers were still expensive and didn’t value “the little guy.” By that I mean that there are a lot of smaller firms or independent personal developers. The thought of dropping a few hundred dollars on a cert is sometimes tough.

Last week a representative contacted me about their offerings as a premier partner of one of those providers. Certs4less.com is now offering Thawte code-signing certificates for individual developers. They are doing this at a price of $99 per year (less for multi-year).

NOTE: As a part of this, like before with SL4, Certs4Less graciously offered a promotional cert for me to validate the end-to-end process so that I could speak accurately about it. I do not use any of these certs provided by these companies for testing purpose toward any production application and they are for testing purposes only. Besides, I’ve not found the time to write production code for apps lately ;-). I am not getting paid for this post, nor am I getting another promo code for personal use myself. I am simply providing what I think is valuable information and get no compensation from Thawte or Certs4Less.

I went through the process of obtaining this cert from Certs4Less.com and it produced exactly what you’d expect, a valid Authenticode code-signing certificate I can use for my Silverlight and Windows 8 application packages! I shared a few points of feedback with the contact there and will enumerate them here for you as well (as well as some tips)

Your ‘Common Name’

Think about this one pretty good when you buy a cert. This has a two-fold purpose why I mention this. First, it is what your customers will see. Do you want them to see an app signed by a name that isn’t recognizable or doesn’t make sense…of course not. Additionally this is the name that will be verified. So if you claim you work for Fizbin Enterprises, but that doesn’t actually exist…you’ll have issues during verification.

One year, 2 or more

One thing you should know about code-signing certificates is that once they expire, the keys change during renewal. In some cases this can cause issues for your app (ClickOnce). For this reason I personally recommend getting the longest you can afford. Most likely this will be a wise investment and you’ll have piece of mind.

Apply on the computer you will receive it

One thing we as developers don’t do well is read directions. One of the instructions you’ll see is to be sure that you do the cert request process from the same machine you plan on picking up the cert from! Seriously, this is critical if you use the browser process because of the private key. If you don’t…you’ll be screwed and out some cash. Plan ahead and don’t do this while on vacation on your laptop that you repave weekly.

Verification Process

This is an area where I think I had the most negative feedback. These verification steps are a bit old. I understand they have their reasons, but in this digital age the fact that I had to find a notary was…well, just inconvenient. This Certs4Less/Thawte process required me to do this. The ‘form’ they emailed me really wasn’t a form…just an email with text broken out with ‘==========================’ before each section. So when I brought in my printed out GMail ‘form’ to the Notary he looked at me like I was an idiot. The verification form was nothing formal looking at all and I had to have 3 different people look at it before they finally just said ‘okay’ and signed it.

The thing that was most troublesome in this process was it was a distractor. I had to actually print stuff out, find a passport, go to a bank, wait in line…you know, real people stuff. But still, it felt annoying in this modern age.

Some of my other process with other vendors have been a lot more streamlined and I think this can/should improve.

Acquiring the certificate

Most of the time this is a quick process. Remember when I mentioned that developers don’t read instructions? Yeah, I’m no different. The final email I got indicating my cert had instructions that I didn’t read that talked about making sure I had intermediate certificates installed first. Without this I got ambiguous errors when trying to retrieve my certificate. Be sure to read any verification instructions in detail to provide a good experience.

Back up/export your certificate

I don’t know about you but I’d probably use my cert in automated build processes, keep it on a share (perhaps a dropbox/Live/git location) so that I don’t have to only use my one machine to sign an app. One thing I highly recommend is after the key is installed is to use the certmgr.msc tool and export the certificate. When doing this be sure to export the all the key data as well as cert chain so that your resulting PFX file is portable. Then you can use it in your build process for Silverlight as described here in my previous blog post about that feature.

Summary

I want to thank Certs4Less for reaching out to the independent developer and providing a valuable product at an ‘independent developer’ price level. I appreciate them also reaching out to allow me to test the process to verify it is fairly painless and the result is what I expected.

Code-signing certificates are very valuable in many ways and I believe every developer should have one for their personal projects as well as their large ones.

Hope this helps!

tags: xaml, silverlight, xap, ssl, thawte, certs4less

This work is licensed under a Creative Commons Attribution By license.

Silverlight 5 Released with awesome samples in the Silverlight Toolkit

Tim Heuer — Tue, 13 Dec 2011 00:27:00 GMT

Silverlight 5 is finally released! Congratulations to the team for getting through some of the toughest parts of finishing a product and validating with customers. It’s been a pretty crazy year for the Silverlight team and this is a really good release for the product bringing some solid features to the platform for folks to leverage in building their apps.

In addition to the platform having a release, I was really pleased to see an update to the Silverlight Toolkit, which has been one of the most popular things almost every Silverlight developer/application uses. If you didn’t know where to get things, here’s some links for you:

Silverlight 5 Tools for VS (requires SP1)
Silverlight 5 Toolkit
Developer runtime for Windows (32 bit, 64 bit) and Mac OSX

Rather than enumerate all the good features that were finished from the RC/Beta, you should head on over to listen/watch Pete Brown’s presentation on the Silverlight 5 release overview. He also has a post about the release enumerating in short form (with links to tutorials for some of the key features) on his blog.

What I think is really cool is also the amount of effort put into the Silverlight Toolkit for this release. The one large thing of note is the extensions to enhance your 3D development experience in Silverlight 5. David Catuhe has a post outlining in great detail some of the 3D extensions included in the toolkit. You should really go check out his post. Scrolling to the bottom I was really surprised/impressed to see a set of 3D samples included to help you understand how to use this feature:

Bloom – uses the Content Pipeline and post-processing effects
CustomModelEffect
Generated geometry – how 3D models generated by code
Particles – c’mon, who doesn’t like a particle generator!
Platformer - while not 3D it appears, it is a complete game with levels
3D Animation
Skinning – shows skinning a character using the content pipeline

I mean, wow, great stuff David!

I hope you all enjoy the release of Silverlight 5 and kudos to the team for getting it out the door. Go download the bits and start building awesome stuff.

tags: xaml, silverlight 5, silverlight, xna, 3d

This work is licensed under a Creative Commons Attribution By license.

Silverlight 5 RC available for developers

Tim Heuer — Thu, 01 Sep 2011 17:56:19 GMT

The Silverlight 5 Release Candidate (RC) is now available for developers to download. As with previous preview releases, this is a developer-focused release, which means no production releases, no go-live license, etc. This is made available for you to test your apps, upgrade to get latest features and to deal with the changes from beta to RC.

The beta was a great release and preview of what the team had introduced as new features. You can read back on my Silverlight 5 guide to new features post regarding if you haven’t understood the latest and greatest additions. However there are now some new available features in the RC including:

P/Invoke for calling native methods
64-bit support for the plugin
Vector printing
Capabilities to support remote controls (for media)
In-browser trusted apps
PivotViewer now a part of Silverlight (with new features)

Some things have changed from beta to RC, to be sure to take a look at your code, references, namespaces, etc.

Pete Brown has a great announcement post on his blog with links to his (updated for RC) tutorials and videos for Silverlight 5. Be sure to go on over there and read and get the links.

tags: silverlight 5, silverlight, riaservices

This work is licensed under a Creative Commons Attribution By license.

Silverlight 5 Beta–A guide to the new features

Tim Heuer — Wed, 13 Apr 2011 17:09:22 GMT

At the MIX11 conference Scott Guthrie announced the availability of Silverlight 5 Beta. I suppose this doesn’t come at a surprise to most as this is now a regular annual occurrence. In fact it is almost exactly a year ago when Silverlight 4 was released.

The team has been working very hard to deliver on the features we discussed at the Silverlight Firestarter event last December 2010. That was a flurry of revealing that happened in December showing the world what the Silverlight team has been working on. There was no rest for them of course and they continued to complete this initial version of Silverlight 5 to release at MIX11.

As always with Silverlight betas, this is a developer release. This means that this is a preview for software developers to understand and appreciate (and give feedback) the new features provided. There is no “end-user” runtime available for the release nor a “go-live” license for you to develop applications into production.

So enough with the pleasantries…

Download Silverlight 5 and Tools

To get started with the Silverlight 5 beta you are going to need some tools. Here’s the link dump (be patient as some link caches get updated):

Visual Studio 2010 SP1 or Visual Web Developer Express 2010 SP1 (yes, SP1 is required and if you don’t have it you’ll have to install it and can get it from here.)
Silverlight 5 Tools for Visual Studio
Expression Blend Preview for Silverlight 5
Silverlight 5 SDK CHM
Developer runtimes: Windows and Mac platforms – not needed if you install the tools above but some like to know where they can get these just for test/debug
Silverlight 5 SDK only – not needed if you install the tools above
Breaking changes doc

These are the full set of tools to help you evaluate Silverlight 5. At a bare minimum for a developer you’ll need/want the Visual Studio 2010 and the Silverlight 5 Tools for VS.

NOTE: In case you are like me and don’t like to read the finer details you may have missed the note that you don’t need to install the developer runtime/SDK separately if you are installing the Silverlight 5 Tools. Again, it is not necessary to install the SDK and developer runtimes *again* if you have already installed the Silverlight 5 Tools for Visual Studio. The links to the developer runtimes are provided for convenience as some use these to put on test machines without developer tools to test things out and debug.

Go ahead and start downloading the tools now…here’s some information on the release for you as you download!

Silverlight 5 Resources

There are a few places you can go to get more information and quick learning on Silverlight 5:

hey this blog :-) -- you can subscribe to my feed as well as follow me on Twitter for some casual updates/sharing
John Papa and Pete Brown blogs
View some initial Silverlight 5 learning videos with sample code

You should also subscribe/bookmark those links as they’ll likely to be continually updated with good nuggets of information!

What’s new in Silverlight 5 – feature review

Here’s more of the details on what is new in this release. This shouldn’t come of any surprise if you watched the Silverlight Firestarter event and saw all the new stuff. This is a little long in description here, but hopefully for your benefit.

Tooling
Media
Text
Data binding
Controls

3D Graphics
Trusted Applications in Browser
Trusted Applications
General “stuff”

Tooling

How could we have a release without improved tools? Visual Studio 2010 has proved to me to be a great platform (have you seen the Extension Manager and how you can grab all the great things online? VSCommands is my favorite) for productive development on the Microsoft platforms.

You would expect to have the Silverlight 5 support in the tools and it is in there, all what you want. The cool thing is that adding the tools on your existing SP1 installation gives you ultimate Silverlight multi-targeting support:

In addition to the basics and supporting the new features, we’ve added one of my favorite tooling features that folks have been asking for: XAML debugging. Now right now it is for Binding expressions only, but let’s be honest, that’s what you care most about right! So what does this feature mean? Well you can set a breakpoint in your editor on XAML lines that have the {Binding} syntax in them:

When that binding is evaluated you’ll get information about the binding evaluation:

Pretty helpful huh? We hope so. For now it is supported for Binding only.

Video: Pete Brown demonstrates XAML debugging

Media

A few things improved on the media front based on some feedback from our customers. First, when having the need for low-latency sound (for things like audio loops, etc.) the MediaElement wasn’t doing the trick. There were a few hacks you could do, but overall not ideal. So remember how we did some fun things on the phone that allowed you to use XNA? Well, now we have SoundEffect for Silverlight 5 as well. This should look familiar if you are a Windows Phone developer:

   1: using Microsoft.Xna.Framework.Audio;

2:

   3: // theStream is some audio stream you've retrieved

   4: // from a source

5:

   6: SoundEffect se = SoundEffect.FromStream(theStream.Stream);

   7: se.Play();

Hopefully this will be a welcome addition for those working with audio. You can also control the volume, pitch, etc. in the SoundEffect class.

Video: Pete Brown demonstrates low-latency sound

We also introduced a new feature that some affectionately call the “training video” feature. Technically it’s called TrickPlay or variable speed playback. This allows you to set a playback speed/rate on your MediaElement from 0.5-2 (where 1 is the normal playback of your media). The idea is that you’d get media playback at your chosen speed but also proper audio pitch correction. The code couldn’t be simpler:

   1: protected void SpeedUpTrainingButtonClicked(object sender, RoutedEventArgs args)

   2: {

   3:     trainingVideoMediaElement.PlaybackRate = 1.8;

   4: }

For the beta, the audio pitch correction isn’t yet available so when setting the PlaybackRate you’ll only see the video effect right now.

We have also enabled hardware decode for H.264 playback in this release!

^ back to top

Text

We’ve made a few improvements to the Text stack. We’re introducing a RichTextBoxOverflow element that will allow you to have linked text containers where the text flows to another element. This will help with automatically laying out text in situations like mulit-column. Here’s a snippet of what it might look like using element binding:

   1: <StackPanel Width="200">

   2:     <RichTextBox Width="50" Height="50"

   3:         OverflowContentTarget="{Binding ElementName=OverflowArea}">

   4:         <Paragraph>

   5:             This is some really long text that won't fit right into the main RTB control and should overflow into the area that I've defined in my XAML to be the other section.

   6:         </Paragraph>

   7:     </RichTextBox>

   8:     <RichTextBoxOverflow x:Name="OverflowArea" />

   9: </StackPanel>

This would render:

For the typography-philes in the Silverlight world, we’re adding tracking and leading support. If those terms are foreign to you, you are not alone! They basically provide more control over character spacing when text is rendered. Example:

   1: <RichTextBox FontSize="12" CharacterSpacing="300" />

Would look like:

A few things that we’re working on that aren’t in in the beta right now but we’re working on are improving text clarity using pixel-snapping and enhanced OpenType support. Some of these were demonstrated at MIX so be sure to watch the keynote and session videos!

Video: Pete Brown demonstrates text in Silverlight 5

^ back to top

Data Binding

There are a few features that I categorize in this area of data binding. They may all not directly be related, but I mentally put them in this category. First we now support Implicit DataTemplates. What this means is that you can specify a DataTemplate for a specific type in your binding. Let’s use a simple example. Let’s say I have an object Person which has FirstName, LastName, Title. I now have another object called Manager, which inherits from Person and Employee which also inherits from Person. If I was binding to a list box and wanted to list these people I could do something like this:

Class Code:

   1: void MainPage_Loaded(object sender, RoutedEventArgs e)

   2: {

   3:     List<Person> people = new List<Person>();

4:

   5:     people.Add(new Manager() { FirstName = "Scott", LastName = "Guthrie", Title = "VP" });

   6:     people.Add(new Employee() { FirstName = "Tim", LastName = "Heuer", Title = "Minion" });

   7:     people.Add(new Manager() { FirstName = "Steve", LastName = "Ballmer", Title = "CEO" });

   8:     people.Add(new Employee() { FirstName = "Scott", LastName = "Hanselman", Title = "Open Source Fanatic" });

9:

  10:     PeopleList.ItemsSource = people;

  11: }

XAML:

   1: <ListBox x:Name="PeopleList">

   2:     <ListBox.Resources>

   3:         <DataTemplate DataType="local:Manager">

   4:             <Border Background="LightBlue">

   5:                 <StackPanel Orientation="Horizontal">

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

   7:                     <TextBlock Text="{Binding LastName}" />

   8:                 </StackPanel>

   9:             </Border>

  10:         </DataTemplate>

  11:         <DataTemplate DataType="local:Employee">

  12:             <Border Background="Bisque">

  13:                 <StackPanel Orientation="Horizontal">

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

  15:                     <TextBlock Text="{Binding LastName}" />

  16:                 </StackPanel>

  17:             </Border>

  18:         </DataTemplate>

  19:     </ListBox.Resources>

  20: </ListBox>

which would render:

This flexibility allows me to use binding on same shaped objects, but provide unique characteristics in my template where appropriate.

Video: Pete Brown demonstrates Implicit DataTemplates

Ancestor RelativeSource binding is also now supported which allows a DataTemplate to bind to a property of the element that contains it, like:

   1: <UserControl x:Class=”MyApplication1.UserControl1”

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

   3:             xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”>

   4:     <ContentControl Tag=”SomeValue”>

   5:         <HeaderdContentControl>

   6:             <HeaderedContentControl.Header>

   7:                 <TextBlock Text=”{Binding Tag, RelativeSource=

   8: {RelativeSource,AncestorType=ContentControl, AncestorLevel=2}}” />

   9:             </HeaderedContentControl.Header>

  10:             <Button>Click Me!</Button>

  11:         </HeaderdContentControl>

  12:     </ContentControl>

  13: </UserControl>

This has been a highly requested feature as well!

How about some custom MarkupExtensions? Yes, that’s available now as well! This will help with those who follow the MVVM pattern of development as well as those who have been yearning to be able to have their own expressions run on markup. I’ve also thought people could use this to scaffold localization efforts as well around a MarkupExtension. Maybe something like:

   1: <TextBlock Text="{local:ResourceLookup Path=MyResourceKey}" />

I think this will be a useful feature. Of course you are required to actually write code for your extension!

Also in the beta is the ability to perform binding in Style setters. These are some great improvements to our markup/binding story and features which you have been asking for so I can’t wait to see how they are used!

^ back to top

Controls

This is another general category I am including some features which are available in Silverlight 5.

First is what we call ClickCount. This will help with basically doing the double-click tracking on elements in your application:

   1: private void CheckClick(object sender, MouseButtonEventArgs e)

   2: {

   3:     if (e.ClickCount == 2)

   4:     {

   5:         // double-click happened

   6:     }

   7: }

Video: Pete Brown demonstrates ClickCount usage

Next is multiple-window support. This is the same Window element that the MainWindow shares and you are able to create numerous Windows that your application can interact with and show as separate windows in the OS. This is not a ChildWindow implementation where they are all within the main object. This feature is available to out-of-browser applications. Once the main application is closed, all the Windows created from that will close as well.

Video: Pete Brown demonstrates multiple Windows

^ back to top

3D Graphics API

One of the coolest demos at the Silverlight Firestarter was the 3D demonstrations. I don’t even claim to be close to a novice on 3D graphics, but I can’t wait to see what people do with the 3D APIs. I would keep a watch on Rene Schulte as I’m positive he’ll have some cool stuff come out! It’s hard to show a short snippet of 3D but here’s some effects you’ll be able to do:

Be sure to watch out for more examples here to understand the capabilities.

Check out Rene Schulte and Andy Beaulieu for some good examples. Here are some teasers:

^ back to top

Trusted Applications in Browser

A new feature we are bringing is the ability to do some of the “trusted” features in Silverlight in the browser. This brings the current functionality of trusted applications in current form to be used in the browser context without having to be installed. This still requires the XAP to have the ElevatedPermissions security setting in the manifest as it would exist with out-of-browser applications as well as the XAP being signed (and the certificate in the user’s trusted publisher store).

Additionally the requirement would be that a registry key be set on the machine to enable this. This could be deployed via Group Policy or other desktop-management techniques. Once these are in place, the application can take advantage of the elevated permissions feature set introduced in Silverlight 4, including things like full keyboard access in full-screen mode.

^ back to top

Trusted Applications Out-of-browser Enhancements

In addition to the new multiple Window support, trusted out-of-browser applications can now access the broader file system outside of the user’s “My Documents” type areas on the disk. We hope this provides greater flexibility in the most trusted application area.

^ back to top

General “stuff”

In addition to the features noted above, here’s some things that are also included that I chose not to put in one of these categories and are implemented in the Silverlight 5 beta:

Startup performance improvements on multi-core systems (multi-core JIT)
ComboBox with type-ahead searching
DefaultFileName in SaveFileDialog!!!
Improvements in the graphics stack brought over from the Windows Phone codebase
Hardware acceleration in Windowless mode in Internet Explorer 9

You may be realizing there was a lot more shown at MIX keynote and will be discussed. You’d be right. There are a number of things we are still refining that aren’t in the current beta such as:

Vector printing
Power awareness for things like full-screen apps (i.e., don’t put me to sleep if I’m watching an awesome movie)
Remote control support allowing users to control media playback
OpenType support as previously mentioned
Text clarity improvements with pixel snapping as previously mentioned
A new DataContextChanged event
WS-Trust support for services
64-bit support for the plugin
COM interop for trusted in-browser applications
P/Invoke for trusted applications
PivotViewer control improvements and distributed in the SDK

As you can see we’re still going to be busy and hope that you like what you see so far!

^ back to top

Summary and Feedback

Now you have some new toys to play with. If you’ve read all this post then your tools should have been done downloading now, so go install them, watch some of Pete’s videos linked here and learn about the new features. If you find issues please be sure to report the feedback (it is better to report bugs/issues via the official channels than as a comment here). Also be sure to read the changes document to get an idea of how any changes may affect your applications.

Congratulations to the Silverlight 5 team (be sure to say hello to them at MIX if you are there) and we hope you like what you see and the direction we’re going to enable features you’ve been asking for in the platform.

Hope this helps!

tags: silverlight 5, silverlight, mix11, sl5

This work is licensed under a Creative Commons Attribution By license.

Visual Studio Template Behavior Research

Tim Heuer — Thu, 17 Mar 2011 15:30:41 GMT

I’ve been working on some stuff around templates lately and had my own opinions of some of the value of certain features of the Visual Studio template functionality. What I’m speaking of here is when you choose File…New Project or on an existing project Add Item. Both of those show you a list of templates. When you select one most typically you get new files in your project. It is one area of Visual Studio that is the simplest to extend and provide specific templates for your developers.

There is an option for template developers to specify what, if any, files are open by default once the template is added. Using Silverlight as an example, when you create a new project you’ll see that the default MainPage.xaml file is opened for you in the designer. I wanted to get a feeling of what developers thought of this functionality. Help me with some research?

Your browser doesn't support iFrames :( Vote for this poll here.

This is, of course, totally un-scientific and I just wanted to get a litmus test of what people thought of that functionality (opening files by default, not just the concept of templates). Thanks in advance for helping out!

tags: visual studio, vs2010, silverlight, riaservices, expression, templates

This work is licensed under a Creative Commons Attribution By license.

Silverlight 4 February 2011 Update Released Today

Tim Heuer — Mon, 14 Feb 2011 20:19:12 GMT

Today (at approximately 10:00 AM PST) our team released an update to the Silverlight 4 runtime. This update, dubbed internally as “GDR3,” provides an update in the following key areas (KB2495644):

Timestamp issues with media playback and VC-1 codec
Visual Studio IDE crash when profiling a Silverlight application which has a pixel shader
Enabling Silverlight to run as a 32-bit process in 64-bit Firefox on OSX
DRM fixes for a “6207” error when playing protected content after upgrading to a version of Silverlight
Memory leak fixes with regard to the use of in-line DataTemplate
Out-of-browser applications failing to update if the application name was changed
Media playback error when the media streams have redirect information
Improving network latency (KB2505882)

Many readers of this blog will likely zero in on the memory leak fix here. The issue is discussed/debated/ridiculed ad nauseam on the forums relating to this issue. If your customer applications are facing this issue and you chose not to apply one of the two workarounds, then you want to encourage your customers to upgrade to this release. This can be done using the minimum runtime version attributes in your <object> tags where you use Silverlight. This will prompt the user for an upgrade. Of course, I’ve stated my opinion many times before that this should be a customized experience and we’ve even provided sample code to do so in our installation experience whitepaper.

‘I noticed <your-favorite-bug/feature> isn’t fixed here’

Each service release doesn’t fix our backlog completely. If there is an issue you are seeing with Silverlight after applying this update, please, please, please log a bug on the product. Don’t assume someone else has. There is a specific way you can log a product bug on Silverlight as I’ve outlined in this post: Ways to give feedback on Silverlight. The ideal bug is one that is detailed, reproducible, and provides an actual repro project/sample. This is the fastest route to getting a bug understood and evaluated.

Getting the update

As with all service updates, this update will be made available to customers via Microsoft Update. If you are a developer and don’t want to wait, you can download the bits here (please be aware network propagation across the globe might take a few hours):

Silverlight runtime (end-user)
Silverlight developer runtime: Windows or Mac

There is NO SDK update for this release. As a developer you only need to update the developer runtime on your machine to continue enabling Silverlight development but to also have the new runtime on your machine as a user as well. Please note that by you, the developer, simply having the updated dev runtime doesn’t “force” your apps to use it. This is controlled by using the minRuntimeVersion flags in your <object> tag to trigger what the minimum requirement is for your application.

Hope this helps!

tags: silverlight, gdr, gdr3, datatemplate

This work is licensed under a Creative Commons Attribution By license.

Silverlight Toolkits now on NuGet

Tim Heuer — Thu, 10 Feb 2011 20:55:25 GMT

Last night after a quick e-mail exchange with Phil, David and Scott I revised my Silverlight Toolkit “NuPack” packages I had previously created when NuPack NuGet first came out. At the time there were a couple of things still not supported and frankly, I got busy and never bothered to check back. Scott had seen something on a forum inquiring why Silverlight stuff, namely our open source controls, aren’t deployable via NuGet. There wasn’t any other reason other than resources not currently scheduled to add this to the build flows, etc. So I spent a few minutes revising the packages and putting them up there:

What you see above is the “Add Library Package Reference” results after you install NuGet. Now instead of having to install an MSI, etc. you can basically add a reference to the package and the bits will be copied to your project and automatically referenced. In order to componentize the main Silverlight Toolkit, I created the NuGet packages in a way that they can be individually consumed, or a meta-package as “All.” It’s cool that NuGet allows you to create a meta-package which is basically a dependency graph. For instance, my “all” package has zero content…but here is the .nuspec contents:

   1: <?xml version="1.0" encoding="utf-8"?>

   2: <package>

   3:   <metadata>

   4:     <id>SilverlightToolkit-All</id>

   5:     <version>4.2010.04</version>

   6:     <authors>Microsoft</authors>

   7:     <description>The complete Microsoft Silverlight Toolkit.  Details at http://silverlight.codeplex.com</description>

   8:     <language>en-US</language>

   9:     <licenseUrl>http://silverlight.codeplex.com/license</licenseUrl>

  10:     <projectUrl>http://silverlight.codeplex.com/</projectUrl>

  11:     <dependencies>

  12:       <dependency id="SilverlightToolkit-Core" version="4.2010.04" />

  13:       <dependency id="SilverlightToolkit-Data" version="4.2010.04" />

  14:       <dependency id="SilverlightToolkit-DataViz" version="4.2010.04" />

  15:       <dependency id="SilverlightToolkit-Input" version="4.2010.04" />

  16:       <dependency id="SilverlightToolkit-Layout" version="4.2010.04" />

  17:       <dependency id="SilverlightToolkit-Theming" version="4.2010.04" />

  18:     </dependencies>

  19:     <title>Silverlight Toolkit - All</title>

  20:     <owners>Tim Heuer</owners>

  21:     <iconUrl>http://silverlight.microsoft.com/assets/sl-32.png</iconUrl>

  22:     <tags>silverlight toolkit sltoolkit</tags>

  23:   </metadata>

  24: </package>

It’ basically defines the pointers to what it needs and NuGet does the magic to manage the dependencies on install. For the Silverlight for Windows Phone Toolkit, we also have icons. NuGet allows me to package up those icons as well so that when the package gets added, so do the icons (NOTE: there is still a step to mark them as content in the project). I point this out because when the phone toolkit first came out some of the samples weren’t working for people because they didn’t read that they had to actually include some icons to get them to work. Using NuGet, at least we’re able to help them even further.

I really like this model. I love that I can use a familiar “Add Reference” gesture in Visual Studio, but I can also use a PowerShell VS window to do my package management as well if I wanted. Take a look at the NuGet stuff and if you are a Silverlight developer, now you have everything easily at your fingertips!

NOTE: The version numbers in the toolkit packages are package version numbers. We’ve never really promoted the toolkit versions as they literally are (i.e., 4.0.31319.blah) but rather as the release timeframe i.e., “April 2010” release. Because NuGet follows CLR versioning taxonomy I created the package versions to hopefully be somewhat descriptive: 4.2010.04 – For Silverlight 4, April 2010 release – as an example. It’s not perfect, but it works.

NuGet has over 670 packages now in the repository with an amazing set of tools readily available at your fingertips. There are some good Silverlight nuggets in there as well and it is nice to have our toolkits in there now also! When updates come out, the Library Package Manager will show the updates, giving the developer the option to update them quickly.

Hope this helps!

tags: nuget, nupack, oss, silverlight, toolkit, expression, riaservices

This work is licensed under a Creative Commons Attribution By license.