static class UiTypeHelper
    {
        static readonly ConcurrentDictionary<Tuple<Type, string>, DependencyProperty> KeyToProperty =
            new ConcurrentDictionary<Tuple<Type, string>, DependencyProperty>();

        public static DependencyProperty GetDependencyProperty(Type type, string propertyName)
        {
            return KeyToProperty.GetOrAdd(
                Tuple.Create(type, propertyName),
                key => GetDependencyProperties(key.Item1).FirstOrDefault(p => p.Name == key.Item2)
            );
        }

        public static IEnumerable<DependencyProperty> GetDependencyProperties(Type type)
        {
            return
                from typeItem in EnumerableHelper.GetLinkedList(type, v => v.BaseType)
                from property in GetTypeItemDependencyProperties(typeItem)
                select property;
        }

        static readonly ConcurrentDictionary<Type, DependencyProperty[]> TypeItemToPropertiesArray =
            new ConcurrentDictionary<Type, DependencyProperty[]>();

        static IEnumerable<DependencyProperty> GetTypeItemDependencyProperties(Type typeItem)
        {
            return TypeItemToPropertiesArray.GetOrAdd(
                typeItem,
                key =>
                    key.GetFields(BindingFlags.Public | BindingFlags.Static)
                        .Where(v => v.FieldType == typeof(DependencyProperty))
                        .Select(v => (DependencyProperty)v.GetValue(null))
                        .ToArray()
            );
        }
    }

    public static class EnumerableHelper
    {         
        public static IEnumerable<T> GetLinkedList<T>(T item, Func<T, T> nextItemSelector)
            where T : class
        {
            do
            {
                yield return item;
                item = nextItemSelector(item);
            }
            while (item != null);
        }
    }