/// <summary>
        /// Retrieves and imports meta data for a given WSDL document specified by 
        /// WsdlDocument property.
        /// </summary>
		/// <param name="options">The metadata resolving options.</param>
		/// <returns>A collection of service metadata in XML form.</returns>
        public static MetadataSet GetMetadataSet(MetadataResolverOptions options)
        {
            if (options == null)
            {
                throw new ArgumentException("options could not be null.");
            }

            if (string.IsNullOrEmpty(options.MetadataLocation))
            {
                throw new ArgumentException("MetadataLocation option could not be null or an empty string.");
            }

            try
            {
                // First download the contracts if they are accessed over the web.
                DownloadContract(options);

                // Try to run RPC2DocumentLiteral converter.
                TryTranslateRpc2DocumentLiteral(options);
                MetadataSet metadataSet = new MetadataSet();
                XmlDocument doc = new XmlDocument();
                doc.Load(options.MetadataLocation);
                MetadataSection ms = new MetadataSection(null, null, doc);
                metadataSet.MetadataSections.Add(ms);
                ResolveImports(options, metadataSet);

                return metadataSet;
            }
            catch (Exception ex)
            {
                // TODO: Log exception.
                throw new MetadataResolveException("Could not resolve metadata", ex);
            }
        }

		void NoExtensionsSetup ()
		{
			XmlReaderSettings xs = new XmlReaderSettings ();
			xs.IgnoreWhitespace = true;
			xtr = XmlTextReader.Create ("Test/System.ServiceModel.Description/dump.xml", xs);

			xtr.Read ();

			//FIXME: skipping Headers
			while (xtr.LocalName != "Body") {
				if (!xtr.Read ())
					return;
			}

			//Move to <Metadata ..
			xtr.Read ();
			ms = MetadataSet.ReadFrom (xtr);

			//MyWsdlImportExtension mw = new MyWsdlImportExtension ();
			List<IWsdlImportExtension> list = new List<IWsdlImportExtension> ();
			//list.Add (mw);
			list.Add (new DataContractSerializerMessageContractImporter ());

			/*list.Add (new MessageEncodingBindingElementImporter ());
			list.Add (new TransportBindingElementImporter ());
			list.Add (new StandardBindingImporter ());*/

			wi = new WsdlImporter (ms, null, list);
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="CodeGeneratorContext"/> class.
		/// </summary>
		/// <param name="metadataSet">The metadata set.</param>
		/// <param name="codeGeneratorOptions">The code generator options.</param>
		public CodeGeneratorContext(MetadataSet metadataSet, CodeGeneratorOptions codeGeneratorOptions)
		{
			MetadataSet = metadataSet;
			CodeDomProvider = CodeDomProvider.CreateProvider(codeGeneratorOptions.CodeLanguage.ToString());
			CodeCompileUnit = new CodeCompileUnit();
			CodeGeneratorOptions = codeGeneratorOptions;
		}

        private static void CreateHttpGetChannelDispatcher(ServiceHostBase host, Uri listenUri, MetadataSet metadata)
        {
            //创建Binding
            TextMessageEncodingBindingElement messageEncodingElement = new TextMessageEncodingBindingElement() { MessageVersion = MessageVersion.None };
            HttpTransportBindingElement transportElement = new HttpTransportBindingElement();
            Utility.SetPropertyValue(transportElement, "Method", "GET");
            Binding binding = new CustomBinding(messageEncodingElement, transportElement);

            //创建ChannelListener
            IChannelListener listener = binding.BuildChannelListener<IReplyChannel>(listenUri, string.Empty, ListenUriMode.Explicit, new BindingParameterCollection());
            ChannelDispatcher dispatcher = new ChannelDispatcher(listener, "ServiceMetadataBehaviorHttpGetBinding", binding) { MessageVersion = binding.MessageVersion };

            //创建EndpointDispatcher
            EndpointDispatcher endpoint = new EndpointDispatcher(new EndpointAddress(listenUri), "IHttpGetMetadata", "http://www.artech.com/");

            //创建DispatchOperation，并设置DispatchMessageFormatter和OperationInvoker
            DispatchOperation operation = new DispatchOperation(endpoint.DispatchRuntime, "Get", "*", "*");
            operation.Formatter = Utility.CreateInstance<IDispatchMessageFormatter>(MessageOperationFormatterType, Type.EmptyTypes, new object[0]);
            MethodInfo method = typeof(IHttpGetMetadata).GetMethod("Get");
            operation.Invoker = Utility.CreateInstance<IOperationInvoker>(SyncMethodInvokerType, new Type[] { typeof(MethodInfo) }, new object[] { method });
            endpoint.DispatchRuntime.Operations.Add(operation);

            //设置SingletonInstanceContext和InstanceContextProvider
            MetadataProvisionService serviceInstance = new MetadataProvisionService(metadata);
            endpoint.DispatchRuntime.SingletonInstanceContext = new InstanceContext(host, serviceInstance);
            endpoint.DispatchRuntime.InstanceContextProvider = Utility.CreateInstance<IInstanceContextProvider>(SingletonInstanceContextProviderType, new Type[] { typeof(DispatchRuntime) }, new object[] { endpoint.DispatchRuntime });
            dispatcher.Endpoints.Add(endpoint);

            //设置ContractFilter和AddressFilter
            endpoint.ContractFilter = new MatchAllMessageFilter();
            endpoint.AddressFilter = new MatchAllMessageFilter();

            host.ChannelDispatchers.Add(dispatcher);
        }

 private void AddDocumentToSet(MetadataSet metadataSet, object document)
 {
     System.Web.Services.Description.ServiceDescription serviceDescription = document as System.Web.Services.Description.ServiceDescription;
     System.Xml.Schema.XmlSchema schema = document as System.Xml.Schema.XmlSchema;
     XmlElement policy = document as XmlElement;
     if (serviceDescription != null)
     {
         metadataSet.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(serviceDescription));
     }
     else if (schema != null)
     {
         metadataSet.MetadataSections.Add(MetadataSection.CreateFromSchema(schema));
     }
     else if ((policy != null) && MetadataSection.IsPolicyElement(policy))
     {
         metadataSet.MetadataSections.Add(MetadataSection.CreateFromPolicy(policy, null));
     }
     else
     {
         MetadataSection item = new MetadataSection {
             Metadata = document
         };
         metadataSet.MetadataSections.Add(item);
     }
 }

		public WebServiceDiscoveryResultWCF (DiscoveryClientProtocol protocol, MetadataSet metadata, WebReferenceItem item, ReferenceGroup refGroup, ClientOptions defaultOptions): base (WebReferencesService.WcfEngine, item)
		{
			this.refGroup = refGroup;
			this.protocol = protocol;
			this.metadata = metadata;
			this.defaultOptions = defaultOptions;
		}

 private static void WriterMetadata(MetadataSet metadata)
 {
     using (XmlWriter writer = new XmlTextWriter("metadata.xml", Encoding.UTF8))
     {
         metadata.WriteTo(writer);
     }
     Process.Start("metadata.xml");
 }

		static TestMetadata()
		{
			DataContractSerializer serializer = new DataContractSerializer(typeof(MetadataSet));
			using (MemoryStream stream = new MemoryStream(Encoding.Default.GetBytes(Resources.RestaurantMetadata)))
			{
				metadataSet = (MetadataSet)serializer.ReadObject(stream);
			}
		}

		void GetServices(MetadataSet metadata)
		{
			foreach (MetadataSection section in metadata.MetadataSections) {
				var service = section.Metadata as WebServices.ServiceDescription;
				if (service != null) {
					Services.Add(service);
				}
			}
		}

		public static MetadataSet GetMetadataSet (Stream stream)
		{
			var dr = new ContractReference ();
			var doc = (WebServices.Description.ServiceDescription) dr.ReadDocument (stream);
			
			var metadata = new MetadataSet ();
			metadata.MetadataSections.Add (
				new MetadataSection (MetadataSection.ServiceDescriptionDialect, "", doc));
			return metadata;
		}

        public ClientServiceGenerator(MetadataSet metadataSet, PrimaryCodeGenerationOptions options, CodeDomProvider codeProvider)
        {
        	Enforce.IsNotNull(metadataSet, "metadataSet");
			this.options = Enforce.IsNotNull(options, "options");
			this.codeProvider = Enforce.IsNotNull(codeProvider, "codeProvider");

            compileUnit = new CodeCompileUnit();
            wsdlImporter = new WsdlImporter(metadataSet);

			InitializeConfiguration();
        }

        public ServiceDescription GetFlattenedServiceDescription(MetadataSet metadataSet)
        {
            var obj = Assembly.GetAssembly(typeof(WsdlExporter)).GetType("System.ServiceModel.Description.WsdlHelper", true)
                .GetMethod("GetSingleWsdl", BindingFlags.Static | BindingFlags.Public)
                .Invoke(null, new object[1] { metadataSet });

            if (obj is ServiceDescription)
                return (ServiceDescription)obj;

            return null;
        }

		void CreateGenerator()
		{
			metadata = new MetadataSet();
			
			fakeProject = MockRepository.GenerateStub<IProjectWithServiceReferences>();
			fakeProxyGenerator = MockRepository.GenerateStub<IServiceReferenceProxyGenerator>();
			fakeReferenceMapGenerator = MockRepository.GenerateStub<IServiceReferenceMapGenerator>();
			fileGenerator = new ServiceReferenceFileGenerator(fakeProxyGenerator, fakeReferenceMapGenerator);
			fakeFileSystem = MockRepository.GenerateStub<IFileSystem>();
			
			generator = new ServiceReferenceGenerator(fakeProject, fileGenerator, fakeFileSystem);
		}

 public WsdlImporter CreateDataContractSerializerImporter(MetadataSet metaData)
 {
     Collection<IWsdlImportExtension> wsdlImportExtensions = ClientSection.GetSection().Metadata.LoadWsdlImportExtensions();
     for (int i = 0; i < wsdlImportExtensions.Count; i++)
     {
         if (wsdlImportExtensions[i].GetType() == typeof(XmlSerializerMessageContractImporter))
         {
             wsdlImportExtensions.RemoveAt(i);
         }
     }
     return new WsdlImporter(metaData, null, wsdlImportExtensions);
 }

 private static void GetMetadataViaHttpGet()
 {
     MetadataSet metadata = new MetadataSet();
     HttpWebRequest request = (HttpWebRequest)WebRequest.Create("http://127.0.0.1:3721/calculatorservice/metadata");
     request.Method = "Get";
     HttpWebResponse response = (HttpWebResponse)request.GetResponse();
     using (XmlReader reader = XmlDictionaryReader.CreateTextReader(response.GetResponseStream(), new XmlDictionaryReaderQuotas()))
     {
         System.Web.Services.Description.ServiceDescription serviceDesc = System.Web.Services.Description.ServiceDescription.Read(reader);
         metadata.MetadataSections.Add(MetadataSection.CreateFromServiceDescription(serviceDesc));
     }
     WriterMetadata(metadata);
 }

        public static void GenerateConfig(MetadataSet metadata, Configuration config)
        {
            WsdlImporter importer = new WsdlImporter (metadata);

            var endpoints = importer.ImportAllEndpoints ();

            var generator = new ServiceContractGenerator (config);
            generator.Options = ServiceContractGenerationOptions.None;

            foreach (var endpoint in endpoints) {
                ChannelEndpointElement channelElement;
                generator.GenerateServiceEndpoint (endpoint, out channelElement);
            }
        }

		void GenerateServiceReferenceProxy(MetadataSet metadata)
		{
			ServiceReferenceFileName referenceFileName = project.GetServiceReferenceFileName(Namespace);
			CreateFolderForFileIfFolderMissing(referenceFileName.Path);
			
			fileGenerator.ServiceReferenceNamespace = Namespace;
			fileGenerator.GenerateProxyFile(metadata, referenceFileName.Path);
			
			ServiceReferenceMapFileName mapFileName = project.GetServiceReferenceMapFileName(Namespace);
			var mapFile = new ServiceReferenceMapFile(mapFileName);
			fileGenerator.GenerateServiceReferenceMapFile(mapFile);
			
			project.AddServiceReferenceProxyFile(referenceFileName);
			project.AddServiceReferenceMapFile(mapFileName);
		}

 private static void CustomizeMexEndpoints(ServiceDescription description, ServiceHostBase host, MetadataSet metadata)
 {
     foreach (ChannelDispatcher channelDispatcher in host.ChannelDispatchers)
     {
         foreach (EndpointDispatcher endpoint in channelDispatcher.Endpoints)
         {
             if (endpoint.ContractName == MexContractName && endpoint.ContractNamespace == MexContractNamespace)
             {
                 DispatchRuntime dispatchRuntime = endpoint.DispatchRuntime;
                 dispatchRuntime.InstanceContextProvider = Utility.CreateInstance<IInstanceContextProvider>(SingletonInstanceContextProviderType, new Type[] { typeof(DispatchRuntime) }, new object[] { dispatchRuntime });
                 MetadataProvisionService serviceInstance = new MetadataProvisionService(metadata);
                 dispatchRuntime.SingletonInstanceContext = new InstanceContext(host, serviceInstance);
             }
         }
     }
 }

		public override MetadataSet GetGeneratedMetadata ()
		{
			if (metadata != null)
				return metadata;

			metadata = new MetadataSet ();
			foreach (WSServiceDescription sd in GeneratedWsdlDocuments)
				metadata.MetadataSections.Add (
					MetadataSection.CreateFromServiceDescription (sd));

			foreach (XmlSchema xs in GeneratedXmlSchemas.Schemas ())
				metadata.MetadataSections.Add (
					MetadataSection.CreateFromSchema (xs));
				
			return metadata;
		}

		/// <summary>
		/// Resolves metadata from the specified URL.
		/// </summary>
		/// <param name="url">The URL.</param>
		/// <returns>A list of metadata sections.</returns>
		public static IEnumerable<MetadataSection> Resolve(string url)
		{
			MetadataSet metadataSet = new MetadataSet();
			DiscoveryClientProtocol discoveryClient = new DiscoveryClientProtocol
			{
				UseDefaultCredentials = true,
				AllowAutoRedirect = true
			};
			discoveryClient.DiscoverAny(url);
			discoveryClient.ResolveAll();
			foreach (object document in discoveryClient.Documents.Values)
			{
				AddDocumentToSet(metadataSet, document);
			}

			return metadataSet.MetadataSections;
		}