C# MetadataImporter.NormalizePolicy方法代码示例

        public virtual bool TryGetNestedPolicyAlternatives(MetadataImporter importer, XmlElement assertion, out Collection<Collection<XmlElement>> alternatives)
        {
            alternatives = null;

            XmlElement policyElement = null;
            foreach (XmlNode node in assertion.ChildNodes)
            {
                if (node is XmlElement && node.LocalName == PolicyName && (node.NamespaceURI == WspNamespace || node.NamespaceURI == Wsp15Namespace))
                {
                    policyElement = (XmlElement)node;
                    break;
                }
            }

            if (policyElement == null)
            {
                alternatives = null;
            }
            else
            {
                IEnumerable<IEnumerable<XmlElement>> enumerableAlternatives = importer.NormalizePolicy(new XmlElement[] { policyElement });

                alternatives = new Collection<Collection<XmlElement>>();
                foreach (IEnumerable<XmlElement> enumerableAlternative in enumerableAlternatives)
                {
                    Collection<XmlElement> alternative = new Collection<XmlElement>();
                    alternatives.Add(alternative);
                    foreach (XmlElement e in enumerableAlternative)
                    {
                        alternative.Add(e);
                    }
                }
            }

            return alternatives != null;
        }

 public virtual bool TryGetNestedPolicyAlternatives(MetadataImporter importer, XmlElement assertion, out Collection<Collection<XmlElement>> alternatives)
 {
     alternatives = null;
     XmlElement element = null;
     foreach (System.Xml.XmlNode node in assertion.ChildNodes)
     {
         if (((node is XmlElement) && (node.LocalName == "Policy")) && ((node.NamespaceURI == "http://schemas.xmlsoap.org/ws/2004/09/policy") || (node.NamespaceURI == "http://www.w3.org/ns/ws-policy")))
         {
             element = (XmlElement) node;
             break;
         }
     }
     if (element == null)
     {
         alternatives = null;
     }
     else
     {
         IEnumerable<IEnumerable<XmlElement>> enumerable = importer.NormalizePolicy(new XmlElement[] { element });
         alternatives = new Collection<Collection<XmlElement>>();
         foreach (IEnumerable<XmlElement> enumerable2 in enumerable)
         {
             Collection<XmlElement> collection;
             collection = new Collection<XmlElement> {
                 collection
             };
             foreach (XmlElement element2 in enumerable2)
             {
                 collection.Add(element2);
             }
         }
     }
     return (alternatives != null);
 }

            bool TryImportDeliveryAssurance(MetadataImporter importer, XmlElement node)
            {
                string wsrmNs = ReliableSessionPolicyStrings.ReliableSession11Namespace;

                if (!IsElement(node, wsrmNs, ReliableSessionPolicyStrings.DeliveryAssurance))
                {
                    return false;
                }

                // Policy
                IEnumerator policyNodes = node.ChildNodes.GetEnumerator();
                XmlNode policyNode = SkipToNode(policyNodes);
                XmlElement policyElement = ThrowIfNotPolicyElement(policyNode, ReliableMessagingVersion.WSReliableMessaging11);
                IEnumerable<IEnumerable<XmlElement>> alternatives = importer.NormalizePolicy(new XmlElement[] { policyElement });

                foreach (IEnumerable<XmlElement> alternative in alternatives)
                {
                    State state = State.Assurance;

                    foreach (XmlElement element in alternative)
                    {
                        if (state == State.Assurance)
                        {
                            state = State.Order;

                            if (!IsElement(element, wsrmNs, ReliableSessionPolicyStrings.ExactlyOnce)
                                && !IsElement(element, wsrmNs, ReliableSessionPolicyStrings.AtMostOnce)
                                && !IsElement(element, wsrmNs, ReliableSessionPolicyStrings.AtMostOnce))
                            {
                                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(SR.GetString(
                                    SR.DeliveryAssuranceRequired,
                                    wsrmNs,
                                    element.LocalName,
                                    element.NamespaceURI)));
                            }

                            // Found required DeliveryAssurance, ignore the value and skip to InOrder
                            continue;
                        }

                        if (state == State.Order)
                        {
                            state = State.Done;

                            // InOrder
                            if (IsElement(element, wsrmNs, ReliableSessionPolicyStrings.InOrder))
                            {
                                // set ordered
                                if (!this.isOrdered)
                                {
                                    this.isOrdered = true;
                                }

                                continue;
                            }
                        }

                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(SR.GetString(
                            SR.UnexpectedXmlChildNode,
                            element.LocalName,
                            element.NodeType,
                            ReliableSessionPolicyStrings.DeliveryAssurance)));
                    }

                    if (state == State.Assurance)
                    {
                        string exceptionString = SR.GetString(SR.DeliveryAssuranceRequiredNothingFound, wsrmNs);
                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(exceptionString));
                    }
                }

                policyNode = SkipToNode(policyNodes);

                if (policyNode != null)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(SR.GetString(
                        SR.UnexpectedXmlChildNode,
                        policyNode.LocalName,
                        policyNode.NodeType,
                        node.LocalName)));
                }

                return true;
            }

        static void ProcessWsrm11Policy(MetadataImporter importer, XmlNode node, ReliableSessionBindingElement settings)
        {
            XmlElement element = ThrowIfNotPolicyElement(node, ReliableMessagingVersion.WSReliableMessaging11);
            IEnumerable<IEnumerable<XmlElement>> alternatives = importer.NormalizePolicy(new XmlElement[] { element });
            List<Wsrm11PolicyAlternative> wsrmAlternatives = new List<Wsrm11PolicyAlternative>();

            foreach (IEnumerable<XmlElement> alternative in alternatives)
            {
                Wsrm11PolicyAlternative wsrm11Policy = Wsrm11PolicyAlternative.ImportAlternative(importer, alternative);
                wsrmAlternatives.Add(wsrm11Policy);
            }

            if (wsrmAlternatives.Count == 0)
            {
                // No specific policy other than turn on WS-RM.
                return;
            }

            foreach (Wsrm11PolicyAlternative wsrmAlternative in wsrmAlternatives)
            {
                // The only policy setting that affects the binding is the InOrder assurance.
                // Even that setting does not affect the binding since InOrder is a server delivery assurance.
                // Transfer any that is valid.
                if (wsrmAlternative.HasValidPolicy)
                {
                    wsrmAlternative.TransferSettings(settings);
                    return;
                }
            }

            // Found only invalid policy.
            // This throws an exception about security since that is the only invalid policy we have.
            Wsrm11PolicyAlternative.ThrowInvalidBindingException();
        }

 private static void ProcessWsrm11Policy(MetadataImporter importer, System.Xml.XmlNode node, ReliableSessionBindingElement settings)
 {
     XmlElement element = ThrowIfNotPolicyElement(node, ReliableMessagingVersion.WSReliableMessaging11);
     IEnumerable<IEnumerable<XmlElement>> enumerable = importer.NormalizePolicy(new XmlElement[] { element });
     List<Wsrm11PolicyAlternative> list = new List<Wsrm11PolicyAlternative>();
     foreach (IEnumerable<XmlElement> enumerable2 in enumerable)
     {
         Wsrm11PolicyAlternative item = Wsrm11PolicyAlternative.ImportAlternative(importer, enumerable2);
         list.Add(item);
     }
     if (list.Count != 0)
     {
         foreach (Wsrm11PolicyAlternative alternative2 in list)
         {
             if (alternative2.HasValidPolicy)
             {
                 alternative2.TransferSettings(settings);
                 return;
             }
         }
         Wsrm11PolicyAlternative.ThrowInvalidBindingException();
     }
 }

 private bool TryImportDeliveryAssurance(MetadataImporter importer, XmlElement node)
 {
     string ns = "http://docs.oasis-open.org/ws-rx/wsrmp/200702";
     if (!ReliableSessionBindingElementImporter.IsElement(node, ns, "DeliveryAssurance"))
     {
         return false;
     }
     IEnumerator nodes = node.ChildNodes.GetEnumerator();
     XmlElement element = ReliableSessionBindingElementImporter.ThrowIfNotPolicyElement(ReliableSessionBindingElementImporter.SkipToNode(nodes), ReliableMessagingVersion.WSReliableMessaging11);
     foreach (IEnumerable<XmlElement> enumerable2 in importer.NormalizePolicy(new XmlElement[] { element }))
     {
         ReliableSessionBindingElementImporter.State assurance = ReliableSessionBindingElementImporter.State.Assurance;
         foreach (XmlElement element2 in enumerable2)
         {
             switch (assurance)
             {
                 case ReliableSessionBindingElementImporter.State.Assurance:
                 {
                     assurance = ReliableSessionBindingElementImporter.State.Order;
                     if ((!ReliableSessionBindingElementImporter.IsElement(element2, ns, "ExactlyOnce") && !ReliableSessionBindingElementImporter.IsElement(element2, ns, "AtMostOnce")) && !ReliableSessionBindingElementImporter.IsElement(element2, ns, "AtMostOnce"))
                     {
                         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(System.ServiceModel.SR.GetString("DeliveryAssuranceRequired", new object[] { ns, element2.LocalName, element2.NamespaceURI })));
                     }
                     continue;
                 }
                 case ReliableSessionBindingElementImporter.State.Order:
                     assurance = ReliableSessionBindingElementImporter.State.Done;
                     if (ReliableSessionBindingElementImporter.IsElement(element2, ns, "InOrder"))
                     {
                         if (!this.isOrdered)
                         {
                             this.isOrdered = true;
                         }
                         continue;
                     }
                     break;
             }
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(System.ServiceModel.SR.GetString("UnexpectedXmlChildNode", new object[] { element2.LocalName, element2.NodeType, "DeliveryAssurance" })));
         }
         if (assurance == ReliableSessionBindingElementImporter.State.Assurance)
         {
             string message = System.ServiceModel.SR.GetString("DeliveryAssuranceRequiredNothingFound", new object[] { ns });
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(message));
         }
     }
     System.Xml.XmlNode node2 = ReliableSessionBindingElementImporter.SkipToNode(nodes);
     if (node2 != null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(System.ServiceModel.SR.GetString("UnexpectedXmlChildNode", new object[] { node2.LocalName, node2.NodeType, node.LocalName })));
     }
     return true;
 }