Making Dependency Property registration strongly typed v2

Question

This is my second attempt to create a strongly typed builder for the Dependency Property. I've improved the two main weaknesses of the previous version which were:

• Can specify only PropertyMatadata but not FrameworkPropertyMetadata
• Can coerce value but not cancel the operation with DependencyProperty.UnsetValue

---

The PropertyMatadata can now be created with its own builder.

class PropertyMetadataBuilder<T, TValue> where T : DependencyObject
{
 private readonly PropertyMetadata _propertyMetadata;
 internal PropertyMetadataBuilder()
 {
 _propertyMetadata = new PropertyMetadata();
 }
 public PropertyMetadataBuilder<T, TValue> DefaultValue(
 TValue defaultValue
 )
 {
 _propertyMetadata.DefaultValue = defaultValue;
 return this;
 }
 public PropertyMetadataBuilder<T, TValue> PropertyChanged(
 Action<T, DependencyPropertyChangedEventArgs<TValue>> propertyChangedCallback
 )
 {
 _propertyMetadata.PropertyChangedCallback = new PropertyChangedCallback(
 (sender, e) =>
 propertyChangedCallback((T)sender,
 new DependencyPropertyChangedEventArgs<TValue>(e)
 )
 );
 return this;
 }
 public PropertyMetadataBuilder<T, TValue> PropertyChanging(
 Action<T, PropertyChangingEventArgs<TValue>> coerceValueCallback
 )
 {
 _propertyMetadata.CoerceValueCallback = new CoerceValueCallback(
 (d, baseValue) =>
 {
 var e = new PropertyChangingEventArgs<TValue>((TValue)baseValue);
 coerceValueCallback((T)d, e);
 return
 e.Canceled
 ? DependencyProperty.UnsetValue
 : e.CoercedValue;
 }
 );
 return this;
 }
 public static implicit operator PropertyMetadata(
 PropertyMetadataBuilder<T, TValue> builder
 )
 {
 return builder._propertyMetadata;
 }
}

I initialize it via an extension for the DependencyPropertyBuilder.

static class DependencyPropertyBuilderExtensions
{
 public static DependencyPropertyBuilder<T, TValue> PropertyMetadata<T, TValue>(
 this DependencyPropertyBuilder<T, TValue> builder,
 Action<PropertyMetadataBuilder<T, TValue>> build
 ) where T : DependencyObject
 {
 var metadataBuilder = new PropertyMetadataBuilder<T, TValue>();
 build(metadataBuilder);
 return builder.Metadata(metadataBuilder);
 }
}

Another extension can be added to support the creation of a FrameworkPropertyMetadata.

---

The DependencyPropertyBuilder has lost the PropertyMetadata related APIs and got instead one for setting metadata:

public DependencyPropertyBuilder<T, TValue> Metadata(
 PropertyMetadata propertyMetadata
)
{
 _propertyMetadata = propertyMetadata;
 return this;
}

---

The missing option DependencyProperty.UnsetValue to cancel CoerceValue is now available via the PropertyChangingEventArgs.

This should unify the the property value changing/changed behavior. The CoerceValue API is a weird one. It actually handles the property-changing event but in a completely unconventional way.

class PropertyChangingEventArgs<TValue> : EventArgs
{
 internal PropertyChangingEventArgs(TValue baseValue)
 {
 NewValue = baseValue;
 CoercedValue = baseValue;
 }
 public TValue NewValue { get; }
 public TValue CoercedValue { get; set; }
 public bool Canceled { get; set; }
}

This does not require to use the UnsetValue directly as it is determined by the Canceled property:

public PropertyMetadataBuilder<T, TValue> PropertyChanging(
 Action<T, PropertyChangingEventArgs<TValue>> coerceValueCallback
)
{
 _propertyMetadata.CoerceValueCallback = new CoerceValueCallback(
 (d, baseValue) =>
 {
 var e = new PropertyChangingEventArgs<TValue>((TValue)baseValue);
 coerceValueCallback((T)d, e);
 return
 e.Canceled
 ? DependencyProperty.UnsetValue
 : e.CoercedValue;
 }
 );
 return this;
}

---

Example

The new implementation can be used like this

class TestObject : DependencyObject
{
 public static readonly DependencyProperty CountProperty =
 DependencyPropertyBuilder
 .Register<TestObject, int>(nameof(TestObject.Count))
 .PropertyMetadata(b => b
 .DefaultValue(5)
 .PropertyChanged((testObject, e) =>
 {
 Console.WriteLine($"{e.Property.Name} = {e.OldValue} --> {e.NewValue}");
 })
 .PropertyChanging((testObject, e) =>
 {
 if (e.NewValue > 20)
 {
 e.CoercedValue = 15;
 }
 if (e.NewValue < 1)
 {
 e.Canceled = true;
 }
 })
 ).ValidateValue(value => value >= 0);
 public int Count
 {
 get { return CountProperty.GetValue<int>(this); }
 set { CountProperty.SetValue(this, value); }
 }
}

Changing Count value:

var testObject = new TestObject();
testObject.Count.Dump("Default");
testObject.Count2 = 8;
testObject.Count2.Dump("Changed");
testObject.Count = 22;
testObject.Count.Dump("Coerced to max");
testObject.Count = 0;
testObject.Count.Dump("Property change canceled");
testObject.Count = -2; // bam!

Output

Default 
5 
Count = 5 --> 8 
Changed 
8 
Count = 8 --> 15
Coerced to max 
15 
Property change canceled 
15 
ArgumentException
'-2' is not a valid value for property 'Count'. 

Answer 1

I have combined this builder with the declarative one.

---

Now the Build resolves the DefaultValue and Validation attributes on the property:

public DependencyProperty Build()
{
 BuildDefaultValue();
 BuildValidateValueCallback();
 return DependencyProperty.Register(
 _name,
 _propertyType,
 _ownerType,
 _propertyMetadata,
 _validateValueCallback
 );
}
private void BuildDefaultValue()
{
 var property = _ownerType.GetProperty(_name);
 // Use the default value specified by the user or try to use the attribute.
 _propertyMetadata.DefaultValue =
 _propertyMetadata.DefaultValue ??
 new Func<object>(() =>
 // Get the defualt value from the attribute...
 property.GetCustomAttribute<DefaultValueAttribute>()?.Value ??
 // or use the default value for the type.
 (property.PropertyType.IsValueType
 ? Activator.CreateInstance(property.PropertyType)
 : null
 )
 )();
}
private void BuildValidateValueCallback()
{
 var property = _ownerType.GetProperty(_name);
 // Use the callback specified by the user or try to use the attributes.
 _validateValueCallback =
 _validateValueCallback ??
 (value =>
 new Func<bool>(() => (
 property.GetCustomAttributes<ValidationAttribute>() ??
 Enumerable.Empty<ValidationAttribute>()
 ).All(x => x.IsValid(value)))()
 );
}

---

I changed the PropertyChanging API back to CoerceValue. The main one works like the WPF implementation:

public PropertyMetadataBuilder<T, TValue> CoerceValue(
 Func<T, TValue, object> coerceValueCallback
)
{
 _propertyMetadata.CoerceValueCallback = (d, baseValue) => 
 coerceValueCallback((T) d, (TValue)baseValue);
 return this;
}

and I extended it via an extension to work with EventArgs.

public static PropertyMetadataBuilder<T, TValue> CoerceValue<T, TValue>(
 this PropertyMetadataBuilder<T, TValue> builder,
 Action<T, CoerceValueEventArgs<TValue>> coerceValueCallback
) where T : DependencyObject
{
 builder.CoerceValue((d, baseValue) =>
 {
 var e = new CoerceValueEventArgs<TValue>(baseValue);
 coerceValueCallback(d, e);
 return
 e.Canceled
 ? DependencyProperty.UnsetValue
 : e.CoercedValue;
 });
 return builder;
}

The custom EventArgs

public class CoerceValueEventArgs<TValue> : EventArgs
{
 internal CoerceValueEventArgs(TValue baseValue)
 {
 NewValue = baseValue;
 CoercedValue = baseValue;
 }
 public TValue NewValue { get; }
 public TValue CoercedValue { get; set; }
 public bool Canceled { get; set; }
}

---

This is the new TestObject

internal class TestObject : DependencyObject
{
 public static readonly DependencyProperty CountProperty =
 DependencyPropertyBuilder
 .Register<TestObject, int>(nameof(Count))
 .PropertyMetadata(b => b
 .PropertyChanged((testObject, e) =>
 {
 Console.WriteLine($"{e.Property.Name} = {e.OldValue} --> {e.NewValue}");
 }) 
 .CoerceValue((testObject, e) =>
 {
 if (e.NewValue > 20)
 {
 e.CoercedValue = 15;
 }
 if (e.NewValue < 1)
 {
 e.Canceled = true;
 }
 })
 );
 [DefaultValue(5)]
 [Range(0, 15)]
 public int Count
 {
 get { return CountProperty.GetValue<int>(this); }
 set { CountProperty.SetValue(this, value); }
 }
}

and the tests

[TestMethod]
public void Count_DefaultValue()
{
 var testObject = new TestObject();
 Assert.AreEqual(5, testObject.Count, "Default value.");
}
[TestMethod]
public void Count_ChangeValue()
{
 var testObject = new TestObject
 {
 Count = 8
 };
 Assert.AreEqual(8, testObject.Count, "Changed value");
}
[TestMethod]
[ExpectedException(typeof(ArgumentException))]
public void Count_ValueOutOfRange()
{
 new TestObject
 {
 Count = 22
 };
}