How to check if a dependency object contains a dependency property?

Question

Essentially I want some simple reflection where I have an arbitrary DependencyProperty as a parameter. I'd have a special case (in an if statement, for example) if DependencyProperty is defined by / property of a PlaneProjection. I've done some simple fandangling of GetType() but no luck with the expected getters like MemberType.

public void SomeFunc(DependencyProperty dp)
{
    // if dp is a dependency property of plane projection, do something
    // would maybe look like PlaneProjection.hasProperty(dp)
}

Answer 1

Does this condition catch it?

Edit: Only in WPF - not SilverLight.

dp.OwnerType.IsAssignableFrom(typeof(PlaneProjection))

Answer 2

Try this code with extension methods:

public static class Helpers
{
    public static DependencyProperty FindDependencyProperty(this DependencyObject target, string propName)
    {
        FieldInfo fInfo = target.GetType().GetField(propName, BindingFlags.Static | BindingFlags.FlattenHierarchy | BindingFlags.Public);

        if (fInfo == null) return null;

        return (DependencyProperty)fInfo.GetValue(null);
    }

    public static bool HasDependencyProperty(this DependencyObject target, string propName)
    {
        return FindDependencyProperty(target, propName) != null;
    }

    public static string GetStaticMemberName<TMemb>(Expression<Func<TMemb>> expression)
    {
        var body = expression.Body as MemberExpression;

        if (body == null) throw new ArgumentException("'expression' should be a member expression");

        return body.Member.Name;
    }
}

Usage:

planeProjection1.HasDependecyProperty(
    Helpers.GetStaticMemberName(() => PlaneProjection.CenterOfRotationXProperty));

Answer 3

This should take care of your needs in SilverLight:

private static readonly Dictionary<DependencyProperty, Type> _ownerCache = new Dictionary<DependencyProperty, Type>();
// normally you'd use a HashSet<DependencyProperty>, but it's not available in SilverLight
private static readonly Dictionary<Type, Dictionary<DependencyProperty, bool>> _excludeCache = new Dictionary<Type, Dictionary<DependencyProperty, bool>>();

public static bool IsOwnedByTypeOrParent(DependencyProperty dp, Type type)
{
    lock (_ownerCache)
    {
        Type owner;
        if (_ownerCache.TryGetValue(dp, out owner))
            return owner.IsAssignableFrom(type);

        Dictionary<DependencyProperty, bool> exclude;
        if (_excludeCache.TryGetValue(type, out exclude))
        {
            if (exclude.ContainsKey(dp))
                return false;
        }

        FieldInfo[] fields = type.GetFields(BindingFlags.Static | BindingFlags.FlattenHierarchy);
        foreach (FieldInfo field in fields)
        {
            if (typeof(DependencyProperty).IsAssignableFrom(field.FieldType))
            {
                try
                {
                    object value = field.GetValue(null);
                    if (object.ReferenceEquals(dp, value))
                    {
                        _ownerCache[dp] = field.DeclaringType;
                        return true;
                    }
                }
                catch
                {
                }
            }
        }

        if (exclude == null)
        {
            exclude = new Dictionary<DependencyProperty, bool>();
            _excludeCache[type] = exclude;
        }

        exclude.Add(dp, false);

        /* optional if you want to minimize memory overhead. unnecessary unless
         * you are using this on enormous numbers of types/DPs
         */
        foreach (var item in _excludeCache)
        {
            item.Value.Remove(dp);
        }

        return false;
    }
}