Looking for DependencyProperty.Register shortcut.

Question

Defining WPF properties is too long:

public static readonly DependencyProperty FooProperty = 
  DependencyProperty.Register("Foo", typeof(string), typeof(FooClass), new PropertyMetadata("Foooooo"));

I have a helper method, making it a bit shorter:

public static readonly DependencyProperty FooProperty =
  WpfUtils.Property<string, FooControl>("Foo", "Foooooo");

Code:

public partial class WpfUtils 
{
    public static DependencyProperty Property<T, TClass>(string name) 
    {
        return Property<T, TClass>(name, default(T));
    }

    public static DependencyProperty Property<T, TClass>(string name, T defaultValue) 
    {
        return DependencyProperty.Register(name, typeof(T), typeof(TClass), new PropertyMetadata(defaultValue));
    }
}

Are there better helpers around?

Answer 1

I agree that it is a pain that Dependency Properties are so long. I don't use a helper, but Visual Studio has a great built-in snippet that you can use by typing wpfdp.

That's how I fill in a bunch of Dependency Properties quickly.

Answer 2

Here is some code for that. This code is evil, but I wanted to show how to do this without using Cecil, or having to create a sourceforge project :-)

To use it, call:

public static readonly DependencyProperty FooProperty = D.P();

And the code is:

public class D
{
    [MethodImpl(MethodImplOptions.NoInlining)]
    public static DependencyProperty P()
    {
        StackTrace stackTrace = new StackTrace();
        StackFrame oneUp = stackTrace.GetFrame(1);
        MethodBase callingMethod = oneUp.GetMethod();
        if (!(callingMethod is ConstructorInfo))
        {
            throw new InvalidOperationException("This method must be called from a static constructor/initializer");
        }
        byte[] staticConstructorCode = callingMethod.GetMethodBody().GetILAsByteArray();
        int offsetAfterThisCall = oneUp.GetILOffset() + 5;

        while (staticConstructorCode[offsetAfterThisCall] == OpCodes.Nop.Value)
        {
            offsetAfterThisCall++;
        }

        if (staticConstructorCode[offsetAfterThisCall] != OpCodes.Stsfld.Value)
        {
            throw new InvalidOperationException("Unexpected IL");
        }

        int token = BitConverter.ToInt32(staticConstructorCode, offsetAfterThisCall + 1);

        FieldInfo field = callingMethod.Module.ResolveField(token);

        if (!field.Name.EndsWith("Property") || field.FieldType != typeof(DependencyProperty))
        {
            throw new NotSupportedException("The field the return value of this method will be stored in must be named xxxProperty and be of type DependencyProperty");
        }

        string name = field.Name.Substring(0, field.Name.Length - "Property".Length);
        return DependencyProperty.Register(name, callingMethod.DeclaringType.GetProperty(name).PropertyType, callingMethod.DeclaringType);
    }
}

Answer 3

For those using resharper I use the following template

//DependencyProperty $PropertyName$
public static readonly DependencyProperty $PropertyName$Property =
      DependencyProperty.Register("$PropertyName$", typeof($PropertyType$), typeof($SelfType$),
      new FrameworkPropertyMetadata($DefaultValue$, $PropertyName$ChangedCallback, $PropertyName$CoerceValue));

public $PropertyType$ $PropertyName${
       set { SetValue($PropertyName$Property, value); }
       get { return ($PropertyType$)GetValue($PropertyName$Property); }
      }

private static void $PropertyName$ChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e){

      $SelfType$ owner = d as $SelfType$;
      if(owner!=null){}

      }

 private static object $PropertyName$CoerceValue(DependencyObject d, object value)   {

      $PropertyType$ val = ($PropertyType$)value;
  return value;
      }

I have it show only where it's possible to declare member I've also set $SelfType$ to expand to the parent type which here is the class name

Answer 4

Here is my attempt. It is safer than the IL-reading method by Alun Harford.

This helper has the following features:

• Support for dependency properties and attached properties
• Providing property name in a type-safe manner, w/o (magic) strings (using expression trees)
• Type-safe callback support, with generic arguments

First, I'll show the usage:

public class Tester : DependencyObject
{
    public int Foo
    {
        get { return (int)GetValue(FooProperty); }
        set { SetValue(FooProperty, value); }
    }
    public static readonly DependencyProperty FooProperty = 
        For<Tester>.Register(o => o.Foo, 0, onFooChanged);

    private static void onFooChanged(Tester obj, DependencyPropertyChangedEventArgs<int> e)
    {
    }

    public string Attached
    {
        get { return (string)GetValue(AttachedProperty); }
        set { SetValue(AttachedProperty, value); }
    }
    public static readonly DependencyProperty AttachedProperty = 
        For<Tester>.RegisterAttached(o => o.Attached, "default", onAttachedChanged);

    private static void onAttachedChanged(DependencyObject obj, DependencyPropertyChangedEventArgs<string> e)
    {
    }
}

And here is the implementation:

public static class For<TOwner>
    where TOwner : DependencyObject
{
    public static DependencyProperty Register<TProperty>(
        Expression<Func<TOwner,TProperty>> property, 
        TProperty defaultValue, 
        Action<TOwner, DependencyPropertyChangedEventArgs<TProperty>> callback)
    {
        return DependencyProperty.Register(
            getName(property),
            typeof(TProperty),
            typeof(TOwner),
            new FrameworkPropertyMetadata(
                defaultValue,
                (o, args) => callback((TOwner)o, new DependencyPropertyChangedEventArgs<TProperty>(args))));
    }

    public static DependencyProperty RegisterAttached<TProperty>(
        Expression<Func<TOwner,TProperty>> property, 
        TProperty defaultValue,
        Action<DependencyObject, DependencyPropertyChangedEventArgs<TProperty>> callback)
    {
        return DependencyProperty.RegisterAttached(
            getName(property),
            typeof(TProperty),
            typeof(TOwner),
            new FrameworkPropertyMetadata(
                defaultValue,
                (o, args) => callback(o, new DependencyPropertyChangedEventArgs<TProperty>(args))));
    }

    private static string getName<T>(Expression<Func<TOwner,T>> property)
    {
        var name = ((MemberExpression)property.Body).Member.Name;
        return name;
    }
}

public struct DependencyPropertyChangedEventArgs<T>
{
    public DependencyPropertyChangedEventArgs(DependencyPropertyChangedEventArgs source)
    {
        m_property = source.Property;
        m_oldValue = (T)source.OldValue;
        m_newValue = (T)source.NewValue;
    }

    private readonly DependencyProperty m_property;
    public DependencyProperty Property { get { return m_property; } }

    private readonly T m_oldValue;
    public T OldValue { get { return m_oldValue; } }

    private readonly T m_newValue;
    public T NewValue { get { return m_newValue; } }
}