internal WsdlEndpointConversionContext (WsdlContractConversionContext context, ServiceEndpoint endpoint, Port port, WSBinding wsdlBinding)
		{
			this.context = context;
			this.endpoint = endpoint;
			this.port = port;
			this.wsdl_binding = wsdlBinding;
		}

        static Type GetServiceType(Binding soapBinding, Assembly assembly)
        {
            foreach (var type in assembly.GetTypes())
            {
                var bindingAttribute = type.GetCustomAttributes(typeof (WebServiceBindingAttribute), false)
                    .Cast<WebServiceBindingAttribute>().SingleOrDefault();
                if (bindingAttribute != null && bindingAttribute.Name == soapBinding.Name)
                    return type;
            }

            return null;

            //var serviceTypes = new List<Type>();

            //// FIXME: Best way to match the service/binding to the implementing type
            ////

            //foreach (var type in assembly.GetTypes())
            //{
            //    var bindingAttributes = type.GetCustomAttributes(typeof (WebServiceBindingAttribute), false);
            //    if (bindingAttributes.Length != 0) serviceTypes.Add(type);
            //}

            //var name = soapBinding.Type.Name;
            //return string.IsNullOrEmpty(name)
            //    ? new Type[0]
            //    : serviceTypes.Where(t => t.Name == name || t.Name.EndsWith(name));
        }

		public CustomPolicyConversionContext (WS.Binding binding, ServiceEndpoint endpoint)
			: base (endpoint)
		{
			this.binding = binding;
			assertions = new PolicyAssertionCollection ();
			binding_elements = ((CustomBinding)endpoint.Binding).Elements;
		}

        //DONE
        //This method generates a list of operations from a web service description. Returns a list of the
        //webservice's operations on success, and null on failure.
        public string[] GetListOfOperations(string webServiceURL)
        {
            List<string> ListOfOperations = new List<string>();
            WebClient webServiceClient = new WebClient();
            Binding binding = new Binding();

            try
            {
                Stream serviceStream = webServiceClient.OpenRead(webServiceURL + "?wsdl");
                //This gets the WSDL file...
                ServiceDescription webServiceDescription = ServiceDescription.Read(serviceStream);

                //Get a list of operations from the web service description...
                binding = webServiceDescription.Bindings[0];
                OperationBindingCollection operationCollection = binding.Operations;

                foreach (OperationBinding operation in operationCollection)
                {
                    ListOfOperations.Add(operation.Name);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }

            return ListOfOperations.ToArray();
        }

        static List<ExplorerItem> BuildEntities(Type serviceType, Binding soapBinding)
        {
            var list = new List<ExplorerItem>();
            foreach (var operation in GetSoapOperations(soapBinding))
                list.Add(CreateExplorerOperation(serviceType, operation));

            return list;
        }

		public void TestAddBinding ()
		{
			const string bindingName = "testBinding";
			
			Binding b = new Binding ();
			b.Name = bindingName;
			
			bc.Add (b);

			Assert.AreEqual (1, bc.Count);
			Assert.AreEqual (b, bc[bindingName]);
		}

        OperationBinding FindOperation(Binding binding, string name)
        {
            foreach (OperationBinding oper in binding.Operations) {
                if (oper.Input.Name != null) {
                    if (oper.Input.Name == name) return oper;
                }
                else
                    if (oper.Name == name) return oper;
            }

            return null;
        }

        private static Type GetServiceType(Binding soapBinding, Assembly assembly)
        {
            foreach (var type in assembly.GetTypes())
            {
                var bindingAttribute = type.GetCustomAttributes(typeof (WebServiceBindingAttribute), false)
                    .Cast<WebServiceBindingAttribute>().SingleOrDefault();
                if (bindingAttribute != null && bindingAttribute.Name == soapBinding.Name)
                    return type;
            }

            return null;
        }

 internal WsdlEndpointConversionContext(WsdlContractConversionContext contractContext, ServiceEndpoint endpoint, Binding wsdlBinding, Port wsdlport)
 {
     this.endpoint = endpoint;
     this.wsdlBinding = wsdlBinding;
     this.wsdlPort = wsdlport;
     this.contractContext = contractContext;
     this.wsdlOperationBindings = new Dictionary<OperationDescription, OperationBinding>();
     this.operationDescriptionBindings = new Dictionary<OperationBinding, OperationDescription>();
     this.wsdlMessageBindings = new Dictionary<MessageDescription, MessageBinding>();
     this.messageDescriptionBindings = new Dictionary<MessageBinding, MessageDescription>();
     this.wsdlFaultBindings = new Dictionary<FaultDescription, FaultBinding>();
     this.faultDescriptionBindings = new Dictionary<FaultBinding, FaultDescription>();
 }

		internal static void Check (ConformanceCheckContext ctx, ConformanceChecker checker, Binding b)
		{
			checker.Check (ctx, b);
			CheckExtensions (ctx, checker, b.Extensions);

			foreach (OperationBinding oper in b.Operations) {
				CheckExtensions (ctx, checker, oper.Extensions);

				foreach (MessageBinding mb in oper.Faults) {
					checker.Check (ctx, mb);
					CheckExtensions (ctx, checker, mb.Extensions);
				}

				checker.Check (ctx, oper.Input);
				CheckExtensions (ctx, checker, oper.Input.Extensions);

				checker.Check (ctx, oper.Output);
				CheckExtensions (ctx, checker, oper.Output.Extensions);
			}
		}

 /// <include file='doc\ServiceDescription.uex' path='docs/doc[@for="BindingCollection.Remove"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public void Remove(Binding binding) {
     List.Remove(binding);
 }

 /// <include file='doc\ServiceDescription.uex' path='docs/doc[@for="BindingCollection.Contains"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public bool Contains(Binding binding) {
     return List.Contains(binding);
 }

 /// <include file='doc\ServiceDescription.uex' path='docs/doc[@for="BindingCollection.IndexOf"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public int IndexOf(Binding binding) {
     return List.IndexOf(binding);
 }

 /// <include file='doc\ServiceDescription.uex' path='docs/doc[@for="BindingCollection.Insert"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public void Insert(int index, Binding binding) {
     List.Insert(index, binding);
 }

 void MoveToBinding(Service service, Port port, Binding binding, PortType portType) {
     this.service = service;
     this.port = port;
     this.portType = portType;
     this.binding = binding;
     this.encodedBinding = false;
 }

		Port ExportService (WSServiceDescription sd, WSBinding ws_binding, EndpointAddress address, bool msg_version_none)
		{
			if (address == null)
				return null;

			Service ws_svc = GetService (sd, "service");
			sd.Name = "service";

				Port ws_port = new Port ();
				ws_port.Name = ws_binding.Name;
				ws_port.Binding = new QName (ws_binding.Name, sd.TargetNamespace);

				if (!msg_version_none) {
					SoapAddressBinding soap_addr = new SoapAddressBinding ();
					soap_addr.Location = address.Uri.AbsoluteUri;

					ws_port.Extensions.Add (soap_addr);
				}

			ws_svc.Ports.Add (ws_port);

			return ws_port;
		}

 internal void SetParent(Binding parent) {
     this.parent = parent;
 }

		EndpointExportMap ExportEndpoint_Internal (ServiceEndpoint endpoint)
		{
			var map = ExportedEndpoints.FirstOrDefault (m => m.Endpoint == endpoint);
			if (map != null)
				return map;

			int index = 0;
			var baseName = String.Concat (endpoint.Binding.Name, "_", endpoint.Contract.Name);
			var name = baseName;
			while (ExportedEndpoints.Exists (m => m.Name == name))
				name = String.Concat (baseName, (++index).ToString ());

			map = new EndpointExportMap (name, endpoint);
			ExportedEndpoints.Add (map);

			var contract = ExportContractInternal (endpoint.Contract);

			//FIXME: Namespace
			WSServiceDescription sd = GetServiceDescription ("http://tempuri.org/");
			if (sd.TargetNamespace != endpoint.Contract.Namespace) {
				sd.Namespaces.Add ("i0", endpoint.Contract.Namespace);

				//Import
				Import import = new Import ();
				import.Namespace = endpoint.Contract.Namespace;

				sd.Imports.Add (import);
			}
			
			if (endpoint.Binding == null)
				throw new ArgumentException (String.Format (
					"Binding for ServiceEndpoint named '{0}' is null",
					endpoint.Name));

			var extensions = new List<IWsdlExportExtension> ();
			var extensionTypes = new Dictionary<Type, IWsdlExportExtension> ();
			if (contract.Results != null) {
				foreach (var extension in contract.Results) {
					var type = extension.GetType ();
					if (extensionTypes.ContainsKey (type))
						continue;
					extensionTypes.Add (type, extension);
					extensions.Add (extension);
				}
			}

			var bindingElements = endpoint.Binding.CreateBindingElements ();
			foreach (var element in bindingElements) {
				var extension = element as IWsdlExportExtension;
				if (extension == null)
					continue;
				var type = extension.GetType ();
				if (extensionTypes.ContainsKey (type))
					continue;
				extensionTypes.Add (type, extension);
				extensions.Add (extension);
			}

			//ExportBinding
			WSBinding ws_binding = new WSBinding ();
			
			//<binding name = .. 
			ws_binding.Name = name;

			//<binding type = ..
			ws_binding.Type = new QName (endpoint.Contract.Name, endpoint.Contract.Namespace);
			sd.Bindings.Add (ws_binding);

			//	<operation
			foreach (OperationDescription sm_op in endpoint.Contract.Operations) {
				var op_binding = CreateOperationBinding (endpoint, sm_op);
				ws_binding.Operations.Add (op_binding);
			}

			//Add <service
			Port ws_port = ExportService (sd, ws_binding, endpoint.Address);

			//Call IWsdlExportExtension.ExportEndpoint
			WsdlContractConversionContext contract_context = new WsdlContractConversionContext (
				endpoint.Contract, sd.PortTypes [endpoint.Contract.Name]);
			WsdlEndpointConversionContext endpoint_context = new WsdlEndpointConversionContext (
				contract_context, endpoint, ws_port, ws_binding);

			foreach (var extension in extensions) {
				try {
					extension.ExportEndpoint (this, endpoint_context);
				} catch (Exception ex) {
					var error = AddError (
						"Failed to export endpoint '{0}': wsdl exporter '{1}' " +
						"threw an exception: {2}", endpoint.Name, extension.GetType (), ex);
					throw new MetadataExportException (error, ex);
				}
			}

			try {
				ExportPolicy (endpoint, ws_binding);
			} catch (MetadataExportException) {
				throw;
			} catch (Exception ex) {
				var error = AddError (
//.........这里部分代码省略.........

		internal void SetParent (Binding binding) 
		{
			this.binding = binding; 
		} 

		OperationBinding GetOperationBinding (WSBinding b, string name, string label)
		{
			foreach (OperationBinding op in b.Operations)
				if (op.Name == name)
					return op;

			Assert.Fail (String.Format ("[{0}] OperationBinding named '{1}' not found.", label, name));
			return null;
		}