private void FindProviderAddChildOperators()
        {
            Type arg;
            var  tt = type.GetTypeInfo();

            if (tt.IsGenericType &&
                !tt.IsGenericTypeDefinition &&
                tt.GetGenericTypeDefinition() == typeof(IAddChild <>) &&
                (arg = tt.GetGenericArguments()[0]).IsProviderType())
            {
                foreach (var pi in App.DescribeProviders().GetProviderInfos(arg))
                {
                    var m    = pi.Member;
                    var name = pi.Name;

                    var item = ReflectedProviderFactoryDefinitionBase.Create(arg, m, name);
                    if (item == null || this.operators.ContainsKey(item.QualifiedName))
                    {
                        // TODO If two operators are defined with the same name, trace an error (StatusAppender.ForType(PropertyTreeSchema))
                        continue;
                    }
                    this.operators.Add(item);
                }
            }
        }
        void FindActivationConstructor()
        {
            var tt = type.GetTypeInfo();

            if (tt.IsAbstract)
            {
                // Composable providers can be abstract
                if (type.IsProviderType() && tt.IsDefined(typeof(ComposableAttribute), false))
                {
                    var composeMember = App.GetProviderMember(type, "compose");
                    if (composeMember == null)
                    {
                        throw new NotImplementedException();
                    }

                    activationConstructor = ReflectedProviderFactoryDefinitionBase.Create(type, composeMember);
                }
            }
            else
            {
                MethodBase ctor = TypeHelper.FindActivationConstructor(type);
                if (ctor != null)
                {
                    activationConstructor = ReflectedPropertyTreeFactoryDefinition.Create(null, ctor);
                }
            }
        }