C# PolicyConversionContext.GetBindingAssertions方法代码示例

 internal void OnImportPolicy(MetadataImporter importer, PolicyConversionContext context)
 {
     string str;
     XmlElement element = PolicyConversionContext.FindAssertion(context.GetBindingAssertions(), "PeerTransportSecurityMode", "http://schemas.microsoft.com/soap/peer", true);
     this.Mode = SecurityMode.Transport;
     if ((element != null) && ((str = element.InnerText) != null))
     {
         if (!(str == "PeerTransportSecurityModeNone"))
         {
             if (str == "PeerTransportSecurityModeTransport")
             {
                 this.Mode = SecurityMode.Transport;
             }
             else if (str == "PeerTransportSecurityModeMessage")
             {
                 this.Mode = SecurityMode.Message;
             }
             else if (str == "PeerTransportSecurityModeTransportWithMessageCredential")
             {
                 this.Mode = SecurityMode.TransportWithMessageCredential;
             }
         }
         else
         {
             this.Mode = SecurityMode.None;
         }
     }
     this.transportSecurity.OnImportPolicy(importer, context);
 }

        internal void OnExportPolicy(MetadataExporter exporter, PolicyConversionContext context)
        {
            string str = "";
            switch (this.Mode)
            {
                case SecurityMode.None:
                    str = "PeerTransportSecurityModeNone";
                    break;

                case SecurityMode.Transport:
                    str = "PeerTransportSecurityModeTransport";
                    break;

                case SecurityMode.Message:
                    str = "PeerTransportSecurityModeMessage";
                    break;

                case SecurityMode.TransportWithMessageCredential:
                    str = "PeerTransportSecurityModeTransportWithMessageCredential";
                    break;

                default:
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
            }
            XmlElement item = new XmlDocument().CreateElement("pc", "PeerTransportSecurityMode", "http://schemas.microsoft.com/soap/peer");
            item.InnerText = str;
            context.GetBindingAssertions().Add(item);
            this.transportSecurity.OnExportPolicy(exporter, context);
        }

 void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext policyContext)
 {
     if (policyContext == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("policyContext");
     }
     XmlElement element = PolicyConversionContext.FindAssertion(policyContext.GetBindingAssertions(), "PrivacyNotice", "http://schemas.xmlsoap.org/ws/2005/05/identity", true);
     if (element != null)
     {
         PrivacyNoticeBindingElement item = policyContext.BindingElements.Find<PrivacyNoticeBindingElement>();
         if (item == null)
         {
             item = new PrivacyNoticeBindingElement();
             policyContext.BindingElements.Add(item);
         }
         item.Url = new Uri(element.InnerText);
         string attribute = element.GetAttribute("Version", "http://schemas.xmlsoap.org/ws/2005/05/identity");
         if (string.IsNullOrEmpty(attribute))
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("CannotImportPrivacyNoticeElementWithoutVersionAttribute")));
         }
         int result = 0;
         if (!int.TryParse(attribute, out result))
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("PrivacyNoticeElementVersionAttributeInvalid")));
         }
         item.Version = result;
     }
 }

 void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext context)
 {
     if (importer == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("importer");
     }
     if (context == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
     }
     XmlElement element = PolicyConversionContext.FindAssertion(context.GetBindingAssertions(), "OneWay", "http://schemas.microsoft.com/ws/2005/05/routing/policy", true);
     if (element != null)
     {
         OneWayBindingElement item = new OneWayBindingElement();
         context.BindingElements.Add(item);
         for (int i = 0; i < element.ChildNodes.Count; i++)
         {
             System.Xml.XmlNode node = element.ChildNodes[i];
             if (((node != null) && (node.NodeType == XmlNodeType.Element)) && ((node.NamespaceURI == "http://schemas.microsoft.com/ws/2005/05/routing/policy") && (node.LocalName == "PacketRoutable")))
             {
                 item.PacketRoutable = true;
                 return;
             }
         }
     }
     else if (WsdlImporter.WSAddressingHelper.DetermineSupportedAddressingMode(importer, context) == SupportedAddressingMode.NonAnonymous)
     {
         context.BindingElements.Add(new OneWayBindingElement());
     }
 }

        void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext context)
        {
            if (importer == null)
            {
                throw new ArgumentNullException("importer");
            }

            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ICollection<XmlElement> assertions = context.GetBindingAssertions();

            foreach (XmlElement assertion in assertions)
            {
                if (assertion.NamespaceURI == MakeConnectionConstants.Namespace)
                {
                    if (assertion.LocalName == MakeConnectionConstants.Policy.Assertion)
                    {
                        assertions.Remove(assertion);
                        context.BindingElements.Insert(0, new MakeConnectionBindingElement());
                        return;
                    }
                }
            }
        }

        internal void OnImportPolicy(MetadataImporter importer, PolicyConversionContext context)
        {
            XmlElement element = PolicyConversionContext.FindAssertion(context.GetBindingAssertions(),
                                    PeerTransportPolicyConstants.PeerTransportSecurityMode,
                                    TransportPolicyConstants.PeerTransportUri, true);

            this.Mode = SecurityMode.Transport;
            if (element != null)
            {
                switch (element.InnerText)
                {
                    case PeerTransportPolicyConstants.PeerTransportSecurityModeNone:
                        this.Mode = SecurityMode.None;
                        break;
                    case PeerTransportPolicyConstants.PeerTransportSecurityModeTransport:
                        this.Mode = SecurityMode.Transport;
                        break;
                    case PeerTransportPolicyConstants.PeerTransportSecurityModeMessage:
                        this.Mode = SecurityMode.Message;
                        break;
                    case PeerTransportPolicyConstants.PeerTransportSecurityModeTransportWithMessageCredential:
                        this.Mode = SecurityMode.TransportWithMessageCredential;
                        break;
                    default:
                        break;
                }
            }
            transportSecurity.OnImportPolicy(importer, context);
        }

        void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext context)
        {
            if (importer == null)
            {
                throw new ArgumentNullException("importer");
            }
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            UdpTransportBindingElement udpBindingElement = null;
            bool multicast = false;
            PolicyAssertionCollection policyAssertions = context.GetBindingAssertions();
            if (policyAssertions.Remove(UdpPolicyStrings.TransportAssertion, UdpPolicyStrings.UdpNamespace) != null)
            {
                udpBindingElement = new UdpTransportBindingElement();
            }
            if (policyAssertions.Remove(UdpPolicyStrings.MulticastAssertion, UdpPolicyStrings.UdpNamespace) != null)
            {
                multicast = true;
            }
            if (udpBindingElement != null)
            {
                udpBindingElement.Multicast = multicast;
                context.BindingElements.Add(udpBindingElement);
            }
        }

        void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext policyContext)
        {
            if (policyContext == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("policyContext");

            XmlElement privacyNoticeAssertion = PolicyConversionContext.FindAssertion(policyContext.GetBindingAssertions(),
                PrivacyNoticePolicyStrings.PrivacyNoticeName, PrivacyNoticePolicyStrings.PrivacyNoticeNamespace, true);
            if (privacyNoticeAssertion != null)
            {
                PrivacyNoticeBindingElement settings =
                    policyContext.BindingElements.Find<PrivacyNoticeBindingElement>();

                if (null == settings)
                {
                    settings = new PrivacyNoticeBindingElement();
                    policyContext.BindingElements.Add(settings);
                }

                settings.Url = new Uri(privacyNoticeAssertion.InnerText);
                string versionString = privacyNoticeAssertion.GetAttribute(PrivacyNoticePolicyStrings.PrivacyNoticeVersionAttributeName, PrivacyNoticePolicyStrings.PrivacyNoticeNamespace);
                if (string.IsNullOrEmpty(versionString))
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.CannotImportPrivacyNoticeElementWithoutVersionAttribute)));
                }

                int version = 0;
                if (!Int32.TryParse(versionString, out version))
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.PrivacyNoticeElementVersionAttributeInvalid)));
                }
                settings.Version = version;
            }
        }

        void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext context)
        {
            if (importer == null)
            {
                throw new ArgumentNullException("importer");
            }

            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ICollection<XmlElement> assertions = context.GetBindingAssertions();
            foreach (XmlElement assertion in assertions)
            {
                if ((assertion.NamespaceURI == GZipMessageEncodingPolicyConstants.GZipEncodingNamespace) &&
                    (assertion.LocalName == GZipMessageEncodingPolicyConstants.GZipEncodingName)
                    )
                {
                    assertions.Remove(assertion);
                    context.BindingElements.Add(new GZipMessageEncodingBindingElement());
                    break;
                }
            }
        }

        void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext context)
        {
            if (importer == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("importer");
            }

            if (context == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
            }

            bool gotAssertion = false;

            XmlElement reliableSessionAssertion = PolicyConversionContext.FindAssertion(context.GetBindingAssertions(),
                ReliableSessionPolicyStrings.ReliableSessionName,
                ReliableSessionPolicyStrings.ReliableSessionFebruary2005Namespace, true);

            if (reliableSessionAssertion != null)
            {
                ProcessReliableSessionFeb2005Assertion(reliableSessionAssertion, GetReliableSessionBindingElement(context));
                gotAssertion = true;
            }

            reliableSessionAssertion = PolicyConversionContext.FindAssertion(context.GetBindingAssertions(),
                ReliableSessionPolicyStrings.ReliableSessionName,
                ReliableSessionPolicyStrings.ReliableSession11Namespace, true);

            if (reliableSessionAssertion != null)
            {
                if (gotAssertion)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidChannelBindingException(
                        SR.GetString(SR.MultipleVersionsFoundInPolicy,
                        ReliableSessionPolicyStrings.ReliableSessionName)));
                }

                ProcessReliableSession11Assertion(importer, reliableSessionAssertion,
                    GetReliableSessionBindingElement(context));
            }
        }

        void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext context)
        {
            if (importer == null)
            {
                throw new ArgumentNullException("importer");
            }

            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ICollection<XmlElement> bindingAssertions = context.GetBindingAssertions();
            List<XmlElement> processedAssertions = new List<XmlElement>();
            UdpTransportBindingElement udpBindingElement = null;
            bool multicast = false;
            foreach (XmlElement assertion in bindingAssertions)
            {
                if (assertion.NamespaceURI != UdpPolicyStrings.UdpNamespace)
                {
                    continue;
                }

                switch (assertion.LocalName)
                {
                    case UdpPolicyStrings.TransportAssertion:
                        udpBindingElement = new UdpTransportBindingElement();
                        break;
                    case UdpPolicyStrings.MulticastAssertion:
                        multicast = true;
                        break;
                    default:
                        continue;
                }

                processedAssertions.Add(assertion);
            }

            if (udpBindingElement != null)
            {
                udpBindingElement.Multicast = multicast;
                context.BindingElements.Add(udpBindingElement);
            }

            for (int i = 0; i < processedAssertions.Count; i++)
            {
                bindingAssertions.Remove(processedAssertions[i]);
            }
        }

 void IPolicyImportExtension.ImportPolicy(MetadataImporter importer, PolicyConversionContext context)
 {
     if (importer == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("importer");
     }
     if (context == null)
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
     }
     if ((PolicyConversionContext.FindAssertion(context.GetBindingAssertions(), "CompositeDuplex", "http://schemas.microsoft.com/net/2006/06/duplex", true) != null) || (WsdlImporter.WSAddressingHelper.DetermineSupportedAddressingMode(importer, context) == SupportedAddressingMode.NonAnonymous))
     {
         context.BindingElements.Add(new CompositeDuplexBindingElement());
     }
 }

 private static TransportBindingElement CreateTransportBindingElements(string transportUri, PolicyConversionContext policyContext)
 {
     TransportBindingElement element = null;
     string str = transportUri;
     if (str != null)
     {
         if (!(str == "http://schemas.xmlsoap.org/soap/http"))
         {
             if (str == "http://schemas.microsoft.com/soap/tcp")
             {
                 return new TcpTransportBindingElement();
             }
             if (str == "http://schemas.microsoft.com/soap/named-pipe")
             {
                 return new NamedPipeTransportBindingElement();
             }
             if (str == "http://schemas.microsoft.com/soap/msmq")
             {
                 return new MsmqTransportBindingElement();
             }
             if (str != "http://schemas.microsoft.com/soap/peer")
             {
                 return element;
             }
             return new PeerTransportBindingElement();
         }
         if (policyContext != null)
         {
             WSSecurityPolicy securityPolicy = null;
             ICollection<XmlElement> bindingAssertions = policyContext.GetBindingAssertions();
             if (WSSecurityPolicy.TryGetSecurityPolicyDriver(bindingAssertions, out securityPolicy) && securityPolicy.ContainsWsspHttpsTokenAssertion(bindingAssertions))
             {
                 HttpsTransportBindingElement element2 = new HttpsTransportBindingElement {
                     MessageSecurityVersion = securityPolicy.GetSupportedMessageSecurityVersion(SecurityVersion.WSSecurity11)
                 };
                 element = element2;
             }
         }
         if (element == null)
         {
             element = new HttpTransportBindingElement();
         }
     }
     return element;
 }

        internal void OnExportPolicy(MetadataExporter exporter, PolicyConversionContext context)
        {
            string str = "";
            switch (this.CredentialType)
            {
                case PeerTransportCredentialType.Password:
                    str = "PeerTransportCredentialTypePassword";
                    break;

                case PeerTransportCredentialType.Certificate:
                    str = "PeerTransportCredentialTypeCertificate";
                    break;

                default:
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
            }
            XmlElement item = new XmlDocument().CreateElement("pc", "PeerTransportCredentialType", "http://schemas.microsoft.com/soap/peer");
            item.InnerText = str;
            context.GetBindingAssertions().Add(item);
        }

		void IPolicyImportExtension.ImportPolicy (MetadataImporter importer,
			PolicyConversionContext context)
		{
			var assertions = context.GetBindingAssertions ();

			var mtom = PolicyImportHelper.GetMtomMessageEncodingPolicy (assertions);
			if (mtom != null) {
				// http://www.w3.org/Submission/WS-MTOMPolicy/
				context.BindingElements.Add (new MtomMessageEncodingBindingElement ());
				return;
			}

			var binary = PolicyImportHelper.GetBinaryMessageEncodingPolicy (assertions);
			if (binary != null) {
				context.BindingElements.Add (new BinaryMessageEncodingBindingElement ());
				return;
			}

			context.BindingElements.Add (new TextMessageEncodingBindingElement ());
		}