Build for both-Reflection bits & pieces for Windows Phone 8 and Windows 8

This is a bit of an odd post – it’s the things I learned while porting SilverlightSerializer 2 from Windows Phone to Windows 8 Store apps code. For those who don’t know what that is – it’s a very fast serializer, created by the brilliant Mike Talbot that’s able to store complex objects graphs in a very compact binary format. I use it to store an app’s state by simply serializing the view model graph to storage. For my (now) only Windows Store app I made a half-*ssed attempt to convert the much simpler SilverlightSerializer  v1 last year – but that’s slower and much less capable – especially my port. I was very much in a hurry then, so I cut out everything I did not need.

Anyway – SilverlightSerializer is a big chunk of reflection code. To get it to work in Windows Store apps, I had to change quite a lot of things – but then again a lot less than I thought. Even more shocking was the fact it worked without any problems when I linked the adapted code back to my Windows Phone project. That’s the power of the common Windows Runtime – no #if WINDOWS_PHONE preprocessor statements here!

So anyway, here’s what I learned. I wrote it in a kind of boring old-new style, but I found very little on this subject on the web, so I hope this is useful for people digging into reflection on Windows Store apps and hitting the wall when trying to do it ‘the new way’.

Properties and Fields

Get an object’s properties:

• Old code: Type.GetProperties()
• New code: Type.GetRuntimeProperties()

Get a single property:

• Old code: Type.GetProperty("MyProperty")
• New code: Type.GetRuntimeProperty("MyProperty")

Get a property’s get method

• Old code: PropertyInfo.GetGetMethod();
• New code: PropertyInfo.GetMethod;

Get a property’s set method

• Old code: PropertyInfo.GetSetMethod();
• New code: PropertyInfo.SetMethod;

Get public non-static properties that can be get and set

• Old code:Type.GetProperties(BindingFlags.Instance | BindingFlags.Public).
                        Where(p => p.GetSetMethod() != null));
• New code:Type.GetRuntimeProperties().
                           Where(p=> p.GetMethod != null && p.SetMethod != null &&
                                       !p.SetMethod.IsStatic && !p.GetMethod.IsStatic &&
                                       p.GetMethod.IsPublic && p.SetMethod.IsPublic);

Get an object’s Fields:

• Old code: Type.GetFields()
• New code: Type.GetRuntimeFields()

Get a single Field:

• Old code: Type.GetField("MyProperty")
• New code: Type.GetRuntimeField("MyProperty")

You can already see two patterns here – in stead of GetXYZ you do GetRuntimeXYZ. This “Runtime” indicates all an objects has available on runtime – that is, both it’s own properties, methods etc. and those of it’s parents. The other pattern is that in the Windows Runtime there is a tendency to use properties in stead of zero-parameter get methods.

Attributes

Determine whether a property has a custom attribute or not

• Old code: PropertyInfo.GetCustomAttributes(typeof(DoNotSerialize), true).Any()
• New code: PropertyInfo.GetCustomAttribute<DoNotSerialize>(true) != null

Type info

Determine if a type is an enum

• Old code: Type.IsEnum
• New code: Type.GetTypeInfo().IsEnum

Determine if a type is a generic type

• Old code: Type.IsGenericType
• New code: Type.GetTypeInfo().IsGenericType

Determine a type’s generic arguments

• Old code: Type.GetGenericArguments()
• New code: Type.GetTypeInfo().GenericTypeArguments

Find a type’s default constructor

• Old code:Type.GetConstructor(new Type[] { });
• New code: Type.GetTypeInfo().DeclaredConstructors.
                          FirstOrDefault(p => !p.GetParameters().Any());

Determine if a type implements an interface

• Old code: Type.GetInterface("IEnumerable", true) != null;
• New code: GetTypeInfo().ImplementedInterfaces.FirstOrDefault(
                       p => string.Compare(p.Name, name, ignoreCase?
                       StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)==0);

I must admit being a bit lazy on this one – this was used quite a number of times in SilverlightSerializer, so I made the following extension method

using System;
using System.Linq;
using System.Reflection;

namespace WpWinNl.Utilities
{
  public static class TypeExtensions
  {
    public static Type GetInterface(this Type type, string name, bool ignoreCase)
    {
      return type.GetTypeInfo().ImplementedInterfaces.FirstOrDefault(
        p => string.Compare(p.Name, name, ignoreCase? 
            StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal)==0) ;
    }
  }
}

and was done with it ;-). Beware – this is not something I recommend – making the new API compatible with the old. Rather, make it the other way around. But for porting existing code – especially code you did not write yourself – this can be a helpful way to save time.

Miscellaneous

Creating delegates

• Old code: Delegate.CreateDelegate(typeof(DelegateType), MethodInfo);
• New code: MethodInfo.CreateDelegate(typeof(DelegateType));

A MethodInfo is something you would get out of for instance PropertyInfo.GetMethod. I must admit to code in SilverlightSerializer is quite complex at this point, and I don’t understand the whole detail. But this seems to work, and I suggest people more interested in the details to have a look at the code. I will post the whole shebang soon.

Sorry, no sample this time ;-)