protected IEnumerable <string> GetValueDependencyTriggers()
{
var propertyFieldInfo = OwnerType.GetField(CachedPropertyName, BindingFlags.Static | BindingFlags.Public);
var valueDependencyTriggersAttribute = propertyFieldInfo.GetCustomAttribute <ValueDependencyTriggersAttribute>();
if (valueDependencyTriggersAttribute != null)
{
return(valueDependencyTriggersAttribute.TriggerPropertyNames);
}
return(Enumerable.Empty <string>());
}
void EmitLoadObj(ILGenerator il, int index)
{
Debug.Assert(il != null);
Debug.Assert(index < TargetsCount);
// loads this
il.Emit(OpCodes.Ldarg_0);
if (TargetsCount == 1)
{
// if expr constains only one target,
// this target will be this
}
else if (TargetsCount <= 3)
{
Debug.Assert(this.ownerType != null);
FieldInfo field = OwnerType.GetField(
"obj" + index, OwnerSupport.FieldFlags);
Debug.Assert(field != null);
// 2 hours of debugging to find the difference :(
if (field.FieldType.IsValueType)
{
il.Emit(OpCodes.Ldflda, field);
}
else
{
il.Emit(OpCodes.Ldfld, field);
}
}
else
{
il.Emit(OpCodes.Ldfld, OwnerSupport.OwnerNArray);
il_EmitLoadI4(il, index);
il.Emit(OpCodes.Ldelem_Ref);
Type targetType = this.closure[index].GetType();
if (targetType.IsValueType)
{
il.Emit(OpCodes.Unbox_Any, targetType);
}
else
{
il.Emit(OpCodes.Castclass, targetType);
}
}
}
DependencyPropertyInfo GetDependencyPropertyInfo(PropertyInfo property, DependencyPropertyAttribute attribute)
{
if (_enforceWpfConvention)
{
// Find public dependency property field identifier.
const BindingFlags identifierModifiers = BindingFlags.Public | BindingFlags.Static;
string identifierField = property.Name + IdentifierSuffix;
FieldInfo identifier = OwnerType.GetField(identifierField, identifierModifiers);
if (identifier == null || (identifier.FieldType != typeof(DependencyProperty)))
{
throw new InvalidImplementationException(
ConventionEnabledError +
"There is no public static dependency property field identifier \"" + identifierField +
"\" available in the class \"" + OwnerType.Name + "\".");
}
// Verify name when set.
if (attribute.Name != null && property.Name != attribute.Name)
{
throw new InvalidImplementationException(
ConventionEnabledError + "The CLR property wrapper '" + property.Name +
"' doesn't match the name of the dependency property.");
}
}
// Set dependency property parameters.
Type propertyType = property.PropertyType;
MethodInfo setMethod = property.GetSetMethod();
object defaultValue;
if (attribute.DefaultValueProvider != null)
{
var defaultValueProvider = (IDefaultValueProvider <T>)Activator.CreateInstance(attribute.DefaultValueProvider);
defaultValue = defaultValueProvider.GetDefaultValue((T)attribute.GetId(), property.PropertyType);
}
else
{
defaultValue = attribute.DefaultValue ?? propertyType.CreateDefault();
}
if (defaultValue != null && defaultValue.GetType() != propertyType)
{
TypeConverter converter = TypeDescriptor.GetConverter(propertyType);
if (converter.CanConvertFrom(defaultValue.GetType()))
{
var context = new TypeDescriptorContext(propertyType);
defaultValue = converter.ConvertFrom(context, CultureInfo.CurrentCulture, defaultValue);
}
}
var metaData = new FrameworkPropertyMetadata
{
DefaultValue = defaultValue,
AffectsArrange = attribute.AffectsArrange,
AffectsMeasure = attribute.AffectsMeasure,
AffectsParentArrange = attribute.AffectsParentArrange,
AffectsParentMeasure = attribute.AffectsParentMeasure,
AffectsRender = attribute.AffectsRender,
SubPropertiesDoNotAffectRender = attribute.SubPropertiesDoNotAffectRender
};
var dependencyPropertyInfo = new DependencyPropertyInfo
{
IsAttached = false,
Name = attribute.Name ?? property.Name,
Type = propertyType,
// When no default value is set, use the default value.
MetaData = metaData,
// By default, readonly when setter is private.
ReadOnly = attribute.IsReadOnlySet() ? attribute.IsReadOnly() : (setMethod == null || setMethod.IsPrivate),
Id = (T)attribute.GetId()
};
return(dependencyPropertyInfo);
}
