예제 #1
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));
            }
            private void ApplyType(PropertyTreeMetaObject target,
                                   PropertyTreeNavigator node)
            {
                if (node == null)
                    return;

                Type type = target.ComponentType ?? typeof(object);
                var serviceProvider = Parent.GetBasicServices(node);
                target.BindTargetType(this.DirectiveFactory.CreateTargetType(node), serviceProvider);
            }
예제 #3
0
            private void ApplyType(PropertyTreeBinderImpl parent,
                                   PropertyTreeMetaObject target,
                                   PropertyTreeNavigator node)
            {
                if (node == null)
                {
                    return;
                }

                var serviceProvider = parent.GetBasicServices(node);

                target.BindTargetType(parent.DirectiveFactory.CreateTargetType(node), serviceProvider);
            }
            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;
            }