Silverlight and Windows Phone SDK

Windows Phone Design Guidelines on MSDN

Cheryl Simmons - MSFT — Thu, 02 Feb 2012 06:18:07 GMT

It was recently brought to my attention that we have done a poor job of evangelizing the Windows Phone Design Guidelines on MSDN. These guidelines were previously available in PDF format, but a few months ago a couple of folks worked really hard to bring these to MSDN. Given the success of one of my previous posts, the design cheat sheet, I would guess that developers are looking for these design guidelines presented in an easy-to-consume format.

Along the lines of easy to consume are the control design guideline topics. There are design guideline topics for most controls that ship with the Windows Phone SDK. These topics typically contain an image of the control and describe the standard appearance of a control and its standard use. The best part of these topics, in my opinion, is the Design Guidelines section that lists the important points you need to remember when using the control in your UI. The following images show parts of the topic for the Button control.

So please, check out these topics and let us know what you think. Post a comment to this post or just use the feedback mechanism on the MSDN page.

--Cheryl

Updates to the Windows Phone docs

Cheryl Simmons - MSFT — Tue, 20 Dec 2011 18:10:47 GMT

We recently made a refresh of the Windows Phone documentation and samples. We've updated several samples:

Background Agent
Background Transfer Service
Quick Card
Search Extensibility

We also added the following new sample that shows how to use types in the NetworkInformation namespace to get the network status of the device, mobile network and other information.

Network and Device Information

To get the latest samples go to the Code Samples page on MSDN.

In addition, we made fixes to several docs, some based on your feedback on UserVoice. For example, we added links to the camera sample from the camera docs. Please keep your feedback coming and we'll keep updating and making changes!

Muted audio even when the playback rate is set to a supported audio playback rate

Nitya Ravi — Mon, 19 Dec 2011 18:28:00 GMT

Silverlight 5 supports multiple playback rates. When the playback rate is set to a rate that does not support audio playback, audio will be muted. If playback is reset back to 1 or to any value that supports audio playback after multiple rates that don’t support audio/pitch correction playback, the audio could still be muted.

To work around this issue, you can reset the volume when the playback rate is changed. The following code demonstrates one way to reset the volume.

void ME_RateChanged(object sender, RateChangedRoutedEventArgs e)

{

// For playback rates that support audio playback, Enforce audio playback by resetting the MediaElement Volume property

//to unmute audio after multiple playbackRate changes.

if (e.NewRate <= 2 && e.NewRate >= 0.5)

{

ME.Volume = ME.Volume;

}

-Nitya.

Don't forget about the databinding features of Silverlight 4 that you get with Mango!

Cheryl Simmons - MSFT — Fri, 16 Dec 2011 23:55:00 GMT

If you are a Windows Phone developer, there are some properties offered on the Binding object in SIlverlight 4, which is supported by Mango. Thse properties were not offered in Silverlight 3/Windows Phone OS 7.0. The SL4 binding properties make setting up control bindings much easier and help you avoid using a value converter in many cases.

You can set a StringFormat value on the binding to format your string in many common formats such as currency, date, time, etc . For example, if you want the string to be formatted like currency, your binding would look like this:

Text="{Binding StringFormat=C}"

The docs for StringFormat could use some work (don't worry--I've filed a bug and they should get fixed for the next update), but meanwhile look at the following topics for more information about what your format strings should look like:

Standard Format Strings

Date Format Strings

You can also set the FallbackValue property that is used when the binding can't return a value. In other words, this value will display in the UI when the binding doesn't resolve.

Text="{Binding Name, FallbackValue=No Value}"

And finally set the TargetNullValue to display a value when the underlying source value is null or nothing.

Text="{Binding Name, TargetNullValue=n/a}"

All of these properties will show in Intellisense and speed development for you.

Enjoy!

--Cheryl

Silverlight 5 has released! The docs are up and a .chm is available

Cheryl Simmons - MSFT — Fri, 09 Dec 2011 20:51:00 GMT

Silverlight 5 has released! Here's the link to download the Silverlight 5 tools.

Silverlight 5 offers many new features including:

PivotViewer control
Trusted applications in-browser
3D graphics
Vector printing
Improved text rendering including the RichTextBlock control.
Hardware decode of H.264 media

For a detailed list of the new features see the Silverlight content on MSDN, specifically, the What's New for Silverlight 5 topic.

If you prefer your docs offline, here's the link to download the .chm containing Silverlight 5 docs.

Enjoy!

Cheryl

Tip for Using HyperlinkButton or Hyperlink in Silverlight for Windows Phone

Cheryl Simmons - MSFT — Tue, 25 Oct 2011 23:14:00 GMT

If you’ve tried unsuccessfully to use the HyperlinkButton control or the Hyperlink type in your Silverlight for Windows Phone applications, I have a tip for you.

In Silverlight for Windows Phone you must always set the TargetName property to a value for the control to successfully navigate to the URL specified by NavigateUri when the hyperlink control is clicked. It doesn’t really matter what you set TargetName to, it just must be set. If you set TargetName and click the hyperlink control, the web browser will display with the correct page.

Here’s an example:

This is different than the behavior for Silverlight for the desktop. On the desktop, you don’t need to explicitly set TargetName. If you do set it, the behavior is similar to the standard HTML TARGET attribute.

HTH

--Cheryl

Windows Phone Mango release and we want your feedback!

Cheryl Simmons - MSFT — Wed, 28 Sep 2011 17:31:00 GMT

The Windows Phone Mango updates are going out to handsets, and the RTM version of the Mango SDK is now available. In addition, the Marketplace is now available on the web. Check it out here.

You can get the Windows Phone 7.1 SDK from the download center. In addition, the docs and samples have been updated and finalized for this release as well. You can check out all the docs here. If you are just getting started building apps for Mango, you might what to check out the What's New in the Windows Phone SDK.

As we look forward to future releases, we would really love your feedback about the documentation and samples. Visit the Windows Phone Documentation UserVoice site to give us your feedback and vote on issues.

Thanks and enjoy!

Cheryl

pInvoke in Silverlight5 and .NET Framework

Alexandra Rusina — Tue, 27 Sep 2011 18:06:24 GMT

One of the new features in Silverlight 5 RC is the ability to call native code including Win32 APIs through platform invocation, or pInvoke.

The technology itself is pretty well-known and it’s been in .NET since version 1.0. Here is one of the tutorials for .NET that explains what pInvoke is about. So instead of explaining what pInvoke is, let me concentrate on how this feature works in Silverlight 5 and what differences with .NET you might expect.

First of all, calling native APIs is available only in full-trust applications. This is a security restriction; there is simply too much power in Windows APIs for a partial-trust Web application to have. The good news is that Silverlight 5 allows your application to be full trust and consequently use pInvoke in both in and out of the browser. One more restriction is that pInvoke is available only on Windows, there is no Mac support.

To get the things going, let me first re-introduce an example that Nick Kramer first presented at MIX. It shows how you can detect a removable drive (think about USB sticks or card readers). You click a button, and the program tells you whether you have a removable drive and if yes, what letter it’s assigned.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Runtime.InteropServices;

namespace SamplePInvoke
{
    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();
        }

        // Import native method.
        [DllImport("kernel32.dll")]
        static extern int GetDriveType(string lpRootPathName);

        private void detectDrive_Click(object sender, 
                                       RoutedEventArgs e)
        {
            String[] drives = new string[] 
                { @"c:\", @"d:\", @"e:\", 
                  @"f:\", @"g:\", @"h:\", @"i:\" };
            bool driveInserted = false;
            string driveLetter = "";
            foreach (String drive in drives)
            {
                // Calling the native method. 
                // “2” means that the drive is a removable drive.
                if (GetDriveType(drive) == 2)
                {
                    driveInserted = true;
                    driveLetter = drive;
                }
            }
            if (driveInserted)
                textBlock1.Text = "Removable drive is " + driveLetter;
            else
                textBlock1.Text = "No removable drive";
        }
    }
}

As I mentioned already and as you can see from the example above, in most cases the feature works exactly the same as in .NET. This code is basically identical in both Silverlight and WPF.

However, there are also some differences as well, so keep on reading.

Marshaling

For marshaling, many applications use the methods from the System.Runtime.InteropServices.Marshal class. But you might notice that .NET and Silverlight versions of this class have different number of methods. As usual, Silverlight provides you with only a subset of the full .NET, which we believe represents the most used part. In fact, this is the same set of methods Silverlight itself uses for native interop and it is usually sufficient.

Many of the methods from the Marshal class in the full .NET Framework are just managed wrappers around native APIs. Often, if you can’t find a certain method from the Marshal class in Silverlight, you can use the native API directly.

For example, the method Marshal.AllocHGlobal exists in .NET and doesn’t exist in Silverlight. However, this method is just a wrapper around the Win32 LocalAlloc function from Kernel32.dll. So you need to call this native function directly instead of its managed wrapper and refactor you code accordingly.

[DllImport("kernel32.dll", EntryPoint = "LocalAlloc")]
internal static extern IntPtr LocalAlloc_NoSafeHandle(
    int uFlags, IntPtr sizetdwBytes);

Usually, you can find what native method is being wrapped in the documentation of the managed method itself.

Reverse pInvoke Calls

In the first example in this article, the only call I make is from managed code to native code. However, sometimes you need to do the opposite: call a managed method from within the native code. It usually happens when a native method uses a callback or accepts a pointer to a function as one of its parameters and you want to use your managed method for this callback.

In the full .NET such reverse calls and direct calls are treated the same. In Silverlight, however, you need to explicitly specify the “entry points” for reverse pInvoke calls by using the AllowReversePInvokeCalls attribute. Basically, all you need to do is to apply this attribute to managed methods that need to be called from the native code.

Here is an example. Consider that you have the following C++ method:

typedef int (*NumberSource) (void); 

int MultiplyByTen(NumberSource numberSource)
{
      int returnValue = numberSource() * 10;
      return returnValue;
}

This sample method takes a pointer to a function returning integer as a parameter and multiplies the function’s return value by 10.

In managed code, I need to declare this method as follows:

[DllImport("testCPlusPlus.dll")]
static extern int MultiplyByTen(NumberSource src);

public delegate int NumberSource();

Note that instead of the function pointer I use a delegate. Again, this is identical to what you would do in the full .NET. Next, I create a managed method and pass it to the native method through a delegate binding.

public int ManagedSource()
{
    return 42;
}

public MainPage()
{
    InitializeComponent();
    int res = MultiplyByTen(new NumberSource(ManagedSource));
}

This code works fine in the full .NET, but in Silverlight the last line throws a security exception with the following message:

Delegate 'SilverlightApplication1.MainPage+NumberSource' must be bound to a method in a fully-trusted assembly and the method must have the AllowReversePinvokeCallsAttribute.

To fix this problem, all I need to do is apply the AllowReversePinvokeCalls attribute to the ManagedSource method.

[AllowReversePInvokeCalls]
public int ManagedSource()
{
    return 42;
}

This feature is just an additional security measure, so you can have better control over what managed methods can and cannot be called by native APIs.

Processing Window Messages

Anybody familiar with Win32 API probably knows that Windows sends different messages to each registered window through the WindowProc function. For example, it sends messages whenever a USB device is inserted or removed.

In WPF and even in Windows Form, you could take an existing window or subclass a Window class and override its WndProc method. However, in Silverlight the Window class doesn’t expose this method. One way to solve this problem is to define a hidden window by using native APIs. Here is another code example that detects the removal and insertion of a USB.

public partial class MainPage : UserControl
{

// Importing a set of necessary native methods from Win32 API.
[DllImport("User32", EntryPoint = "CreateWindowEx", 
    CharSet = CharSet.Auto,SetLastError = true)]
static extern IntPtr CreateWindowEx(int dwExStyle, 
    string lpszClassName, string lpszWindowName, int style, 
    int x, int y, int width, int height,
    IntPtr hWndParent, IntPtr hMenu, IntPtr hInst,
    [MarshalAs(UnmanagedType.AsAny)] object pvParam);

[DllImport("user32.dll")]
static extern IntPtr DefWindowProc(IntPtr hWnd, int uMsg, 
    IntPtr wParam, IntPtr lParam);

[DllImport("user32", CharSet = CharSet.Auto, SetLastError = true)]
public static extern short RegisterClass(WNDCLASS wc);

// Marshaling the Window structure.
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public class WNDCLASS
{
    public int style;
    public WndProc lpfnWndProc;
    public int cbClsExtra;
    public int cbWndExtra;
    public IntPtr hInstance;
    public IntPtr hIcon;
    public IntPtr hCursor;
    public IntPtr hbrBackground;
    public string lpszMenuName;
    public string lpszClassName;
}

//system detects USB insertion/removal
const int WM_DEVICECHANGE = 0x0219;
// system detects a new device
const int DBT_DEVICEARRIVAL = 0x8000;
// device removed
const int DBT_DEVICEREMOVECOMPLETE = 0x8004;

// Callbacks must have AllowReversePInvokeCalls attribute.
[AllowReversePInvokeCalls]
private IntPtr Callback(
    IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam)
{
    if (msg == WM_DEVICECHANGE)
    {
        if (wparam.ToInt32() == DBT_DEVICEARRIVAL) 
            textBlock1.Text = "USB inserted";
        if (wparam.ToInt32() == DBT_DEVICEREMOVECOMPLETE) 
            textBlock1.Text = "USB removed";
    }
    return DefWindowProc(hWnd, msg, wparam, lparam);
}

public delegate IntPtr WndProc(
    IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam);

// Preventing garbage collection of the delegate
private static WndProc dontGCthis;

public MainPage()
{
    InitializeComponent();

    WNDCLASS wc = new WNDCLASS();

    // Preventing garbage collection of the delegate
    dontGCthis = new WndProc(Callback);
    wc.lpfnWndProc = dontGCthis;

    // Note that you need to ensure unique names 
    // for each registered class.
    // For example, if you open the same plugin 
    // in two different tabs of the browser,
    // you still should not end up with 
    // two registered classes with identical names.
    wc.lpszClassName = "foobar" + (new Random()).Next();

    RegisterClass(wc);

    IntPtr createResult = CreateWindowEx(0, wc.lpszClassName, 
        "Window title", 0, 100, 100, 500, 500, 
        IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, 0);
}
}

This example prints to a text block when a USB device is removed or inserted. Note that if you use the same code in WPF, it will work just fine. However, it’s important to remember that porting your existing pInvoke code from WPF to Silverlight might require some extra work (as usual).

More Examples

There were several good articles about pInvoke already written after Silverlight RC. I just wanted to share the list, since there never can be too many code examples, especially when you are dealing with such advanced topics as interop between managed and advanced code.

Silverlight 5 RC Released - Using PInvoke by Jeremy Likness
A very simple article that shows how to call MessageBeep. The article takes you through initial marshaling concepts and introduces some best practices for interop coding.
Silverlight 5 PInvoke fun - System Font Dialog by Peter Kuhn aka Mister Goodcat.
Another good article for beginners, but with a more advanced example showing how to load system fonts.
Enumerating MIDI Interfaces using Silverlight 5 PInvoke by Pete Brown.
I liked this one, since working with devices is one of the primary scenarios for pInvoke in Silverlight 5.

Silverlight 5 RC support for application-restricted media

Cheryl Simmons - MSFT — Thu, 08 Sep 2011 00:20:00 GMT

Application restricted media (ARM) is new feature in Silverlight 5 RC that enables content providers to ensure their content under digital rights management (DRM) is consumed only by Silverlight applications they authorize.

This enables experience protection of DRM’d content, which is particularly useful for media that contains revenue-generating ad content.

To enable ARM for an application you must sign your content using an Authenticode x.509 certificate. You can use signtool.exe, which you also use to create a Silverlight trusted application, although the Silverlight application consuming content does not have to be a trusted application. For example, you could a command like the following:

signtool sign /v /f certificateFile.pfx fileToSign

You can also use the signing mechanism in Visual Studio to sign your application. The following image shows the Signing tab in Visual Studio, which you access from Project Properties:

To learn more about DRM content in general, see Digital Rights Management.

--Cheryl

Silverlight 5 RC has released!

Cheryl Simmons - MSFT — Thu, 01 Sep 2011 07:01:00 GMT

The SL5 RC has released and you can now download the tools here.

This is an exciting release and brings many new features to Silverlight. Following are just a few of the new features. You can check out more details in the What's New for Silverlight 5 topic on MSDN.

PivotViewer control, which adds support for dynamic client-based collections, XAML-based visuals, and
customizability.
Data binding improvements such as a DataContextChanged event and PropertyChanged added to the UpdateSourceTrigger enumeration
3D: Improvements to the 3D support added in SL5 beta. This includes XNA built-in effects, surface composition settings for depth and stencil buffers and mult-sample anti-aliasing
File access: OpenFileDialog offers a DefaultDirectory property and SaveFileDialog offers a DefaultFileName property
Printing: SL5 now supports vector printing in addition to the bitmap printing offered in SL4.
Remote control event support added with the MediaCommand event on UIElement.
Application restricted media: Enables content providers to ensure DRM'd content is only consumed by SL applications they authorize. More about this feature in an upcoming blog post.
Support for OpenType and pixel-snapped text.

The docs are updated with Silverlight 5 RC content, and you can get the chm here.

--Cheryl

Get the tools and submit your Mango apps!

Cheryl Simmons - MSFT — Tue, 23 Aug 2011 16:51:22 GMT

Windows Phone SDK 7.1 RC is now available. You can use this version of the tools to create Windows Phone Mango apps and submit them to the marketplace.

You need to uninstall previous versions of the tools before installing this version.

These tools enable you to create Mango-targeted applications that include all the new Mango features. In addition you get some new tools such as the isolated storage explorer for viewing and debugging files in isolated storage, the memory profiler, an addition to the performance analysis suite, and the Marketplace Test Kit, which enables you to assess the marketplace readiness of your application before you submit it to the marketplace. There is also a great new emulator screen-shot tool that makes it easy to complete those final steps for marketplace submission.

The tools are here, and the marketplace is open....now is the time to get on board with Mango.

--Cheryl

Ensuring your Windows Phone Applications Work on Mango

Cheryl Simmons - MSFT — Fri, 22 Jul 2011 16:13:00 GMT

Not only does Mango support Silverlight 4, there are also numerous updates and improvements to Silverlight for Windows Phone. A bunch of work has gone into compatibility between Mango and Windows Phone 7, however you should test your existing applications on Mango, to make sure they behave as expected.

There are a few known differences in the behavior of Silverlight API in comparison to the same API in Silverlight on Windows Phone 7. When the docs are published for Mango, you will be able to see these changes in the Version Notes section of the relevant API page. Following is an example of the Version Notes calling out a difference in Windows Phone OS 7.1.

One problem is of course is that you are probably testing your applications on Mango now, and may encounter unexpected behavior, and waiting until the docs publish isn’t the best solution. In the meantime, I’ll list the current known Silverlight for Windows Phone issues here.

Controls

Image and MediaElement controls in a list

In Windows Phone OS 7.1, scrolling performance was improved. However, if you display several Image or MediaElement controls in an ItemsControl (most importantly the ListBox), you might notice issues with scrolling. In some cases, the list may scroll faster than the images can load, causing flickering in the UI. If this occurs consider loading the images on a background thread. For more information on how to do this, see Off-Thread Decoding of Images, on the Silverlight for Windows Phone Performance Team blog. Finally, make sure that you test the scrolling behavior on a Windows Phone device.

(As a side note, if you are Windows Phone developer, you should be reading the Performance Team blog on a regular basis. Great info there.)

ScrollViewer

In Windows Phone OS 7.1, when you set the content indirectly for the ScrollViewer, such as with a ContentPresenter, you should call UpdateLayout prior to calling ScrollToVerticalOffset or ScrollToHorizontalOffset; otherwise, an exception will occur.

To improve scrolling performance some events, properties and methods you had access to from the ScrollViewer are now handled by the system. Check out this post on the Performance Team blog to get more details.

TextBox

In Windows Phone OS 7.1, when you set the FontFamily property to a font that is downloaded or contained in a file, the TextBox renders at the position (0,0). When the font has finished downloading the application renders again with the TextBox in the correct location.

VirtualizingStackPanel

In Windows Phone OS 7.1, when you set a RenderTransform as a child of the VirtualizingStackPanel, it is returned as a CompositeTransform, regardless of the actual transform that is applied.

Navigation

NavigationEventArgs

In Windows Phone OS 7.1, if you use the NavigationEventArgs constructor to create a NavigationEventArgs and pass null for the uri parameter, when accessed later the Uri value returned will be empty Uri.

Media

Image and MediaElement controls in a list

WriteableBitmap

In, Windows Phone OS 7.1, when you specify a BitmapImage as the parameter for the WriteableBitmap constructor, you must set the CreateOptions property of the BitmapImage before you use it to construct the WriteableBitmap; otherwise, an exception will occur.

Networking

HttpWebResponse

In Windows Phone OS 7.1, if you compare the value of the HttpWebResponse.ContentLength property to -1 to determine if the ContentLength header is set on an HttpWebResponse, you should compare the value as a 64-bit and 32-bit integers. To do this, you should cast the value to a 32-bit integer and compare with -1, as well as comparing with -1 as a 64-bit integer. The following code example shows how to do this.

if (response.ContentLength == -1L || (Int32)response.ContentLength == -1)

{

// The ContentLength header is not set. Handle this appropriately.

}

I’ve also updated a few key conceptual topics with this information, and they will republish soon.

For control changes, see the Controls in Silverlight for Windows Phone topic and pay particular attention to the Compatibility Notes column of the table that lists controls.
For media changes, see the Media in Silverlight for Windows Phone topics
For networking changes, see Networking in Silverlight for Windows Phone.
For general behavior changes that don’t fit into a nice feature bucket, see the Differences between Silverlight and Silverlight for Windows Phone topic.

Finally, for changes to core Windows Phone features, see Windows Phone OS Application Compatibility topic.

--Cheryl

Mango Beta2…get it while it's fresh!

Cheryl Simmons - MSFT — Wed, 29 Jun 2011 17:15:00 GMT

The Mango Windows Phone Developer Tools Windows Phone SDK Beta2 released today (the tools have been renamed to SDK). With the beta2 release you will see some additions to the tools like the Isolated Storage Explorer, improvements to the profiler and emulator as well as numerous updates to the docs. You can get the Mango beta2 tools on the download site, and see the changes to the documentation on MSDN.

Additionally, if you are already a registered Windows Phone developer, you should get an invitation to install the Mango bits on one registered device. You can see the details of this on the Windows Phone Developer Blog.

Enjoy!

--Cheryl

Fuel Tracker sample application for WP7 now in Visual Basic

Karl Erickson — Mon, 20 Jun 2011 20:39:00 GMT

I'm happy to report that the Fuel Tracker sample is now available in Visual Basic as well as C#. Additionally, we have fixed several small issues that various people have reported, one of which prevented the application from working correctly when running under the Windows Phone Developer Tools 7.1 Beta. The accompanying documentation has not yet been updated, but will be in the near future.

Enjoy!

Karl Erickson
Silverlight User Education

New Addition to Windows Phone Quickstarts- Pivot and Panorama Controls

Nitya Ravi — Wed, 25 May 2011 18:51:00 GMT

Windows Phone 7 includes Panorama and Pivot controls that you can use to display controls and data and navigate through them using their built-in swipe and pan gestures.

To help you understand these controls we have added a new quickstart to our existing Windows Phone quickstarts collection- Panorama and Pivot Controls. This quickstart provides an overview of Pivot and Panorama controls, different ways to create these controls and suggests some best practices to keep in mind. Hope you find it useful!

-Nitya.

Windows Phone Developer Tools 7.1 Beta now available!

Cheryl Simmons - MSFT — Tue, 24 May 2011 20:44:00 GMT

The Windows Phone Developer Tools 7.1 Beta released today. Download them here. The tools enable you to get started developing applications for the next version of Windows Phone 7 Codenamed "Mango" and leverage new phone features while continuing to develop applications for Windows Phone OS 7.0. In addition to multi-targeting the tools offer some other great features:

Location data simulation in the emulator
Acclerometer data simulation in the emulator
Profiling tools
New templates to support SL/XNA content in the same application

Mango has numerous performance improvements such as fast application switching and the ability to run tasks in the background. In addition, Mango provides support for sockets and local database storage. For more information about the improvements and features in Mango, see What's New in Windows Phone Developer Tools. Mango also offers support for many of the features that were offered in Silverlight 4 such as improved data binding, RichTextBox and Viewbox controls, webcam and microphone capture. For more information about new features for Silverlight for Windows Phone, see What's New for Silverlight for Windows Phone.

Enjoy!

--Cheryl

Binding to Dynamic Properties with ICustomTypeProvider (Silverlight 5 Beta)

Alexandra Rusina — Tue, 26 Apr 2011 18:40:00 GMT

Silverlight 5 Beta introduces a new ICustomTypeProvider interface that enables data binding to objects the structure of which cannot be known until runtime. This is a common problem when you work with data in any format from databases to metadata or XML files to JSON objects. New attributes or new columns can be added over time and prior to Silverlight 5 you needed to update and recompile your source code if you wanted to show this new data through data binding in a Silverlight application.

With ICustomTypeProvider you can add properties to objects on the fly and then databind to these newly created objects. The interface is pretty simple:

public interface ICustomTypeProvider
{
    public Type GetCustomType();
}

When you implement the ICustomTypeProvider interface you need to return your own Type. Silverlight’s data binding engine now checks whether an object implements this interface or not. If the object does implement ICustomTypeProvider, the data binding engine uses your custom type instead of the System.Type.

Implementing ICustomTypeProvider

However, implementing this interface requires some effort. Here is the list of things to consider:

Create your own Type by deriving from System.Type.
Your new type needs to store its properties somewhere, so you need to create your own PropertyInfo by deriving from System.Reflection.PropertyInfo.
And don’t forget about INotifyPropertyChanged interface if you want your objects to work properly with the data binding.

In Silverlight 4 and earlier, you could not derive from System.Type or System.Reflection.PropertyInfo, but these APIs were changed in Silverlight 5 Beta. Here is the list of types that are now inheritable:

Creating a Helper Class

OK, implementing your own type and using reflection APIs might not be easy, but on the other hand it’s very flexible. What’s good is that you can write all this code just once and create a helper class that can be reused over and over.

I created such a helper class myself and you are free to use it in your code. This helper allows you to combine statically defined properties with dynamic ones. The Silverlight team is considering releasing this helper later as a part of the toolkit, so your feedback is really appreciated.

Just to be clear, the helper class is not a requirement for using this feature and you can handle things differently. Also, my implementation of the helper class is not the only possible implementation – you are welcome to change it according to your needs or write your own.

The structure of my helper class looks as follows:

public class CustomTypeHelper<T> : ICustomTypeProvider, 
                                   INotifyPropertyChanged
{
    private static List<CustomPropertyInfoHelper> _properties = 
        new List<CustomPropertyInfoHelper>();
    private Dictionary<string, object> _customPropertyValues;
    private CustomType _ctype;

    public event PropertyChangedEventHandler PropertyChanged;
    private void NotifyPropertyChanged(String info) {}
    
    public CustomTypeHelper() {}

    public Type GetCustomType()

    public static void AddProperty(String name) {}
    public static void AddProperty(String name, Type propertyType) {}
    public static void AddProperty(
         String name, Type propertyType, List<Attribute> attributes) {}

    public void SetPropertyValue(string propertyName, object value) {}
    public object GetPropertyValue(string propertyName) {}

    public PropertyInfo[] GetProperties() {}

    private class CustomType : Type {}

    private class CustomPropertyInfoHelper : PropertyInfo {}
}

You can download the source code for CustomTypeHelper<T> class and example of its usage. In this class, the list of properties is a static list, so that if you add a new property it will be added to all instances of this class. The values of properties for each instance are stored in the _customPropertyValues dictionary. The class is generic, so you can use it for different types (for example, create Customer and Product classes with their own sets of properties).

You might notice that this helper class doesn’t allow for removing or changing properties. The feature itself doesn’t prohibit this, but it is hard to handle changes in the structure of the existing objects in a generalized helper class. You’d better figure it out for each particular application. But once again, I am looking for your feedback and if you can think of common scenarios or envision some kind of a general solution, let me know.

Using a Helper Class

Let’s see how you can use such a class. Imagine that you have a DataGrid named dataGrid1 and you want to bind it to a collection of objects that can add new properties at runtime. There are two options for using the CustomTypeHelper<T> class. First, you can simply inherit it.

public class Customer : CustomTypeHelper<Customer>
{
    public String FirstName { get; set; }
    public String LastName { get; set; }
}

If you need to preserve your own class hierarchy, you can use the classic delegation pattern. In this case you need to implement the ICustomTypeProvider on your class and also create a property or a field of the CustomTypeHelper<T> class to which you can delegate all the calls.

public class Customer : ICustomTypeProvider
{
    public String FirstName { get; set; }
    public String LastName { get; set; }

    private CustomTypeHelper<Customer> helper = 
        new CustomTypeHelper<Customer>();

    // Redirect all method calls to the helper like shown below
    public Type GetCustomType()
    {
        return helper.GetCustomType();
    }

    public static void AddProperty(String name)
    {
        CustomTypeHelper<Customer>.AddProperty(name);
    }

    // ... Do the same for all other methods from CustomTypeHelper<T>
}

No matter whether you create your class through inheritance or by using the delegation pattern, you can use it for adding properties and data binding as shown below.

ObservableCollection<Customer> customers = new ObservableCollection<Customer>();

public MainPage()
{
    InitializeComponent();

    dataGrid1.AutoGenerateColumns = true;
    dataGrid1.ItemsSource = customers;

    Customer.AddProperty("Age", typeof(int));
    Customer.AddProperty("Married", typeof(bool));

    Customer customer1 = new Customer 
        { FirstName = "Mary", LastName = "Smith" };
    customer1.SetPropertyValue("Age", 40);
    customer1.SetPropertyValue("Married", true);

    Customer customer2 = new Customer 
        { FirstName = "John", LastName = "Smith" };
    customer2.SetPropertyValue("Age", 45);
    customer2.SetPropertyValue("Married", true);

    customers.Add(customer1);
    customers.Add(customer2);
}

As you can see, most of the reflection aspects can be hidden in the helper class and the public interface can be made pretty simple.

What about WPF and DLR?

Some of you might be familiar with the ICustomTypeDescriptor interface from WPF, which is solving the same problem as ICustomTypeProvider in Silverlight 5 (even the names are quite similar). So, why didn’t we simply add ICustomTypeDescriptor? The reason is that WPF’s interface requires its own hierarchy of classes (TypeDescriptor, EventDescriptor, etc.) which basically duplicates the reflection hierarchy and also increases the size of the installation package. It is more convenient to use the reflection hierarchy directly. In fact, this new reflection-based model is considered for both WPF and Silverlight. However, the next Silverlight release ships earlier than WPF, so for a while there will be some inconsistency in these APIs.

Another question that many of you might have is whether this feature has anything to do with the Dynamic Language Runtime (DLR), which is a part of the .NET 4 Framework. The answer is no, it’s an independent feature.

Since it’s already a popular question, let me explain why. The DLR objects such as ExpandoObject or DynamicObject (or any other implementation of the IDynamicMetaObjectProvider interface) do not carry any type information for their properties. The data binding engine, on the other hand, needs to get this information in order to perform type conversion for anything other than String.

For example, imagine that you have a text box bound to a property of the System.DateTime type. When you enter a value to this text box you of course enter just a string of characters. But the data binding engine checks the type of the bound property and converts the text box value from string to the necessary date format and vice versa. However, if you bind to a property of let’s say an ExpandoObject, the type of the property itself will simply change to string in this case and no data conversion will be possible. This is exactly what’s happening in WPF: you can bind DLR objects to UI elements, but no type conversion is happening, all you get from UI is strings.

So, while DLR is very convenient for interacting with other platforms and languages, it’s not really suitable for data binding and interacting with the UI of your own application.

Downloads, Links, and Feedback

The feature is available in Silverlight 5 Beta. The helper class source code and usage example are also available. Here are the links:

Download Silverlight 5 Beta and Tools
Download the CustomTypeHelper<T> source code (it is also attached to this blog post, see at the bottom of the page).

And of course, your feedback is appreciated here in comments, on Silverlight forums, and at UserVoice.

Silverlight 4 Documentation Updated

agbcl — Fri, 22 Apr 2011 20:05:00 GMT

The Silverlight 4 documentation has been updated--both online MSDN docs and the offline CHM. The CHM is Silverlight only and is great for fast, offline access.

There are numerous tweaks and small changes to the docs, but here are a few of the new and updated topics:

Implementing MediaStream Sources
This topic describes how to create parsers for container formats and describes delivery mechanisms not natively supported by Silverlight.

Delivering and Accessing Media Content
This topic describes steps that you need to perform to deliver and access media content in Silverlight.

Troubleshooting Media Issues
This topic describes how to diagnose and solve media issues in Silverlight.

Updated: Digital Rights Management (DRM)
New Output Protection section.

Updated: Supported Media Formats, Protocols, and Log Fields

Updated: MediaElement States

-- Brian

Adding Panorama and Pivot Controls to the Toolbox in Visual Studio (speeding development 1 second at a time)

Cheryl Simmons - MSFT — Fri, 15 Apr 2011 16:58:28 GMT

So I started work on a sample today and decided I wanted to use a Pivot control. I created a new project in Visual Studio and looked for the Pivot control in the Toolbox, but didn’t find it. In the XAML editor I tried typing <phone:…and got Intellisense that suggested a Page, Frame or WebBrowser control, but I still did not see the Panorama or Pivot controls. I was a bit puzzled, but I haven’t used these controls in awhile, so I looked up Pivot in the reference documentation. I saw that Pivot (and Panorama) are in the Microsoft.Phone.Controls namespace in the Microsoft.Phone.Controls assembly.

Because this assembly reference is not added by default to the Windows Phone project, in order to use these controls, I would need to add a reference to this assembly and then map the namespace/assembly in XAML.

Then I had a better idea. Why not add them to the Toolbox? Then I would get the reference and namespace mapping for free. So that’s what I did, and here’s how you can do it too.

To add a new control to the Toolbox:

Display the Toolbox
Right-click and select Choose Items…. The following image shows an example.

The Choose Toolbox Items dialog appears, and the Windows Phone Components tab should be selected. If not, select it.
Scroll until you locate the Panorama and Pivot controls and check them. Again, see the following image for an example:

Check any other controls you would like in the Toolbox. For example, if you have the Toolkit installed, you can add controls such as the ListPicker.

Now you can drag and drop the Panorama and Pivot controls from the Toolbox to the design surface, and you’ll get the necessary references and namespace mappings for free. Development just got faster!

--Cheryl

Silverlight 5 Beta has released…Get the chm!

Cheryl Simmons - MSFT — Wed, 13 Apr 2011 21:59:00 GMT

We’ve got apps, and we’ve got chms. Well, more specifically, a chm for Silverlight 5 beta.

To start, you can check out what’s new for Silverlight 5 beta. In addition to the new 3D support, there are many great additions to Silverlight for the SL5 beta release.

Next you will probably want the Silverlight 5 Beta Tools for Visual Studio 2010.

Last but not least, get the Silverlight 5 CHM.

What's new in Silverlight 5 beta? 3D graphics support!

John Mulhausen — Wed, 13 Apr 2011 19:30:00 GMT

Happy Silverlight 5 Beta day! The biggest additions to Silverlight 5 are certainly the support for GPU accelerated video and 3D graphics and the SDK team has been hard at work trying to get samples and documentation together for today. If you're a developer, after downloading the Silverlight 5 beta runtime, SDK, and developer tools, you'll probably want to start playing with the 3D features. In this blog post, I'll point you to the resources we created to help get you started.

Get the Silverlight 5 Beta, Tools, and SDK Now

1) The XNA Math Helper DLL
We expect that the math functions from XNA will be integrated into the Silverlight namespaces in the future, but for Silverlight 5 beta, you'll want to make use of this library instead. Add a reference to this DLL by right-clicking references in your Visual Studio project, clicking "Add Reference," selecting the "Browse" tab and navigating to this DLL's location. Then you can use the original XNA documentation to make use of the math functions contained within. These are a real lifesaver when doing matrix math, creating camera views, changing object positions, etc.

2) 3D Graphics Overview Topic
A high-level overview of the basics, explaining the capabilities provided in this beta release.

3) Textured 3D Cube Walkthrough and Downloadable Source Code
This walkthrough and sample demonstrates how to create a complete Silverlight 5 beta 3D application, including the use of textures, the use of shaders, integration with Silverlight UI elements, and cross-thread synchronizing (between the rendering thread and main UI thread). When completed, you will have created a textured cube that can be manipulated with ordinary Silverlight UI elements (in this case, sliders).

Already have the runtime installed? Here's the Textured Cube sample running live!

4) Reference documentation for the new API areas: Microsoft.Xna.Framework (Silverlight Version), Microsoft.Xna.Framework.Graphics (Silverlight Version), Micrososft.Xna.Framework.Silverlight, and the appearance of DrawingSurface in the System.Windows.Controls namespace.

While XNA developers have enjoyed being able to use managed code to create and apply 3D effects for awhile now, in Silverlight 5 beta, effects are the purview of shaders. This is because the effects APIs from XNA haven't been integrated yet. For now, just as you must workaround the limitations of the beta release by manually importing the XNA math library, so must you write and compile shaders to have effects in Silverlight 5 beta. A minimum of a vertex shader and a pixel shader is required, but as you will see in the textured cube sample, they need not do anything terribly fancy.

We are working on posting some other samples that demonstrate 3D use, and look forward to posting them very soon. Hopefully you got to see the "Babylon" demo (showing the interior of a cafe) during the MIX presentation, featuring full-scene, full-screen, GPU-accelerated 3D. It is really amazing to have an in-browser experience that feels so much like a modern 3D game; truly an example of trailblazing plug-in technology at work!

Silverlight 5 Beta Breaking Changes

snoutholder — Wed, 13 Apr 2011 17:29:00 GMT

There are currently no breaking changes for Silverlight 5 Beta to report.

Attending MIX 2011? There’s an app for that!

Nitya Ravi — Thu, 07 Apr 2011 10:23:00 GMT

If you’re planning on attending MIX 2011 conference in Las Vegas and if you own a Windows Phone, check out our new Conference Helper app for Windows Phone 7, that we just released to the marketplace. Conference Helper is a free app. You can get it either by searching in the marketplace or by downloading it from this link: http://social.zune.net/redirect?type=phoneApp&id=58d5ccf2-0854-e011-854c-00237de2db9e

You can use this application to:

Browse sessions by dates and time
View keynotes
View sessions filtered by speakers and tags.
View session description
Create your own customized schedule by adding sessions to “My Sessions”
Search by keywords
Access sessions and schedule information even without Internet access
View maps of the conference center and the neighborhood.

The app uses the phone’s internet connection to automatically detect and download any changes or additions to the conference session information.

We also plan to release this app as a sample shortly. Keep checking this space for more updates.

-Nitya.

Windows Phone 7 XNA Game Tutorial For Ya

snoutholder — Tue, 05 Apr 2011 17:34:00 GMT

The Microsoft game folks just released a tutorial that will guide you through the creation of a two-dimensional action game – called Shooter – on Windows, Xbox 360, or Windows Phone 7.

Start-to-Finish Guidance for Windows Phone 7 Application Development

Karl Erickson — Tue, 29 Mar 2011 13:34:00 GMT

If you are a C#/.NET developer who wants to learn the basics of phone application development using Silverlight, check out our new end-to-end guidance and sample application:

This guidance does not assume any Silverlight or phone development experience, but it takes you from whiteboard to marketplace, describing the key design and development scenarios along the way. It is designed to complement the Windows Phone Development QuickStarts, but the focus here is on describing how the features work in the context of an actual application, using a simple but complete fuel tracking app as an example.

This guidance describes everything you need to know to accomplish the following tasks:

Installing the free development tools and creating a new Windows Phone project.
Designing the user interface (UI) and choosing appropriate controls, icons, and graphics.
Using the application bar and back button, and handling navigation between pages.
Storing and retrieving data using isolated storage.
Display data in controls, enabling user edits, and performing validation.
Handling application deactivation, tombstoning, and reactivation.
Using the photo chooser task.
Publishing your application in the Windows Phone Marketplace.

As always, let us know if you have any feedback. In particular, we are interested in knowing whether you’d like to see more of this kind of guidance.

Enjoy!

Karl Erickson
Silverlight Developer Guidance