linux-packaging-mono/mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Description/WsdlExporter.cs

//-----------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------

namespace System.ServiceModel.Description
{
    using System.Collections;
    using System.Collections.Generic;
    using System.Globalization;
    using System.IO;
    using System.Runtime;
    using System.ServiceModel;
    using System.ServiceModel.Channels;
    using System.Xml;
    using System.Xml.Schema;
    using System.Xml.Serialization;
    using WsdlNS = System.Web.Services.Description;

    public class WsdlExporter : MetadataExporter
    {
        static XmlDocument xmlDocument;
        bool isFaulted = false;


        WsdlNS.ServiceDescriptionCollection wsdlDocuments = new WsdlNS.ServiceDescriptionCollection();
        XmlSchemaSet xmlSchemas = WsdlExporter.GetEmptySchemaSet();

        Dictionary<ContractDescription, WsdlContractConversionContext> exportedContracts
            = new Dictionary<ContractDescription, WsdlContractConversionContext>();
        Dictionary<BindingDictionaryKey, WsdlEndpointConversionContext> exportedBindings = new Dictionary<BindingDictionaryKey, WsdlEndpointConversionContext>();
        Dictionary<EndpointDictionaryKey, ServiceEndpoint> exportedEndpoints = new Dictionary<EndpointDictionaryKey, ServiceEndpoint>();

        public override void ExportContract(ContractDescription contract)
        {
            if (this.isFaulted)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.WsdlExporterIsFaulted)));

            if (contract == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contract");

            if (!this.exportedContracts.ContainsKey(contract))
            {
                try
                {
                    WsdlNS.PortType wsdlPortType = CreateWsdlPortType(contract);
                    WsdlContractConversionContext contractContext;


                    contractContext = new WsdlContractConversionContext(contract, wsdlPortType);

                    foreach (OperationDescription operation in contract.Operations)
                    {
                        bool isWildcardAction;
                        if (!OperationIsExportable(operation, out isWildcardAction))
                        {
                            string warningMsg = isWildcardAction ? SR.GetString(SR.WarnSkippingOpertationWithWildcardAction, contract.Name, contract.Namespace, operation.Name)
                                : SR.GetString(SR.WarnSkippingOpertationWithSessionOpenNotificationEnabled, "Action", OperationDescription.SessionOpenedAction, contract.Name, contract.Namespace, operation.Name);

                            LogExportWarning(warningMsg);
                            continue;
                        }

                        WsdlNS.Operation wsdlOperation = CreateWsdlOperation(operation, contract);
                        wsdlPortType.Operations.Add(wsdlOperation);

                        contractContext.AddOperation(operation, wsdlOperation);

                        foreach (MessageDescription message in operation.Messages)
                        {
                            //Create Operation Message
                            WsdlNS.OperationMessage wsdlOperationMessage = CreateWsdlOperationMessage(message);
                            wsdlOperation.Messages.Add(wsdlOperationMessage);
                            contractContext.AddMessage(message, wsdlOperationMessage);
                        }

                        foreach (FaultDescription fault in operation.Faults)
                        {
                            //Create Operation Fault
                            WsdlNS.OperationFault wsdlOperationFault = CreateWsdlOperationFault(fault);
                            wsdlOperation.Faults.Add(wsdlOperationFault);
                            contractContext.AddFault(fault, wsdlOperationFault);
                        }
                    }

                    CallExportContract(contractContext);

                    exportedContracts.Add(contract, contractContext);
                }
                catch
                {
                    isFaulted = true;
                    throw;
                }
            }
        }

        public override void ExportEndpoint(ServiceEndpoint endpoint)
        {
            if (this.isFaulted)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.WsdlExporterIsFaulted)));

            if (endpoint == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpoint");

            ExportEndpoint(endpoint, new XmlQualifiedName(NamingHelper.DefaultServiceName, NamingHelper.DefaultNamespace), null);
        }

        public void ExportEndpoints(IEnumerable<ServiceEndpoint> endpoints, XmlQualifiedName wsdlServiceQName)
        {
            this.ExportEndpoints(endpoints, wsdlServiceQName, null);
        }

        internal void ExportEndpoints(IEnumerable<ServiceEndpoint> endpoints, XmlQualifiedName wsdlServiceQName, BindingParameterCollection bindingParameters)
        {
            if (this.isFaulted)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.WsdlExporterIsFaulted)));

            if (endpoints == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpoints");
            if (wsdlServiceQName == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("wsdlServiceQName");

            foreach (ServiceEndpoint endpoint in endpoints)
            {
                ExportEndpoint(endpoint, wsdlServiceQName, bindingParameters);
            }
        }

        public override MetadataSet GetGeneratedMetadata()
        {
            MetadataSet set = new MetadataSet();

            foreach (WsdlNS.ServiceDescription wsdl in wsdlDocuments)
                set.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(wsdl));

            foreach (XmlSchema schema in xmlSchemas.Schemas())
                set.MetadataSections.Add(MetadataSection.CreateFromSchema(schema));

            return set;
        }

        public WsdlNS.ServiceDescriptionCollection GeneratedWsdlDocuments { get { return wsdlDocuments; } }
        public XmlSchemaSet GeneratedXmlSchemas { get { return xmlSchemas; } }

        void ExportEndpoint(ServiceEndpoint endpoint, XmlQualifiedName wsdlServiceQName, BindingParameterCollection bindingParameters)
        {
            if (endpoint.Binding == null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.EndpointsMustHaveAValidBinding1, endpoint.Name)));

            EndpointDictionaryKey endpointKey = new EndpointDictionaryKey(endpoint, wsdlServiceQName);

            try
            {
                if (exportedEndpoints.ContainsKey(endpointKey))
                    return;

                this.ExportContract(endpoint.Contract);

                // Retreive Conversion Context for Contract;
                // Note: Contract must have already been exported at this point.
                WsdlContractConversionContext contractContext = this.exportedContracts[endpoint.Contract];


                bool newWsdlBinding, bindingNameWasUniquified;
                WsdlNS.Port wsdlPort;
                WsdlNS.Binding wsdlBinding;
                wsdlBinding = CreateWsdlBindingAndPort(endpoint, wsdlServiceQName, out wsdlPort, out newWsdlBinding, out bindingNameWasUniquified);


                if (!newWsdlBinding && wsdlPort == null)
                    return;

                // Create an Endpoint conversion context based on 
                // the contract's conversion context (reuse contract correlation information)
                WsdlEndpointConversionContext endpointContext;
                if (newWsdlBinding)
                {
                    endpointContext = new WsdlEndpointConversionContext(contractContext, endpoint, wsdlBinding, wsdlPort);

                    foreach (OperationDescription operation in endpoint.Contract.Operations)
                    {
                        if (!WsdlExporter.OperationIsExportable(operation))
                        {
                            continue;
                        }

                        WsdlNS.OperationBinding wsdlOperationBinding = CreateWsdlOperationBinding(endpoint.Contract, operation);
                        wsdlBinding.Operations.Add(wsdlOperationBinding);

                        endpointContext.AddOperationBinding(operation, wsdlOperationBinding);

                        foreach (MessageDescription message in operation.Messages)
                        {
                            WsdlNS.MessageBinding wsdlMessageBinding = CreateWsdlMessageBinding(message, endpoint.Binding, wsdlOperationBinding);
                            endpointContext.AddMessageBinding(message, wsdlMessageBinding);
                        }

                        foreach (FaultDescription fault in operation.Faults)
                        {
                            WsdlNS.FaultBinding wsdlFaultBinding = CreateWsdlFaultBinding(fault, endpoint.Binding, wsdlOperationBinding);
                            endpointContext.AddFaultBinding(fault, wsdlFaultBinding);
                        }
                    }

                    // CSDMain 180381:  Added internal functionality for passing BindingParameters into the ExportPolicy process via PolicyConversionContext.
                    // However, in order to not change existing behavior, we only call the internal ExportPolicy method which accepts BindingParameters if they are not null
                    // (non-null binding parameters can only be passed in via internal code paths).  Otherwise, we call the existing ExportPolicy method, just like before.
                    PolicyConversionContext policyContext;
                    if (bindingParameters == null)
                    {
                        policyContext = this.ExportPolicy(endpoint);
                    }
                    else
                    {
                        policyContext = this.ExportPolicy(endpoint, bindingParameters);
                    }
                    // consider factoring this out of wsdl exporter
                    new WSPolicyAttachmentHelper(this.PolicyVersion).AttachPolicy(endpoint, endpointContext, policyContext);
                    exportedBindings.Add(new BindingDictionaryKey(endpoint.Contract, endpoint.Binding), endpointContext);
                }
                else
                {
                    endpointContext = new WsdlEndpointConversionContext(exportedBindings[new BindingDictionaryKey(endpoint.Contract, endpoint.Binding)], endpoint, wsdlPort);
                }

                CallExportEndpoint(endpointContext);
                exportedEndpoints.Add(endpointKey, endpoint);
                if (bindingNameWasUniquified)
                    Errors.Add(new MetadataConversionError(SR.GetString(SR.WarnDuplicateBindingQNameNameOnExport, endpoint.Binding.Name, endpoint.Binding.Namespace, endpoint.Contract.Name), true /*isWarning*/));
            }
            catch
            {
                isFaulted = true;
                throw;
            }
        }

        void CallExportEndpoint(WsdlEndpointConversionContext endpointContext)
        {
            foreach (IWsdlExportExtension extension in endpointContext.ExportExtensions)
            {
                CallExtension(endpointContext, extension);
            }
        }

        void CallExportContract(WsdlContractConversionContext contractContext)
        {
            foreach (IWsdlExportExtension extension in contractContext.ExportExtensions)
            {
                CallExtension(contractContext, extension);
            }
        }

        WsdlNS.PortType CreateWsdlPortType(ContractDescription contract)
        {
            XmlQualifiedName wsdlPortTypeQName = WsdlNamingHelper.GetPortTypeQName(contract);

            WsdlNS.ServiceDescription wsdl = GetOrCreateWsdl(wsdlPortTypeQName.Namespace);
            WsdlNS.PortType wsdlPortType = new WsdlNS.PortType();
            wsdlPortType.Name = wsdlPortTypeQName.Name;
            if (wsdl.PortTypes[wsdlPortType.Name] != null)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.DuplicateContractQNameNameOnExport, contract.Name, contract.Namespace)));
            NetSessionHelper.AddUsingSessionAttributeIfNeeded(wsdlPortType, contract);
            wsdl.PortTypes.Add(wsdlPortType);

            return wsdlPortType;
        }

        WsdlNS.Operation CreateWsdlOperation(OperationDescription operation, ContractDescription contract)
        {
            WsdlNS.Operation wsdlOperation = new WsdlNS.Operation();
            wsdlOperation.Name = WsdlNamingHelper.GetWsdlOperationName(operation, contract);
            NetSessionHelper.AddInitiatingTerminatingAttributesIfNeeded(wsdlOperation, operation, contract);
            return wsdlOperation;
        }

        WsdlNS.OperationMessage CreateWsdlOperationMessage(MessageDescription message)
        {
            WsdlNS.OperationMessage wsdlOperationMessage;

            if (message.Direction == MessageDirection.Input)
                wsdlOperationMessage = new WsdlNS.OperationInput();
            else
                wsdlOperationMessage = new WsdlNS.OperationOutput();

            if (!XmlName.IsNullOrEmpty(message.MessageName))
                wsdlOperationMessage.Name = message.MessageName.EncodedName;

            // consider factoring this out of wslExporter
            WSAddressingHelper.AddActionAttribute(message.Action, wsdlOperationMessage, this.PolicyVersion);
            return wsdlOperationMessage;
        }

        WsdlNS.OperationFault CreateWsdlOperationFault(FaultDescription fault)
        {
            WsdlNS.OperationFault wsdlOperationFault;
            wsdlOperationFault = new WsdlNS.OperationFault();

            // operation fault name must not be empty (FaultDescription checks this)
            wsdlOperationFault.Name = fault.Name;

            // consider factoring this out of wslExporter
            WSAddressingHelper.AddActionAttribute(fault.Action, wsdlOperationFault, this.PolicyVersion);
            return wsdlOperationFault;
        }

        WsdlNS.Binding CreateWsdlBindingAndPort(ServiceEndpoint endpoint, XmlQualifiedName wsdlServiceQName, out WsdlNS.Port wsdlPort, out bool newBinding, out bool bindingNameWasUniquified)
        {
            WsdlNS.ServiceDescription bindingWsdl;
            WsdlNS.Binding wsdlBinding;
            WsdlEndpointConversionContext bindingConversionContext;
            XmlQualifiedName wsdlBindingQName;
            XmlQualifiedName wsdlPortTypeQName;
            bool printWsdlDeclaration = IsWsdlExportable(endpoint.Binding);

            if (!exportedBindings.TryGetValue(new BindingDictionaryKey(endpoint.Contract, endpoint.Binding), out bindingConversionContext))
            {
                wsdlBindingQName = WsdlNamingHelper.GetBindingQName(endpoint, this, out bindingNameWasUniquified);
                bindingWsdl = GetOrCreateWsdl(wsdlBindingQName.Namespace);
                wsdlBinding = new WsdlNS.Binding();
                wsdlBinding.Name = wsdlBindingQName.Name;
                newBinding = true;

                WsdlNS.PortType wsdlPortType = exportedContracts[endpoint.Contract].WsdlPortType;
                wsdlPortTypeQName = new XmlQualifiedName(wsdlPortType.Name, wsdlPortType.ServiceDescription.TargetNamespace);
                wsdlBinding.Type = wsdlPortTypeQName;
                if (printWsdlDeclaration)
                {
                    bindingWsdl.Bindings.Add(wsdlBinding);
                }
                WsdlExporter.EnsureWsdlContainsImport(bindingWsdl, wsdlPortTypeQName.Namespace);
            }
            else
            {
                wsdlBindingQName = new XmlQualifiedName(bindingConversionContext.WsdlBinding.Name, bindingConversionContext.WsdlBinding.ServiceDescription.TargetNamespace);
                bindingNameWasUniquified = false;
                bindingWsdl = wsdlDocuments[wsdlBindingQName.Namespace];
                wsdlBinding = bindingWsdl.Bindings[wsdlBindingQName.Name];
                wsdlPortTypeQName = wsdlBinding.Type;
                newBinding = false;
            }


            //We can only create a Port if there is an address
            if (endpoint.Address != null)
            {
                WsdlNS.Service wsdlService = GetOrCreateWsdlService(wsdlServiceQName);

                wsdlPort = new WsdlNS.Port();
                string wsdlPortName = WsdlNamingHelper.GetPortName(endpoint, wsdlService);
                wsdlPort.Name = wsdlPortName;
                wsdlPort.Binding = wsdlBindingQName;

                WsdlNS.SoapAddressBinding addressBinding = SoapHelper.GetOrCreateSoapAddressBinding(wsdlBinding, wsdlPort, this);

                if (addressBinding != null)
                {
                    addressBinding.Location = endpoint.Address.Uri.AbsoluteUri;
                }

                WsdlExporter.EnsureWsdlContainsImport(wsdlService.ServiceDescription, wsdlBindingQName.Namespace);
                if (printWsdlDeclaration)
                {
                    wsdlService.Ports.Add(wsdlPort);
                }
            }
            else
            {
                wsdlPort = null;
            }

            return wsdlBinding;
        }

        WsdlNS.OperationBinding CreateWsdlOperationBinding(ContractDescription contract, OperationDescription operation)
        {
            WsdlNS.OperationBinding wsdlOperationBinding = new WsdlNS.OperationBinding();
            wsdlOperationBinding.Name = WsdlNamingHelper.GetWsdlOperationName(operation, contract);
            return wsdlOperationBinding;
        }

        WsdlNS.MessageBinding CreateWsdlMessageBinding(MessageDescription messageDescription, Binding binding, WsdlNS.OperationBinding wsdlOperationBinding)
        {
            WsdlNS.MessageBinding wsdlMessageBinding;
            if (messageDescription.Direction == MessageDirection.Input)
            {
                wsdlOperationBinding.Input = new WsdlNS.InputBinding();
                wsdlMessageBinding = wsdlOperationBinding.Input;
            }
            else
            {
                wsdlOperationBinding.Output = new WsdlNS.OutputBinding();
                wsdlMessageBinding = wsdlOperationBinding.Output;
            }

            if (!XmlName.IsNullOrEmpty(messageDescription.MessageName))
                wsdlMessageBinding.Name = messageDescription.MessageName.EncodedName;

            return wsdlMessageBinding;
        }

        WsdlNS.FaultBinding CreateWsdlFaultBinding(FaultDescription faultDescription, Binding binding, WsdlNS.OperationBinding wsdlOperationBinding)
        {
            WsdlNS.FaultBinding wsdlFaultBinding = new WsdlNS.FaultBinding();
            wsdlOperationBinding.Faults.Add(wsdlFaultBinding);
            if (faultDescription.Name != null)
                wsdlFaultBinding.Name = faultDescription.Name;

            return wsdlFaultBinding;
        }

        internal static bool OperationIsExportable(OperationDescription operation)
        {
            bool isWildcardAction;
            return OperationIsExportable(operation, out isWildcardAction);
        }

        internal static bool OperationIsExportable(OperationDescription operation, out bool isWildcardAction)
        {
            isWildcardAction = false;

            if (operation.IsSessionOpenNotificationEnabled)
            {
                return false;
            }

            for (int i = 0; i < operation.Messages.Count; i++)
            {
                if (operation.Messages[i].Action == MessageHeaders.WildcardAction)
                {
                    isWildcardAction = true;
                    return false;
                }
            }
            return true;
        }

        internal static bool IsBuiltInOperationBehavior(IWsdlExportExtension extension)
        {
            DataContractSerializerOperationBehavior dcsob = extension as DataContractSerializerOperationBehavior;
            if (dcsob != null)
            {
                return dcsob.IsBuiltInOperationBehavior;
            }

            XmlSerializerOperationBehavior xsob = extension as XmlSerializerOperationBehavior;
            if (xsob != null)
            {
                return xsob.IsBuiltInOperationBehavior;
            }

            return false;
        }

        static XmlDocument XmlDoc
        {
            get
            {
                if (xmlDocument == null)
                {
                    NameTable nameTable = new NameTable();
                    nameTable.Add(MetadataStrings.WSPolicy.Elements.Policy);
                    nameTable.Add(MetadataStrings.WSPolicy.Elements.All);
                    nameTable.Add(MetadataStrings.WSPolicy.Elements.ExactlyOne);
                    nameTable.Add(MetadataStrings.WSPolicy.Attributes.PolicyURIs);
                    nameTable.Add(MetadataStrings.Wsu.Attributes.Id);
                    nameTable.Add(MetadataStrings.Addressing200408.Policy.UsingAddressing);
                    nameTable.Add(MetadataStrings.Addressing10.WsdlBindingPolicy.UsingAddressing);
                    nameTable.Add(MetadataStrings.Addressing10.MetadataPolicy.Addressing);
                    nameTable.Add(MetadataStrings.Addressing10.MetadataPolicy.AnonymousResponses);
                    nameTable.Add(MetadataStrings.Addressing10.MetadataPolicy.NonAnonymousResponses);
                    xmlDocument = new XmlDocument(nameTable);
                }
                return xmlDocument;
            }
        }

        // Generate WSDL Document if it doesn't already exist otherwise, return the appropriate WSDL document
        internal WsdlNS.ServiceDescription GetOrCreateWsdl(string ns)
        {
            // NOTE: this method is not thread safe
            WsdlNS.ServiceDescriptionCollection wsdlCollection = this.wsdlDocuments;
            WsdlNS.ServiceDescription wsdl = wsdlCollection[ns];

            // Look for wsdl in service descriptions that have been created. If we cannot find it then we create it
            if (wsdl == null)
            {
                wsdl = new WsdlNS.ServiceDescription();
                wsdl.TargetNamespace = ns;

                XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces(new WsdlNamespaceHelper(this.PolicyVersion).SerializerNamespaces);
                if (!string.IsNullOrEmpty(wsdl.TargetNamespace))
                    namespaces.Add("tns", wsdl.TargetNamespace);
                wsdl.Namespaces = namespaces;

                wsdlCollection.Add(wsdl);
            }

            return wsdl;
        }

        WsdlNS.Service GetOrCreateWsdlService(XmlQualifiedName wsdlServiceQName)
        {
            // NOTE: this method is not thread safe

            WsdlNS.ServiceDescription wsdl = GetOrCreateWsdl(wsdlServiceQName.Namespace);

            WsdlNS.Service wsdlService = wsdl.Services[wsdlServiceQName.Name];
            if (wsdlService == null)
            {
                //Service not found. Create service.
                wsdlService = new WsdlNS.Service();
                wsdlService.Name = wsdlServiceQName.Name;

                if (string.IsNullOrEmpty(wsdl.Name))
                    wsdl.Name = wsdlService.Name;

                wsdl.Services.Add(wsdlService);
            }
            return wsdlService;
        }

        static void EnsureWsdlContainsImport(WsdlNS.ServiceDescription srcWsdl, string target)
        {
            if (srcWsdl.TargetNamespace == target)
                return;
            // FindImport
            foreach (WsdlNS.Import import in srcWsdl.Imports)
            {
                if (import.Namespace == target)
                    return;
            }
            {
                WsdlNS.Import import = new WsdlNS.Import();
                import.Location = null;
                import.Namespace = target;
                srcWsdl.Imports.Add(import);
                WsdlNamespaceHelper.FindOrCreatePrefix("i", target, srcWsdl);
                return;
            }
        }

        void LogExportWarning(string warningMessage)
        {
            this.Errors.Add(new MetadataConversionError(warningMessage, true));
        }

        static internal XmlSchemaSet GetEmptySchemaSet()
        {
            XmlSchemaSet schemaSet = new XmlSchemaSet();
            schemaSet.XmlResolver = null;
            return schemaSet;
        }

        static bool IsWsdlExportable(Binding binding)
        {
            BindingElementCollection bindingElements = binding.CreateBindingElements();
            if (bindingElements == null)
            {
                return true;
            }
            foreach (BindingElement bindingElement in bindingElements)
            {
                MessageEncodingBindingElement messageEncodingBindingElement = bindingElement as MessageEncodingBindingElement;
                if (messageEncodingBindingElement != null && !messageEncodingBindingElement.IsWsdlExportable)
                {
                    return false;
                }
            }
            return true;
        }

        internal static class WSAddressingHelper
        {
            internal static void AddActionAttribute(string actionUri, WsdlNS.OperationMessage wsdlOperationMessage, PolicyVersion policyVersion)
            {
                XmlAttribute attribute;
                if (policyVersion == PolicyVersion.Policy12)
                {
                    attribute = WsdlExporter.XmlDoc.CreateAttribute(MetadataStrings.AddressingWsdl.Prefix,
                        MetadataStrings.AddressingWsdl.Action,
                        MetadataStrings.AddressingWsdl.NamespaceUri);
                }
                else
                {
                    attribute = WsdlExporter.XmlDoc.CreateAttribute(MetadataStrings.AddressingMetadata.Prefix,
                        MetadataStrings.AddressingMetadata.Action,
                        MetadataStrings.AddressingMetadata.NamespaceUri);
                }

                attribute.Value = actionUri;
                wsdlOperationMessage.ExtensibleAttributes = new XmlAttribute[] { attribute };
            }

            internal static void AddAddressToWsdlPort(WsdlNS.Port wsdlPort, EndpointAddress addr, AddressingVersion addressing)
            {
                if (addressing == AddressingVersion.None)
                {
                    return;
                }

                MemoryStream stream = new MemoryStream();
                XmlWriter xw = XmlWriter.Create(stream);
                xw.WriteStartElement("temp");

                if (addressing == AddressingVersion.WSAddressing10)
                {
                    xw.WriteAttributeString("xmlns", MetadataStrings.Addressing10.Prefix, null, MetadataStrings.Addressing10.NamespaceUri);
                }
                else if (addressing == AddressingVersion.WSAddressingAugust2004)
                {
                    xw.WriteAttributeString("xmlns", MetadataStrings.Addressing200408.Prefix, null, MetadataStrings.Addressing200408.NamespaceUri);
                }
                else
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
                        new InvalidOperationException(SR.GetString(SR.AddressingVersionNotSupported, addressing)));
                }

                addr.WriteTo(addressing, xw);
                xw.WriteEndElement();

                xw.Flush();
                stream.Seek(0, SeekOrigin.Begin);

                XmlReader xr = XmlReader.Create(stream);
                xr.MoveToContent();
                XmlElement endpointRef = (XmlElement)XmlDoc.ReadNode(xr).ChildNodes[0];

                wsdlPort.Extensions.Add(endpointRef);
            }

            internal static void AddWSAddressingAssertion(MetadataExporter exporter, PolicyConversionContext context, AddressingVersion addressVersion)
            {
                XmlElement addressingAssertion;
                if (addressVersion == AddressingVersion.WSAddressingAugust2004)
                {
                    addressingAssertion = XmlDoc.CreateElement(MetadataStrings.Addressing200408.Policy.Prefix,
                        MetadataStrings.Addressing200408.Policy.UsingAddressing,
                        MetadataStrings.Addressing200408.Policy.NamespaceUri);
                }
                else if (addressVersion == AddressingVersion.WSAddressing10)
                {
                    if (exporter.PolicyVersion == PolicyVersion.Policy12)
                    {
                        addressingAssertion = XmlDoc.CreateElement(MetadataStrings.Addressing10.WsdlBindingPolicy.Prefix,
                            MetadataStrings.Addressing10.WsdlBindingPolicy.UsingAddressing,
                            MetadataStrings.Addressing10.WsdlBindingPolicy.NamespaceUri);
                    }
                    else
                    {
                        addressingAssertion = XmlDoc.CreateElement(MetadataStrings.Addressing10.MetadataPolicy.Prefix,
                            MetadataStrings.Addressing10.MetadataPolicy.Addressing,
                            MetadataStrings.Addressing10.MetadataPolicy.NamespaceUri);

                        // All of our existing transports are anonymous, so default to it.
                        SupportedAddressingMode mode = SupportedAddressingMode.Anonymous;
                        string key = typeof(SupportedAddressingMode).Name;

                        if (exporter.State.ContainsKey(key) && exporter.State[key] is SupportedAddressingMode)
                        {
                            mode = (SupportedAddressingMode)exporter.State[key];
                            if (!SupportedAddressingModeHelper.IsDefined(mode))
                                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SupportedAddressingModeNotSupported, mode)));
                        }

                        if (mode != SupportedAddressingMode.Mixed)
                        {
                            string responsesAssertionLocalName;
                            if (mode == SupportedAddressingMode.Anonymous)
                            {
                                responsesAssertionLocalName = MetadataStrings.Addressing10.MetadataPolicy.AnonymousResponses;
                            }
                            else
                            {
                                responsesAssertionLocalName = MetadataStrings.Addressing10.MetadataPolicy.NonAnonymousResponses;
                            }

                            XmlElement innerPolicyElement = XmlDoc.CreateElement(MetadataStrings.WSPolicy.Prefix,
                                    MetadataStrings.WSPolicy.Elements.Policy,
                                    MetadataStrings.WSPolicy.NamespaceUri15);

                            XmlElement responsesAssertion = XmlDoc.CreateElement(MetadataStrings.Addressing10.MetadataPolicy.Prefix,
                                    responsesAssertionLocalName,
                                    MetadataStrings.Addressing10.MetadataPolicy.NamespaceUri);

                            innerPolicyElement.AppendChild(responsesAssertion);
                            addressingAssertion.AppendChild(innerPolicyElement);
                        }
                    }
                }
                else if (addressVersion == AddressingVersion.None)
                {
                    // do nothing
                    addressingAssertion = null;
                }
                else
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
                        new InvalidOperationException(SR.GetString(SR.AddressingVersionNotSupported, addressVersion)));
                }

                if (addressingAssertion != null)
                {
                    context.GetBindingAssertions().Add(addressingAssertion);
                }
            }
        }

        class WSPolicyAttachmentHelper
        {
            PolicyVersion policyVersion;
            internal WSPolicyAttachmentHelper(PolicyVersion policyVersion)
            {
                this.policyVersion = policyVersion;
            }

            internal void AttachPolicy(ServiceEndpoint endpoint, WsdlEndpointConversionContext endpointContext, PolicyConversionContext policyContext)
            {
                SortedList<string, string> policyKeys = new SortedList<string, string>();
                NamingHelper.DoesNameExist policyKeyIsUnique
                    = delegate(string name, object nameCollection)
                    {
                        return policyKeys.ContainsKey(name);
                    };

                string key, keyBase;
                ICollection<XmlElement> assertions;

                WsdlNS.ServiceDescription policyWsdl = endpointContext.WsdlBinding.ServiceDescription;

                assertions = policyContext.GetBindingAssertions();

                // Add [wsdl:Binding] level Policy
                WsdlNS.Binding wsdlBinding = endpointContext.WsdlBinding;
                if (assertions.Count > 0)
                {
                    keyBase = CreateBindingPolicyKey(wsdlBinding);
                    key = NamingHelper.GetUniqueName(keyBase, policyKeyIsUnique, null);
                    policyKeys.Add(key, key);
                    AttachItemPolicy(assertions, key, policyWsdl, wsdlBinding);
                }

                foreach (OperationDescription operation in endpoint.Contract.Operations)
                {
                    if (!WsdlExporter.OperationIsExportable(operation))
                    {
                        continue;
                    }

                    assertions = policyContext.GetOperationBindingAssertions(operation);

                    // Add [wsdl:Binding/wsdl:operation] policy
                    if (assertions.Count > 0)
                    {
                        WsdlNS.OperationBinding wsdlOperationBinding = endpointContext.GetOperationBinding(operation);
                        keyBase = CreateOperationBindingPolicyKey(wsdlOperationBinding);
                        key = NamingHelper.GetUniqueName(keyBase, policyKeyIsUnique, null);
                        policyKeys.Add(key, key);
                        AttachItemPolicy(assertions, key, policyWsdl, wsdlOperationBinding);
                    }

                    //
                    // Add [wsdl:Binding/wsdl:operation] child policy
                    //

                    foreach (MessageDescription message in operation.Messages)
                    {
                        assertions = policyContext.GetMessageBindingAssertions(message);

                        // Add [wsdl:Binding/wsdl:operation/wsdl:(input, output, message)] policy
                        if (assertions.Count > 0)
                        {
                            WsdlNS.MessageBinding wsdlMessageBinding = endpointContext.GetMessageBinding(message);
                            keyBase = CreateMessageBindingPolicyKey(wsdlMessageBinding, message.Direction);
                            key = NamingHelper.GetUniqueName(keyBase, policyKeyIsUnique, null);
                            policyKeys.Add(key, key);
                            AttachItemPolicy(assertions, key, policyWsdl, wsdlMessageBinding);
                        }
                    }

                    foreach (FaultDescription fault in operation.Faults)
                    {
                        assertions = policyContext.GetFaultBindingAssertions(fault);

                        // Add [wsdl:Binding/wsdl:operation/wsdl:fault] policy
                        if (assertions.Count > 0)
                        {
                            WsdlNS.FaultBinding wsdlFaultBinding = endpointContext.GetFaultBinding(fault);
                            keyBase = CreateFaultBindingPolicyKey(wsdlFaultBinding);
                            key = NamingHelper.GetUniqueName(keyBase, policyKeyIsUnique, null);
                            policyKeys.Add(key, key);
                            AttachItemPolicy(assertions, key, policyWsdl, wsdlFaultBinding);
                        }
                    }
                }
            }

            void AttachItemPolicy(ICollection<XmlElement> assertions, string key, WsdlNS.ServiceDescription policyWsdl, WsdlNS.DocumentableItem item)
            {
                string policyKey = InsertPolicy(key, policyWsdl, assertions);
                InsertPolicyReference(policyKey, item);
            }

            void InsertPolicyReference(string policyKey, WsdlNS.DocumentableItem item)
            {
                //Create wsp:PolicyReference Element On DocumentableItem
                //---------------------------------------------------------------------------------------------------------
                XmlElement policyReferenceElement = XmlDoc.CreateElement(MetadataStrings.WSPolicy.Prefix,
                                                            MetadataStrings.WSPolicy.Elements.PolicyReference,
                                                            policyVersion.Namespace);

                //Create wsp:PolicyURIs Attribute On DocumentableItem
                //---------------------------------------------------------------------------------------------------------
                XmlAttribute uriAttribute = XmlDoc.CreateAttribute(MetadataStrings.WSPolicy.Attributes.URI);

                uriAttribute.Value = policyKey;
                policyReferenceElement.Attributes.Append(uriAttribute);
                item.Extensions.Add(policyReferenceElement);
            }

            string InsertPolicy(string key, WsdlNS.ServiceDescription policyWsdl, ICollection<XmlElement> assertions)
            {
                // Create [wsp:Policy]
                XmlElement policyElement = CreatePolicyElement(assertions);

                //Create [wsp:Policy/@wsu:Id]
                XmlAttribute idAttribute = XmlDoc.CreateAttribute(MetadataStrings.Wsu.Prefix,
                                                            MetadataStrings.Wsu.Attributes.Id,
                                                            MetadataStrings.Wsu.NamespaceUri);
                idAttribute.Value = key;
                policyElement.SetAttributeNode(idAttribute);

                // Add wsp:Policy To WSDL
                if (policyWsdl != null)
                {
                    policyWsdl.Extensions.Add(policyElement);
                }

                return string.Format(CultureInfo.InvariantCulture, "#{0}", key);
            }

            XmlElement CreatePolicyElement(ICollection<XmlElement> assertions)
            {
                // Create [wsp:Policy]
                XmlElement policyElement = XmlDoc.CreateElement(MetadataStrings.WSPolicy.Prefix,
                                                            MetadataStrings.WSPolicy.Elements.Policy,
                                                            policyVersion.Namespace);

                // Create [wsp:Policy/wsp:ExactlyOne]
                XmlElement exactlyOneElement = XmlDoc.CreateElement(MetadataStrings.WSPolicy.Prefix,
                                                            MetadataStrings.WSPolicy.Elements.ExactlyOne,
                                                            policyVersion.Namespace);
                policyElement.AppendChild(exactlyOneElement);

                // Create [wsp:Policy/wsp:ExactlyOne/wsp:All]
                XmlElement allElement = XmlDoc.CreateElement(MetadataStrings.WSPolicy.Prefix,
                                                            MetadataStrings.WSPolicy.Elements.All,
                                                            policyVersion.Namespace);
                exactlyOneElement.AppendChild(allElement);

                // Add [wsp:Policy/wsp:ExactlyOne/wsp:All/*]
                foreach (XmlElement assertion in assertions)
                {
                    XmlNode iNode = XmlDoc.ImportNode(assertion, true);
                    allElement.AppendChild(iNode);
                }

                return policyElement;
            }

            static string CreateBindingPolicyKey(WsdlNS.Binding wsdlBinding)
            {
                return string.Format(CultureInfo.InvariantCulture, "{0}_policy", wsdlBinding.Name);
            }

            static string CreateOperationBindingPolicyKey(WsdlNS.OperationBinding wsdlOperationBinding)
            {
                return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_policy",
                    wsdlOperationBinding.Binding.Name,
                    wsdlOperationBinding.Name);
            }

            static string CreateMessageBindingPolicyKey(WsdlNS.MessageBinding wsdlMessageBinding, MessageDirection direction)
            {
                WsdlNS.OperationBinding wsdlOperationBinding = wsdlMessageBinding.OperationBinding;
                WsdlNS.Binding wsdlBinding = wsdlOperationBinding.Binding;

                if (direction == MessageDirection.Input)
                    return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_Input_policy", wsdlBinding.Name, wsdlOperationBinding.Name);
                else
                    return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_output_policy", wsdlBinding.Name, wsdlOperationBinding.Name);
            }

            static string CreateFaultBindingPolicyKey(WsdlNS.FaultBinding wsdlFaultBinding)
            {
                WsdlNS.OperationBinding wsdlOperationBinding = wsdlFaultBinding.OperationBinding;
                WsdlNS.Binding wsdlBinding = wsdlOperationBinding.Binding;
                if (string.IsNullOrEmpty(wsdlFaultBinding.Name))
                {
                    return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_Fault", wsdlBinding.Name, wsdlOperationBinding.Name);
                }
                else
                {
                    return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_{2}_Fault", wsdlBinding.Name, wsdlOperationBinding.Name, wsdlFaultBinding.Name);
                }
            }

        }

        class WsdlNamespaceHelper
        {
            XmlSerializerNamespaces xmlSerializerNamespaces;
            PolicyVersion policyVersion;
            internal XmlSerializerNamespaces SerializerNamespaces
            {
                get
                {
                    if (xmlSerializerNamespaces == null)
                    {
                        XmlSerializerNamespaceWrapper namespaces = new XmlSerializerNamespaceWrapper();
                        namespaces.Add("wsdl", WsdlNS.ServiceDescription.Namespace);
                        namespaces.Add("xsd", XmlSchema.Namespace);
                        namespaces.Add(MetadataStrings.WSPolicy.Prefix, policyVersion.Namespace);
                        namespaces.Add(MetadataStrings.Wsu.Prefix, MetadataStrings.Wsu.NamespaceUri);
                        namespaces.Add(MetadataStrings.Addressing200408.Prefix, MetadataStrings.Addressing200408.NamespaceUri);
                        namespaces.Add(MetadataStrings.Addressing200408.Policy.Prefix, MetadataStrings.Addressing200408.Policy.NamespaceUri);
                        namespaces.Add(MetadataStrings.Addressing10.Prefix, MetadataStrings.Addressing10.NamespaceUri);
                        namespaces.Add(MetadataStrings.Addressing10.WsdlBindingPolicy.Prefix, MetadataStrings.Addressing10.WsdlBindingPolicy.NamespaceUri);
                        namespaces.Add(MetadataStrings.Addressing10.MetadataPolicy.Prefix, MetadataStrings.Addressing10.MetadataPolicy.NamespaceUri);
                        namespaces.Add(MetadataStrings.MetadataExchangeStrings.Prefix, MetadataStrings.MetadataExchangeStrings.Namespace);
                        namespaces.Add(NetSessionHelper.Prefix, NetSessionHelper.NamespaceUri);

                        namespaces.Add("soapenc", "http://schemas.xmlsoap.org/soap/encoding/");
                        namespaces.Add("soap12", "http://schemas.xmlsoap.org/wsdl/soap12/");
                        namespaces.Add("soap", "http://schemas.xmlsoap.org/wsdl/soap/");

                        xmlSerializerNamespaces = namespaces.GetNamespaces();
                    }
                    return xmlSerializerNamespaces;
                }
            }

            internal WsdlNamespaceHelper(PolicyVersion policyVersion)
            {
                this.policyVersion = policyVersion;
            }

            // doesn't care if you add a duplicate prefix
            class XmlSerializerNamespaceWrapper
            {
                readonly XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
                readonly Dictionary<string, string> lookup = new Dictionary<string, string>();

                internal void Add(string prefix, string namespaceUri)
                {
                    if (!lookup.ContainsKey(prefix))
                    {
                        namespaces.Add(prefix, namespaceUri);
                        lookup.Add(prefix, namespaceUri);
                    }
                }

                internal XmlSerializerNamespaces GetNamespaces()
                {
                    return namespaces;
                }
            }

            internal static string FindOrCreatePrefix(string prefixBase, string ns, params WsdlNS.DocumentableItem[] scopes)
            {
                if (!(scopes.Length > 0))
                {
                    Fx.Assert("You must pass at least one namespaceScope");
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "You must pass at least one namespaceScope")));
                }
                string prefix = null;

                if (string.IsNullOrEmpty(ns))
                {
                    prefix = string.Empty;
                }
                else
                {
                    //See if a prefix for the namespace has already been defined at one of the scopes
                    for (int j = 0; j < scopes.Length; j++)
                        if (TryMatchNamespace(scopes[j].Namespaces.ToArray(), ns, out prefix))
                            return prefix;

                    // Create prefix definition at the nearest scope.
                    int i = 0;
                    prefix = prefixBase + i.ToString(CultureInfo.InvariantCulture);

                    //Microsoft, consider do we need to check at higher scopes as well?
                    while (PrefixExists(scopes[0].Namespaces.ToArray(), prefix))
                        prefix = prefixBase + (++i).ToString(CultureInfo.InvariantCulture);
                }
                scopes[0].Namespaces.Add(prefix, ns);

                return prefix;
            }

            static bool PrefixExists(XmlQualifiedName[] prefixDefinitions, string prefix)
            {
                return Array.Exists<XmlQualifiedName>(prefixDefinitions,
                    delegate(XmlQualifiedName prefixDef)
                    {
                        if (prefixDef.Name == prefix)
                        {
                            return true;
                        }
                        return false;
                    });

            }

            static bool TryMatchNamespace(XmlQualifiedName[] prefixDefinitions, string ns, out string prefix)
            {
                string foundPrefix = null;
                Array.Find<XmlQualifiedName>(prefixDefinitions,
                    delegate(XmlQualifiedName prefixDef)
                    {
                        if (prefixDef.Namespace == ns)
                        {
                            foundPrefix = prefixDef.Name;
                            return true;
                        }
                        return false;
                    });

                prefix = foundPrefix;
                return foundPrefix != null;
            }
        }

        internal static class WsdlNamingHelper
        {
            internal static XmlQualifiedName GetPortTypeQName(ContractDescription contract)
            {
                return new XmlQualifiedName(contract.Name, contract.Namespace);
            }

            internal static XmlQualifiedName GetBindingQName(ServiceEndpoint endpoint, WsdlExporter exporter, out bool wasUniquified)
            {
                // due to problems in Sysytem.Web.Services.Descriprion.ServiceDescription.Write() (double encoding) method we cannot use encoded names for
                // wsdl:binding item: we need to make sure that XmlConvert.EncodeLocalName will not find any problems with the name, and leave it unchanged.
                // consider changing the name here to something that will not be encoded by XmlSerializer (GenerateSimpleXmlName()?)
                string localName = endpoint.Name;

                string bindingWsdlNamespace = endpoint.Binding.Namespace;
                string uniquifiedLocalName = NamingHelper.GetUniqueName(localName, WsdlBindingQNameExists(exporter, bindingWsdlNamespace), null);
                wasUniquified = localName != uniquifiedLocalName;

                return new XmlQualifiedName(uniquifiedLocalName, bindingWsdlNamespace);
            }

            static NamingHelper.DoesNameExist WsdlBindingQNameExists(WsdlExporter exporter, string bindingWsdlNamespace)
            {
                return delegate(string localName, object nameCollection)
                {
                    XmlQualifiedName wsdlBindingQName = new XmlQualifiedName(localName, bindingWsdlNamespace);
                    WsdlNS.ServiceDescription wsdl = exporter.wsdlDocuments[bindingWsdlNamespace];
                    if (wsdl != null && wsdl.Bindings[localName] != null)
                        return true;

                    return false;
                };
            }



            internal static string GetPortName(ServiceEndpoint endpoint, WsdlNS.Service wsdlService)
            {
                return NamingHelper.GetUniqueName(endpoint.Name, ServiceContainsPort(wsdlService), null);
            }

            static NamingHelper.DoesNameExist ServiceContainsPort(WsdlNS.Service service)
            {
                return delegate(string portName, object nameCollection)
                {
                    foreach (WsdlNS.Port port in service.Ports)
                        if (port.Name == portName)
                            return true;
                    return false;
                };
            }

            internal static string GetWsdlOperationName(OperationDescription operationDescription, ContractDescription parentContractDescription)
            {
                return operationDescription.Name;
            }
        }

        internal static class NetSessionHelper
        {
            internal const string NamespaceUri = "http://schemas.microsoft.com/ws/2005/12/wsdl/contract";
            internal const string Prefix = "msc";
            internal const string UsingSession = "usingSession";
            internal const string IsInitiating = "isInitiating";
            internal const string IsTerminating = "isTerminating";
            internal const string True = "true";
            internal const string False = "false";

            internal static void AddUsingSessionAttributeIfNeeded(WsdlNS.PortType wsdlPortType, ContractDescription contract)
            {
                bool sessionValue;

                if (contract.SessionMode == SessionMode.Required)
                {
                    sessionValue = true;
                }
                else if (contract.SessionMode == SessionMode.NotAllowed)
                {
                    sessionValue = false;
                }
                else
                {
                    return;
                }

                wsdlPortType.ExtensibleAttributes = CloneAndAddToAttributes(wsdlPortType.ExtensibleAttributes, NetSessionHelper.Prefix,
                    NetSessionHelper.UsingSession, NetSessionHelper.NamespaceUri, ToValue(sessionValue));
            }

            internal static void AddInitiatingTerminatingAttributesIfNeeded(WsdlNS.Operation wsdlOperation,
                OperationDescription operation, ContractDescription contract)
            {
                if (contract.SessionMode == SessionMode.Required)
                {
                    AddInitiatingAttribute(wsdlOperation, operation.IsInitiating);
                    AddTerminatingAttribute(wsdlOperation, operation.IsTerminating);
                }
            }

            static void AddInitiatingAttribute(System.Web.Services.Description.Operation wsdlOperation, bool isInitiating)
            {
                wsdlOperation.ExtensibleAttributes = CloneAndAddToAttributes(wsdlOperation.ExtensibleAttributes, NetSessionHelper.Prefix,
                    NetSessionHelper.IsInitiating, NetSessionHelper.NamespaceUri, ToValue(isInitiating));
            }

            static void AddTerminatingAttribute(System.Web.Services.Description.Operation wsdlOperation, bool isTerminating)
            {
                wsdlOperation.ExtensibleAttributes = CloneAndAddToAttributes(wsdlOperation.ExtensibleAttributes, NetSessionHelper.Prefix,
                    NetSessionHelper.IsTerminating, NetSessionHelper.NamespaceUri, ToValue(isTerminating));
            }

            static XmlAttribute[] CloneAndAddToAttributes(XmlAttribute[] originalAttributes, string prefix, string localName, string ns, string value)
            {
                XmlAttribute newAttribute = XmlDoc.CreateAttribute(prefix, localName, ns);
                newAttribute.Value = value;

                int originalAttributeCount = 0;
                if (originalAttributes != null)
                    originalAttributeCount = originalAttributes.Length;

                XmlAttribute[] attributes = new XmlAttribute[originalAttributeCount + 1];

                if (originalAttributes != null)
                    originalAttributes.CopyTo(attributes, 0);

                attributes[attributes.Length - 1] = newAttribute;

                return attributes;
            }

            static string ToValue(bool b)
            {
                return b ? NetSessionHelper.True : NetSessionHelper.False;
            }
        }

        void CallExtension(WsdlContractConversionContext contractContext, IWsdlExportExtension extension)
        {
            try
            {
                extension.ExportContract(this, contractContext);
            }
#pragma warning suppress 56500 // covered by FxCOP
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                    throw;
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ThrowExtensionException(contractContext.Contract, extension, e));
            }
        }

        void CallExtension(WsdlEndpointConversionContext endpointContext, IWsdlExportExtension extension)
        {
            try
            {
                extension.ExportEndpoint(this, endpointContext);
            }
#pragma warning suppress 56500 // covered by FxCOP
            catch (Exception e)
            {
                if (Fx.IsFatal(e))
                    throw;
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(ThrowExtensionException(endpointContext.Endpoint, extension, e));
            }
        }

        Exception ThrowExtensionException(ContractDescription contract, IWsdlExportExtension exporter, Exception e)
        {
            string contractIdentifier = new XmlQualifiedName(contract.Name, contract.Namespace).ToString();
            string errorMessage = SR.GetString(SR.WsdlExtensionContractExportError, exporter.GetType(), contractIdentifier);

            return new InvalidOperationException(errorMessage, e);
        }

        Exception ThrowExtensionException(ServiceEndpoint endpoint, IWsdlExportExtension exporter, Exception e)
        {
            string endpointIdentifier;
            if (endpoint.Address != null && endpoint.Address.Uri != null)
                endpointIdentifier = endpoint.Address.Uri.ToString();
            else
                endpointIdentifier = String.Format(CultureInfo.InvariantCulture,
                    "Contract={1}:{0} ,Binding={3}:{2}",
                    endpoint.Contract.Name,
                    endpoint.Contract.Namespace,
                    endpoint.Binding.Name,
                    endpoint.Binding.Namespace);

            string errorMessage = SR.GetString(SR.WsdlExtensionEndpointExportError, exporter.GetType(), endpointIdentifier);

            return new InvalidOperationException(errorMessage, e);
        }

        sealed class BindingDictionaryKey
        {
            public readonly ContractDescription Contract;
            public readonly Binding Binding;

            public BindingDictionaryKey(ContractDescription contract, Binding binding)
            {
                this.Contract = contract;
                this.Binding = binding;
            }

            public override bool Equals(object obj)
            {
                BindingDictionaryKey key = obj as BindingDictionaryKey;
                if (key != null && key.Binding == this.Binding && key.Contract == this.Contract)
                    return true;
                return false;
            }

            public override int GetHashCode()
            {
                return this.Contract.GetHashCode() ^ this.Binding.GetHashCode();
            }
        }

        sealed class EndpointDictionaryKey
        {
            public readonly ServiceEndpoint Endpoint;
            public readonly XmlQualifiedName ServiceQName;

            public EndpointDictionaryKey(ServiceEndpoint endpoint, XmlQualifiedName serviceQName)
            {
                this.Endpoint = endpoint;
                this.ServiceQName = serviceQName;
            }

            public override bool Equals(object obj)
            {
                EndpointDictionaryKey key = obj as EndpointDictionaryKey;
                if (key != null && key.Endpoint == this.Endpoint && key.ServiceQName == this.ServiceQName)
                    return true;
                return false;
            }

            public override int GetHashCode()
            {
                return this.Endpoint.GetHashCode() ^ this.ServiceQName.GetHashCode();
            }
        }
    }
}