C# Xml.ParserContext类代码示例

        protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
        {

            builder.AddPropertyReference(TxNamespaceUtils.TRANSACTION_MANAGER_PROPERTY,
                GetAttributeValue(element, TxNamespaceUtils.TRANSACTION_MANAGER_ATTRIBUTE));
            XmlNodeList txAttributes = element.SelectNodes("*[local-name()='attributes' and namespace-uri()='" + element.NamespaceURI + "']");
            if (txAttributes.Count > 1 )
            {
                parserContext.ReaderContext.ReportException(element, "tx advice", "Element <attributes> is allowed at most once inside element <advice>");
            }
            else if (txAttributes.Count == 1)
            {
                //using xml defined source
                XmlElement attributeSourceElement = txAttributes[0] as XmlElement;
                AbstractObjectDefinition attributeSourceDefinition =
                    ParseAttributeSource(attributeSourceElement, parserContext);
                builder.AddPropertyValue(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE, attributeSourceDefinition);
            }
            else
            {
                //Assume attibutes source
                ObjectDefinitionBuilder txAttributeSourceBuilder = 
                    parserContext.ParserHelper.CreateRootObjectDefinitionBuilder(typeof (AttributesTransactionAttributeSource));

                builder.AddPropertyValue(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE,
                                         txAttributeSourceBuilder.ObjectDefinition);

            }
        }

        public ManagedList ParseInterceptors(XmlElement element, ParserContext parserContext)
        {
            ManagedList interceptors = new ManagedList();
            foreach(XmlNode child in element.ChildNodes) {

            /* TODO:
             * check full elementname (incl. NamespaceUri)
            */
            if (child.NodeType == XmlNodeType.Element) {
                XmlElement childElement = (XmlElement) child;
                string localName = child.LocalName;
                if ("object".Equals(localName)) {
                    ObjectDefinitionHolder holder = parserContext.ParserHelper.ParseObjectDefinitionElement(childElement);
                    interceptors.Add(holder);
                }
                else if ("ref".Equals(localName)) {
                    string reference = childElement.GetAttribute("object");
                    interceptors.Add(new RuntimeObjectReference(reference));
                }
                else {
                    if (!parsers.ContainsKey(localName)) {
                        parserContext.ReaderContext.ReportException(childElement, localName, "unsupported interceptor element");
                    }
                    IObjectDefinitionRegisteringParser parser = parsers[localName];
                    string interceptorObjectName = parser.Parse(childElement, parserContext);
                    interceptors.Add(new RuntimeObjectReference(interceptorObjectName));
                }
            }
            }
            return interceptors;
        }

        private ObjectDefinitionHolder ParseTestObjectDefinition(XmlElement rootElement, ParserContext parserContext)
        {
            MutablePropertyValues properties = new MutablePropertyValues();
            
            XmlNodeList childNodes = rootElement.ChildNodes;

            //Get all properties (from non whitespace nodes)
            foreach (XmlNode childNode in childNodes)
            {                
                if (XmlNodeType.Whitespace != childNode.NodeType)
                {
                    properties.Add(new PropertyValue(childNode.LocalName, childNode.InnerText));
                }
            }
            IConfigurableObjectDefinition od = new RootObjectDefinition(typeof (TestObject), null, properties);
            od.IsSingleton = false;

            //HardCoded for now.
            string id = "testObject";
            //id = ObjectDefinitionReaderUtils.GenerateObjectName(od, reader.ObjectReader.Registry);

            return new ObjectDefinitionHolder(od, id);


        }

        protected override AbstractObjectDefinition ParseInternal(XmlElement element, ParserContext parserContext)
        {
            ObjectDefinitionBuilder builder = BuildObjectDefinition(element, parserContext);
            ManagedList interceptors = null;
            XmlElement interceptorsElement = DomUtils.GetChildElementByTagName(element, "interceptors");

            if(interceptorsElement != null) {
                ChannelInterceptorParser interceptorParser = new ChannelInterceptorParser();
                interceptors = interceptorParser.ParseInterceptors(interceptorsElement, new ParserContext(parserContext.ParserHelper, builder.RawObjectDefinition));
            }
            if(interceptors == null) {
                interceptors = new ManagedList();
            }

            string datatypeAttr = element.GetAttribute("datatype");
            if(StringUtils.HasText(datatypeAttr)) {
                string[] datatypes = StringUtils.CommaDelimitedListToStringArray(datatypeAttr);
                RootObjectDefinition selectorDef = new RootObjectDefinition();
                selectorDef.ObjectTypeName = IntegrationNamespaceUtils.SELECTOR_PACKAGE + ".PayloadTypeSelector";
                selectorDef.ConstructorArgumentValues.AddGenericArgumentValue(datatypes);
                string selectorObjectName = parserContext.ReaderContext.RegisterWithGeneratedName(selectorDef);

                RootObjectDefinition interceptorDef = new RootObjectDefinition();
                interceptorDef.ObjectTypeName = IntegrationNamespaceUtils.CHANNEL_INTERCEPTOR_PACKAGE + ".MessageSelectingInterceptor";
                interceptorDef.ConstructorArgumentValues.AddGenericArgumentValue(new RuntimeObjectReference(selectorObjectName));
                string interceptorObjectName = parserContext.ReaderContext.RegisterWithGeneratedName(interceptorDef);

                interceptors.Add(new RuntimeObjectReference(interceptorObjectName));
            }

            builder.AddPropertyValue("interceptors", interceptors);
            return builder.ObjectDefinition;
        }

        /// <summary>The do parse.</summary>
        /// <param name="element">The element.</param>
        /// <param name="parserContext">The parser context.</param>
        /// <param name="builder">The builder.</param>
        protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
        {
            var parser = new ObjectDefinitionParserHelper(parserContext);
            var map = parser.ParseMapElement(element, builder.RawObjectDefinition);

            builder.AddPropertyValue("SourceDictionary", map);
        }

 protected override AbstractObjectDefinition ParseInternal(XmlElement element, ParserContext parserContext)
 {
     ObjectDefinitionBuilder handlerBuilder = ParseHandler(element, parserContext);
     IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(handlerBuilder, element, "output-channel");
     IntegrationNamespaceUtils.SetValueIfAttributeDefined(handlerBuilder, element, "order");
     AbstractObjectDefinition handlerBeanDefinition = handlerBuilder.ObjectDefinition;
     string inputChannelAttributeName = InputChannelAttributeName;
     if(!element.HasAttribute(inputChannelAttributeName)) {
         if(!parserContext.IsNested) {
             parserContext.ReaderContext.ReportException(element, element.Name, "The '" + inputChannelAttributeName
                     + "' attribute is required for top-level endpoint elements.");
         }
         return handlerBeanDefinition;
     }
     ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CONFIG_PACKAGE + ".ConsumerEndpointFactoryObject");
     string handlerBeanName = parserContext.ReaderContext.RegisterWithGeneratedName(handlerBeanDefinition);
     builder.AddConstructorArgReference(handlerBeanName);
     string inputChannelName = element.GetAttribute(inputChannelAttributeName);
     if(!parserContext.Registry.ContainsObjectDefinition(inputChannelName)) {
         ObjectDefinitionBuilder channelDef = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.CHANNEL_PACKAGE + ".DirectChannel");
         ObjectDefinitionHolder holder = new ObjectDefinitionHolder(channelDef.ObjectDefinition, inputChannelName);
         ObjectDefinitionReaderUtils.RegisterObjectDefinition(holder, parserContext.Registry);
     }
     builder.AddPropertyValue("inputChannelName", inputChannelName);
     XmlElement pollerElement = DomUtils.GetChildElementByTagName(element, "poller");
     if(pollerElement != null) {
         IntegrationNamespaceUtils.ConfigurePollerMetadata(pollerElement, builder, parserContext);
     }
     IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "auto-startup");
     return builder.ObjectDefinition;
 }

        /// <summary>
        /// Central template method to actually parse the supplied XmlElement
        /// into one or more IObjectDefinitions.
        /// </summary>
        /// <param name="element">The element that is to be parsed into one or more <see cref="IObjectDefinition"/>s</param>
        /// <param name="parserContext">The the object encapsulating the current state of the parsing process;
        /// provides access to a <see cref="IObjectDefinitionRegistry"/></param>
        /// <returns>
        /// The primary IObjectDefinition resulting from the parsing of the supplied XmlElement
        /// </returns>
        protected override AbstractObjectDefinition ParseInternal(XmlElement element, ParserContext parserContext)
        {
            ConfigureAutoProxyCreator(parserContext, element);

            //Create the TransactionAttributeSource
            RootObjectDefinition sourceDef = new RootObjectDefinition(typeof(AttributesTransactionAttributeSource));
            sourceDef.Role = ObjectRole.ROLE_INFRASTRUCTURE;
            string sourceName = parserContext.ReaderContext.RegisterWithGeneratedName(sourceDef);

            //Create the TransactionInterceptor definition.
            RootObjectDefinition interceptorDefinition = new RootObjectDefinition(typeof(TransactionInterceptor));
            interceptorDefinition.Role = ObjectRole.ROLE_INFRASTRUCTURE;
            RegisterTransactionManager(element, interceptorDefinition);
            interceptorDefinition.PropertyValues.Add(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE, new RuntimeObjectReference(sourceName));
            String interceptorName = parserContext.ReaderContext.RegisterWithGeneratedName(interceptorDefinition);

            // Create the TransactionAttributeSourceAdvisor definition.
            RootObjectDefinition advisorDef = new RootObjectDefinition(typeof(ObjectFactoryTransactionAttributeSourceAdvisor));
            advisorDef.Role = ObjectRole.ROLE_INFRASTRUCTURE;
            advisorDef.PropertyValues.Add("transactionAttributeSource", new RuntimeObjectReference(sourceName));
            advisorDef.PropertyValues.Add("adviceObjectName", interceptorName);

            if (element.HasAttribute(ORDER))
            {
                advisorDef.PropertyValues.Add(ORDER, GetAttributeValue(element, ORDER));
            }

            return advisorDef;
        }

 protected override ObjectDefinitionBuilder ParseHandler(XmlElement element, ParserContext parserContext)
 {
     ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.AGGREGATOR_PACKAGE + ".MethodInvokingAggregator");
     string refatr = element.GetAttribute(RefAttribute);
     if(!StringUtils.HasText(refatr)) {
         parserContext.ReaderContext.ReportException(element, element.Name, "The '" + RefAttribute + "' attribute is required.");
     }
     builder.AddConstructorArgReference(refatr);
     if(StringUtils.HasText(element.GetAttribute(MethodAttribute))) {
         string method = element.GetAttribute(MethodAttribute);
         builder.AddConstructorArg(method);
     }
     IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, DiscardChannelAttribute);
     IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, SendTimeoutAttribute);
     IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, SendPartialResultOnTimeoutAttribute);
     IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, ReaperIntervalAttribute);
     IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, TrackedCorrelationIdCapacityAttribute);
     IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "auto-startup");
     IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, TimeoutAttribute);
     string completionStrategyRef = element.GetAttribute(CompletionStrategyRefAttribute);
     string completionStrategyMethod = element.GetAttribute(CompletionStrategyMethodAttribute);
     if(StringUtils.HasText(completionStrategyRef)) {
         if(StringUtils.HasText(completionStrategyMethod)) {
             string adapterBeanName = CreateCompletionStrategyAdapter(
                     completionStrategyRef, completionStrategyMethod, parserContext);
             builder.AddPropertyReference(CompletionStrategyProperty, adapterBeanName);
         }
         else {
             builder.AddPropertyReference(CompletionStrategyProperty, completionStrategyRef);
         }
     }
     return builder;
 }

        public IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext)
        {
            IObjectDefinitionFactory factory = parserContext.ReaderContext.ObjectDefinitionFactory;
            AssertUtils.ArgumentNotNull(factory, "factory");

            string id = element.GetAttribute(ObjectNames.MongoConventionProfileId);
            string defaultId = StringUtils.HasText(id) ? id : ObjectNames.MongoConventionProfileDefaultId;

            ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(ConventionProfileFactory));

            SetConvention(element, builder, ObjectNames.ConventionProfileDefaultValue, ConventionProfileFactory.DefaultValueConventionProperty);
            SetConvention(element, builder, ObjectNames.ConventionProfileElementName, ConventionProfileFactory.ElementNameConventionProperty);
            SetConvention(element, builder, ObjectNames.ConventionProfileExtraElementsMember, ConventionProfileFactory.ExtraElementsMemberConventionProperty);
            SetConvention(element, builder, ObjectNames.ConventionProfileIdGenerator, ConventionProfileFactory.IdGeneratorConventionProperty);
            SetConvention(element, builder, ObjectNames.ConventionProfileIdMember, ConventionProfileFactory.IdMemberConventionProperty);
            SetConvention(element, builder, ObjectNames.ConventionProfileIgnoreExtraElements, ConventionProfileFactory.IgnoreExtraElementsConventionProperty);
            SetConvention(element, builder, ObjectNames.ConventionProfileIgnoreIfDefault, ConventionProfileFactory.IgnoreIfDefaultConventionProperty);
            SetConvention(element, builder, ObjectNames.ConventionProfileIgnoreIfNull, ConventionProfileFactory.IgnoreIfNullConventionProperty);
            SetConvention(element, builder, ObjectNames.ConventionProfileMemberFinder, ConventionProfileFactory.MemberFinderConventionProperty);
            SetConvention(element, builder, ObjectNames.ConventionProfileSerializationOptions, ConventionProfileFactory.SerializationOptionsConventionProperty);

            parserContext.Registry.RegisterObjectDefinition(defaultId, builder.ObjectDefinition);

            return null;
        }

        public void WhenConfigFileIsNotValid()
        {
            //            const string xml = @"<?xml version='1.0' encoding='UTF-8' ?>
            //<objects xmlns='http://www.springframework.net' xmlns:v='http://www.springframework.net/validation'>
            //    <v:required test='#this'>
            //        <v:message id='error.airportCode.required' providers='summary'/>
            //        <v:action type='Spring.Validation.Actions.ExpressionAction, Spring.Core' when='true'/>
            //    </v:required>
            //</objects>
            //";
            XmlDocument doc = GetValidatedXmlResource("_WhenConfigFileIsNotValid.xml");

            MockObjectDefinitionRegistry registry = new MockObjectDefinitionRegistry();
            IObjectDefinitionDocumentReader reader = new DefaultObjectDefinitionDocumentReader();

            XmlReaderContext readerContext = new XmlReaderContext(null, new XmlObjectDefinitionReader(registry));
            ObjectDefinitionParserHelper helper = new ObjectDefinitionParserHelper(readerContext);
            helper.InitDefaults(doc.DocumentElement);
            ParserContext parserContext = new ParserContext(helper.ReaderContext, helper);

            ValidationNamespaceParser parser = new ValidationNamespaceParser();
            foreach (XmlElement element in doc.DocumentElement.ChildNodes)
            {
                if (element.NamespaceURI == "http://www.springframework.net/validation")
                {
                    parser.ParseElement(element, parserContext);
                }
            }
        }

 protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
 {
     if(!StringUtils.HasText(element.GetAttribute("id"))) {
         parserContext.ReaderContext.ReportException(element, element.Name, "id is required");
     }
     ParseSelectorChain(builder, element, parserContext);
 }

        protected override ObjectDefinitionBuilder ParseHandler(XmlElement element, ParserContext parserContext)
        {
            ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(NmsOutboundGateway));
            builder.AddPropertyReference("connectionFactory", element.GetAttribute("connection-factory"));
            String requestDestination = element.GetAttribute("request-destination");
            String requestDestinationName = element.GetAttribute("request-destination-name");
            if (!(StringUtils.HasText(requestDestination) ^ StringUtils.HasText(requestDestinationName)))
            {
                parserContext.ReaderContext.ReportException(element, "request-destination or request-destination-name",
                        "Exactly one of the 'request-destination' or 'request-destination-name' attributes is required.");
            }
            if (StringUtils.HasText(requestDestination))
            {
                builder.AddPropertyReference("requestDestination", requestDestination);
            }
            else if (StringUtils.HasText(requestDestinationName))
            {
                builder.AddPropertyValue("requestDestinationName", requestDestinationName);
            }
            IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "reply-destination");
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "reply-destination-name");
            IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "reply-channel");
            IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "message-converter");
            IntegrationNamespaceUtils.SetReferenceIfAttributeDefined(builder, element, "header-mapper");
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "extract-request-payload");
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "extract-reply-payload");
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "receive-timeout");
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "pub-sub-domain");
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "delivery-mode");
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "time-to-live");
            IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "priority");

            return builder;
        }

 protected override ObjectDefinitionBuilder ParseHandler(XmlElement element, ParserContext parserContext)
 {
     ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.GenericObjectDefinition(IntegrationNamespaceUtils.FILTER_PACKAGE + ".MessageFilter");
     builder.AddConstructorArgReference(ParseSelector(element, parserContext));
     IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "throw-exception-on-rejection");
     return builder;
 }

 /// <summary>
 /// Parse the specified element and register any resulting
 /// IObjectDefinitions with the IObjectDefinitionRegistry that is
 /// embedded in the supplied ParserContext.
 /// </summary>
 /// <param name="element">The element to be parsed into one or more IObjectDefinitions</param>
 /// <param name="parserContext">The object encapsulating the current state of the parsing
 /// process.</param>
 /// <returns>
 /// The primary IObjectDefinition (can be null as explained above)
 /// </returns>
 /// <remarks>
 /// Implementations should return the primary IObjectDefinition
 /// that results from the parse phase if they wish to used nested
 /// inside (for example) a <code>&lt;property&gt;</code> tag.
 /// <para>Implementations may return null if they will not
 /// be used in a nested scenario.
 /// </para>
 /// </remarks>
 public override IObjectDefinition ParseElement(XmlElement element, ParserContext parserContext)
 {
     ParseElementCalled = true;
     ObjectDefinitionHolder holder = ParseTestObjectDefinition(element, parserContext);
     ObjectDefinitionReaderUtils.RegisterObjectDefinition(holder, parserContext.Registry);
     return null;
 }

 protected static string ParseUrl(XmlElement element, ParserContext parserContext)
 {
     string url = element.GetAttribute("url");
     if(!StringUtils.HasText(url)) {
         parserContext.ReaderContext.ReportException(element, "url", "The 'url' attribute is required.");
     }
     return url;
 }