public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent,
                                                           PropertyTreeMetaObject target,
                                                           PropertyTreeNavigator self,
                                                           NodeList children)
            {
                Type type = target.ComponentType ?? typeof(object);

                // Select providers
                if (type.IsProviderType())
                {
                    var node = children.FindAndRemove(ImplicitDirective(target, "provider")).FirstOrDefault();

                    if (node != null)
                    {
                        var serviceProvider = parent.GetBasicServices(node);
                        var pro             = parent.DirectiveFactory.CreateTargetProvider(type, node);
                        if (pro != null)
                        {
                            target = target.BindTargetProvider(pro, serviceProvider);
                            return(target);
                        }
                    }
                }

                return(target);
            }
Пример #2
0
            public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
            {
                Type             type            = target.ComponentType ?? typeof(object);
                Type             concreteClass   = type.GetConcreteClass();
                QualifiedName    name            = self.QualifiedName;
                IServiceProvider serviceProvider = parent;

                if (concreteClass != null && type != concreteClass)
                {
                    target.BindTargetType(TypeReference.FromType(concreteClass), serviceProvider);
                }
                else if (type.IsComposable())
                {
                    target.BindTargetProvider(name, null, serviceProvider);
                }

                if (target.Component == null && !target.ComponentType.GetTypeInfo().IsSealed)
                {
                    // TODO This predicate is probably too loose
                    Predicate <PropertyTreeNavigator> predicate = t => t.Name == "type";
                    var node = children.FindAndRemove(predicate).FirstOrDefault();
                    ApplyType(parent, target, node);
                }
                return(PickBuilderTypeIfAvailable(target));
            }
            public override PropertyTreeMetaObject StartStep(PropertyTreeMetaObject target,
                                                             PropertyTreeNavigator self,
                                                             NodeList children)
            {
                Type type = target.ComponentType ?? typeof(object);

                // Select providers
                if (type.IsProviderType()) {
                    var node = children.FindAndRemove(ImplicitDirective(target, "provider")).FirstOrDefault();

                    if (node != null) {
                        var serviceProvider = Parent.GetBasicServices(node);
                        var pro = DirectiveFactory.CreateTargetProvider(type, node);
                        if (pro != null) {
                            target = target.BindTargetProvider(pro, serviceProvider);
                            return target;
                        }
                    }
                }

                return target;
            }
            public override PropertyTreeMetaObject StartStep(PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
            {
                Type type = target.ComponentType ?? typeof(object);
                Type concreteClass = type.GetConcreteClass();
                QualifiedName name = self.QualifiedName;
                IServiceProvider serviceProvider = Parent;

                if (concreteClass != null && type != concreteClass) {
                    target.BindTargetType(TypeReference.FromType(concreteClass), serviceProvider);

                } else if (type.IsComposable()) {
                    target.BindTargetProvider(name, null, serviceProvider);
                }

                if (target.Component == null && !target.ComponentType.IsSealed) {
                    // TODO This predicate is probably too loose
                    Predicate<PropertyTreeNavigator> predicate = t => t.Name == "type";
                    var node = children.FindAndRemove(predicate).FirstOrDefault();
                    ApplyType(target, node);
                }
                return target;
            }