private static void GenerateCodeDomTree(WsdlImporter wsdlImporter, ServiceContractGenerator contractGenerator)
		{
			Collection<ContractDescription> contracts = wsdlImporter.ImportAllContracts();
			Collection<Binding> bindings = wsdlImporter.ImportAllBindings();
			ServiceEndpointCollection endpoints = wsdlImporter.ImportAllEndpoints();

			if (wsdlImporter.Errors.Any(e => !e.IsWarning))
			{
				throw new CodeGenerationException(wsdlImporter.Errors);
			}

			foreach (ContractDescription contract in contracts)
			{
				//TODO:Alex:Make the naming scheme customisable.
				contract.Name = "I" + contract.Name.Replace("Interface", string.Empty);
				contractGenerator.GenerateServiceContractType(contract);
			}

			foreach (Binding binding in bindings)
			{
				string bindingSectionName, configurationName;
				contractGenerator.GenerateBinding(binding, out bindingSectionName, out configurationName);
			}

			foreach (ServiceEndpoint endpoint in endpoints)
			{
				ChannelEndpointElement channelElement;
				contractGenerator.GenerateServiceEndpoint(endpoint, out channelElement);
			}
		}
Пример #2
0
        static void GenerateVBCodeForService(Uri metadataAddress, string outputFile)
        {
            MetadataExchangeClient mexClient = new MetadataExchangeClient(metadataAddress, MetadataExchangeClientMode.HttpGet);
              mexClient.ResolveMetadataReferences = true;
              MetadataSet metaDocs = mexClient.GetMetadata();

              WsdlImporter importer = new WsdlImporter(metaDocs);
              ServiceContractGenerator generator = new ServiceContractGenerator();

              System.Collections.ObjectModel.Collection<ContractDescription> contracts = importer.ImportAllContracts();
              foreach (ContractDescription contract in contracts)
              {
            generator.GenerateServiceContractType(contract);
              }
              if (generator.Errors.Count != 0)
            throw new ApplicationException("There were errors during code compilation.");

              // Write the code dom.
              System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions();
              options.BracingStyle = "C";
              System.CodeDom.Compiler.CodeDomProvider codeDomProvider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("VB");
              System.CodeDom.Compiler.IndentedTextWriter textWriter = new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(outputFile));
              codeDomProvider.GenerateCodeFromCompileUnit(generator.TargetCompileUnit, textWriter, options);
              textWriter.Close();
        }
        protected override CodeCompileUnit GenerateCode(EndPointSetting wsdl)
        {
            if (wsdl == null || string.IsNullOrEmpty(wsdl.Uri))
                throw new ApplicationException("WSDL Uri in endpoint section of the configuration is empty.");

            var wsdlContent = TryGetContent(wsdl.Uri);
            if (string.IsNullOrEmpty(wsdlContent))
                throw new ApplicationException("Could not get content from WSDL at " + wsdl.Uri);

            var codeCompileUnit = new CodeCompileUnit();

            try
            {
                var importer = CreateImporter(wsdl);
                var generator = new ServiceContractGenerator(codeCompileUnit);
                var ns = ProxyGeneratorSettings.Options.Services.Namespace;

                generator.Options = ServiceContractGenerationOptions.AsynchronousMethods |
                                    ServiceContractGenerationOptions.ChannelInterface |
                                    ServiceContractGenerationOptions.ClientClass |
                                    ServiceContractGenerationOptions.EventBasedAsynchronousMethods;

                // Data contract options
                importer.State.Remove(typeof(XsdDataContractExporter));
                var contractImporter = new XsdDataContractImporter();
                contractImporter.Options = new ImportOptions { EnableDataBinding = true };
                contractImporter.Options.Namespaces.Add("*", ns);
                importer.State.Add(typeof(XsdDataContractImporter), contractImporter);

                var contracts = importer.ImportAllContracts();
                var endpoints = importer.ImportAllEndpoints();

                var codeNamespace = new CodeNamespace(ns);
                codeCompileUnit.Namespaces.Add(codeNamespace);

                foreach(ContractDescription contract in contracts)
                {
                    generator.GenerateServiceContractType(contract);
                }

                if(generator.Errors.HasWarnings())
                {
                    Logger.WarnFormat("There was warnings when importing WSDL file at {0}. Warning message is: {1}.", wsdl.Uri, generator.Errors.GetWarnings());
                }

                // Call SL fixups
                var slfix = new WcfSilverlightCodeGenerationExtension();
                slfix.ClientGenerated(generator);
            }
            catch (Exception ex)
            {
                string message = "The wsdl with path:" + wsdl.Uri + " could not be processed.Error during the CodeCompileUnit generation.";
                throw new ApplicationException(message, ex);
            }

            return codeCompileUnit;
        }
        public ServiceClientProxyCompileResult CompileProxy(ServiceMetadataInformation serviceMetadataInfo)
        {
            string tempConfigFileName = CreateTempConfigFile();
            CodeCompileUnit codeCompileUnit = serviceMetadataInfo.CodeCompileUnit;
            ServiceContractGenerator contractGenerator = new ServiceContractGenerator(codeCompileUnit, CreateConfig(new FileInfo(tempConfigFileName)));
            contractGenerator.Options |= ServiceContractGenerationOptions.ClientClass;

            for (int i = 0; i < serviceMetadataInfo.Contracts.Count; i++)
            {
                ContractDescription contract = serviceMetadataInfo.Contracts[i];
                contractGenerator.GenerateServiceContractType(contract);
            }

            bool success = true;
            Collection<MetadataConversionError> contractGenErrors = contractGenerator.Errors;
            if (contractGenErrors != null)
            {
                foreach (MetadataConversionError error in contractGenErrors)
                {
                    if (!error.IsWarning)
                    {
                        success = false;
                        break;
                    }
                }
            }

            if (!success)
            {
                //TODO: Throw exception
            }

            CodeDomProvider codeDomProvider = serviceMetadataInfo.CodeDomProvider;
            string proxyCode = CreateProxyCode(codeDomProvider, codeCompileUnit);

            CompilerParameters compilerParameters = new CompilerParameters();

            AddAssemblyReference(typeof(ServiceContractAttribute).Assembly, compilerParameters.ReferencedAssemblies);
            AddAssemblyReference(typeof(System.Web.Services.Description.ServiceDescription).Assembly, compilerParameters.ReferencedAssemblies);
            AddAssemblyReference(typeof(DataContractAttribute).Assembly, compilerParameters.ReferencedAssemblies);
            AddAssemblyReference(typeof(XmlElement).Assembly, compilerParameters.ReferencedAssemblies);
            AddAssemblyReference(typeof(Uri).Assembly, compilerParameters.ReferencedAssemblies);
            AddAssemblyReference(typeof(DataSet).Assembly, compilerParameters.ReferencedAssemblies);

            CompilerResults results = codeDomProvider.CompileAssemblyFromSource(compilerParameters, proxyCode);

            CompilerErrorCollection compileErrors = results.Errors;
            Assembly compiledAssembly = Assembly.LoadFile(results.PathToAssembly);
            return new ServiceClientProxyCompileResult(serviceMetadataInfo, compiledAssembly, GenerateConfig(contractGenerator, serviceMetadataInfo.Endpoints, tempConfigFileName));
        }
        public CodeCompileUnit GenerateCodeFromImportedContracts(WsdlImporter importer)
        {
            var generator = new ServiceContractGenerator();

            var contracts = importer.ImportAllContracts();
            foreach (var contract in contracts)
            {
                generator.GenerateServiceContractType(contract);
            }
            if (generator.Errors.Count != 0)
                throw new Exception("There were errors during code compilation.");
            var targetCompileUnit = generator.TargetCompileUnit;
            return targetCompileUnit;
        }
Пример #6
0
        protected override CodeCompileUnit GenerateCode(EndPointSetting wsdl)
        {
            if (wsdl == null || string.IsNullOrEmpty(wsdl.Uri))
                throw new ApplicationException("WSDL Uri in endpoint section of the configuration is empty.");

            var wsdlContent = TryGetContent(wsdl.Uri);
            if (string.IsNullOrEmpty(wsdlContent))
                throw new ApplicationException("Could not get content from WSDL at " + wsdl.Uri);

            var codeCompileUnit = new CodeCompileUnit();

            try
            {
                var importer = CreateImporter(wsdl);
                var generator = new ServiceContractGenerator(codeCompileUnit);
                var contracts = importer.ImportAllContracts();
                var endpoints = importer.ImportAllEndpoints();

                var codeNamespace = new CodeNamespace(ProxyGeneratorSettings.Options.Services.Namespace);
                codeCompileUnit.Namespaces.Add(codeNamespace);

                foreach(ContractDescription contract in contracts)
                {
                    generator.GenerateServiceContractType(contract);
                }

                if(generator.Errors.HasWarnings())
                {
                    Logger.WarnFormat("There was warnings when importing WSDL file at {0}. Warning message is: {1}.", wsdl.Uri, generator.Errors.GetWarnings());
                }
            }
            catch (Exception ex)
            {
                string message = "The wsdl with path:" + wsdl.Uri + " could not be processed.Error during the CodeCompileUnit generation.";
                throw new ApplicationException(message, ex);
            }

            return codeCompileUnit;
        }
Пример #7
0
 /// <summary>
 /// 根据元数据发布地址生成代理类
 /// </summary>
 /// <param name="address">元数据地址</param>
 /// <param name="mode">交换元数据方式</param>
 /// <param name="outPutProxyFile">代理文件路径</param>
 /// <param name="outPutConfigFile">配置文件路径</param>
 private static void GenerateWCfProxyAndConfig(string address, Entities.MetadataExchangeClientMode mode, string outPutProxyFile, string outPutConfigFile)
 {
     var mexClient = new MetadataExchangeClient(new Uri(address), (System.ServiceModel.Description.MetadataExchangeClientMode) mode);
     var metadataSet = mexClient.GetMetadata();
     var importer = new WsdlImporter(metadataSet);
     var codeCompileUnit = new CodeCompileUnit();
     var config = ConfigurationManager.OpenMappedExeConfiguration(new ExeConfigurationFileMap { ExeConfigFilename = outPutConfigFile }, ConfigurationUserLevel.None);
     var generator = new ServiceContractGenerator(codeCompileUnit, config);
     foreach (var endpoint in importer.ImportAllEndpoints())
     {
         generator.GenerateServiceContractType(endpoint.Contract);
         ChannelEndpointElement element;
         generator.GenerateServiceEndpoint(endpoint, out element);
     }
     generator.Configuration.Save();
     var provider = CodeDomProvider.CreateProvider("CSharp");
     using (var sw = new StreamWriter(outPutProxyFile))
     {
         var textWriter = new IndentedTextWriter(sw);
         var options = new CodeGeneratorOptions();
         provider.GenerateCodeFromCompileUnit(codeCompileUnit, textWriter, options);
     }
 }
        /// <summary>
        /// Generates the basic CodeNamespace using .NET Fx code generation API.
        /// </summary>
        private void CreateBasicCodeDomTree()
        {
            TweakWsdlImporter();

            Collection<ContractDescription> contracts = wsdlImporter.ImportAllContracts();
            Collection<Binding> bindings = wsdlImporter.ImportAllBindings();
            ServiceEndpointCollection endpoints = wsdlImporter.ImportAllEndpoints();

			if (wsdlImporter.Errors.Any(e => !e.IsWarning))
			{
				throw new ClientServiceGenerationException(wsdlImporter.Errors);
			}

            ServiceContractGenerator scg = new ServiceContractGenerator(compileUnit, Configuration);
            TweakServiceContractGenerator(scg);

            foreach (ContractDescription contract in contracts)
            {
				contract.Name = "I" + contract.Name.Replace("Interface", string.Empty);
                CodeTypeReference ctr = scg.GenerateServiceContractType(contract);
            }

            foreach (Binding binding in bindings)
            {
				string bindingSectionName, configurationName;
				scg.GenerateBinding(binding, out bindingSectionName, out configurationName);
            }

            foreach (ServiceEndpoint endpoint in endpoints)
            {
				ChannelEndpointElement channelElement;
				scg.GenerateServiceEndpoint(endpoint, out channelElement);
            }
        }
Пример #9
0
		void Run (string [] args)
		{
			co.ProcessArgs (args);
			if (co.RemainingArguments.Length == 0) {
				co.DoHelp ();
				return;
			}
			if (!co.NoLogo)
				co.ShowBanner ();

			CodeCompileUnit ccu = new CodeCompileUnit ();
			CodeNamespace cns = new CodeNamespace (co.Namespace);
			ccu.Namespaces.Add (cns);

			generator = new ServiceContractGenerator (ccu);
			generator.Options = GetGenerationOption ();
			generator.Options |=ServiceContractGenerationOptions.ChannelInterface;

			code_provider = GetCodeProvider ();
			MetadataSet metadata = null;

			// For now only assemblyPath is supported.
			foreach (string arg in co.RemainingArguments) {
				Uri uri = null;
				if (Uri.TryCreate (arg, UriKind.Absolute, out uri)) {
					metadata = ResolveWithDisco (arg);
					if (metadata == null)
						metadata = ResolveWithWSMex (arg);

					continue;
				}

				FileInfo fi = new FileInfo (arg);
				if (!fi.Exists)
				switch (fi.Extension) {
				case ".exe":
				case ".dll":
					GenerateContractType (fi.FullName);
					break;
				default:
					throw new NotSupportedException ("Not supported file extension: " + fi.Extension);
				}
			}

			if (metadata == null)
				return;
			
			List<IWsdlImportExtension> list = new List<IWsdlImportExtension> ();
			list.Add (new TransportBindingElementImporter ());
			//list.Add (new DataContractSerializerMessageContractImporter ());
			list.Add (new XmlSerializerMessageContractImporter ());

			//WsdlImporter importer = new WsdlImporter (metadata, null, list);
			WsdlImporter importer = new WsdlImporter (metadata);
			//ServiceEndpointCollection endpoints = importer.ImportAllEndpoints ();

			Console.WriteLine ("Generating files..");
			/*foreach (ServiceEndpoint se in endpoints)
				generator.GenerateServiceContractType (se.Contract);*/

			Collection<ContractDescription> contracts = importer.ImportAllContracts ();
			foreach (ContractDescription cd in contracts)
				generator.GenerateServiceContractType (cd);

			/*if (cns.Types.Count == 0) {
				Console.Error.WriteLine ("Argument assemblies have no types.");
				Environment.Exit (1);
			}*/

			//FIXME: Generate .config 

			Console.WriteLine (GetOutputFilename ());
			using (TextWriter w = File.CreateText (GetOutputFilename ())) {
				code_provider.GenerateCodeFromCompileUnit (ccu, w, null);
			}
		}
Пример #10
0
        static void GenerateVBCodeForService(EndpointAddress metadataAddress, string outputFile)
        {
          MetadataExchangeClient mexClient = new MetadataExchangeClient(metadataAddress);
          mexClient.ResolveMetadataReferences = true;
          MetadataSet metaDocs = mexClient.GetMetadata();

          WsdlImporter importer = new WsdlImporter(metaDocs);
          ServiceContractGenerator generator = new ServiceContractGenerator();

          // Uncomment the following code if you are going to do your work programmatically rather than add 
          // the WsdlDocumentationImporters through a configuration file. 
          /*
          // The following code inserts the custom WSDL programmatically adding the custom WsdlImporter without
          // removing the other importers already in the collection.
          System.Collections.Generic.IEnumerable<IWsdlImportExtension> exts = importer.WsdlExtensions;
          System.Collections.Generic.List<IWsdlImportExtension> newExts = new System.Collections.Generic.List<IWsdlImportExtension>();
          foreach (IWsdlImportExtension ext in exts)
            newExts.Add(ext);
          newExts.Add(new WsdlDocumentationImporter());
          importer = new WsdlImporter(newExts.ToArray(), metaDocs.MetadataSections);
          */

          System.Collections.ObjectModel.Collection<ContractDescription> contracts = importer.ImportAllContracts();
          foreach (ContractDescription contract in contracts)
          {
            generator.GenerateServiceContractType(contract);
          }
          if (generator.Errors.Count != 0)
            throw new ApplicationException("There were errors during code compilation.");

          // Write the code dom.
          System.CodeDom.Compiler.CodeGeneratorOptions options = new System.CodeDom.Compiler.CodeGeneratorOptions();
          options.BracingStyle = "C";
          System.CodeDom.Compiler.CodeDomProvider codeDomProvider = System.CodeDom.Compiler.CodeDomProvider.CreateProvider("VB");
          System.CodeDom.Compiler.IndentedTextWriter textWriter = new System.CodeDom.Compiler.IndentedTextWriter(new System.IO.StreamWriter(outputFile));
          codeDomProvider.GenerateCodeFromCompileUnit(generator.TargetCompileUnit, textWriter, options);
          textWriter.Close();
        }
Пример #11
0
        static void Generate(string url, TextWriter writer)
        {
            var cr = new ContractReference();
            cr.Url = url;

            var protocol = new DiscoveryClientProtocol();

            var wc = new WebClient();
            using (var stream = wc.OpenRead(cr.Url))
                protocol.Documents.Add(cr.Url, cr.ReadDocument(stream));

            var mset = ToMetadataSet(protocol);

            var importer = new WsdlImporter(mset);
            var xsdImporter = new XsdDataContractImporter();
            var options = new ImportOptions();
            options.ReferencedCollectionTypes.Add(typeof(LinkedList<>));
            xsdImporter.Options = options;
            importer.State.Add(typeof(XsdDataContractImporter), xsdImporter);

            Collection<ContractDescription> contracts = importer.ImportAllContracts();

            CodeCompileUnit ccu = new CodeCompileUnit();
            CodeNamespace cns = new CodeNamespace("TestNamespace");
            ccu.Namespaces.Add(cns);

            var generator = new ServiceContractGenerator(ccu);

            foreach (var cd in contracts)
                generator.GenerateServiceContractType(cd);

            var provider = new CSharpCodeProvider();
            provider.GenerateCodeFromCompileUnit(ccu, writer, null);
        }
		protected override string CreateProxyFile (DotNetProject dotNetProject, FilePath basePath, string proxyNamespace, string referenceName)
		{
			var ccu = new CodeCompileUnit ();
			var cns = new CodeNamespace (proxyNamespace);
			ccu.Namespaces.Add (cns);
			
			bool targetMoonlight = dotNetProject.TargetFramework.Id.Identifier == ("Silverlight");
			bool targetMonoTouch = dotNetProject.TargetFramework.Id.Identifier == ("MonoTouch");
			bool targetMonoDroid = dotNetProject.TargetFramework.Id.Identifier == ("MonoDroid");
			
			bool targetCoreClr = targetMoonlight || targetMonoDroid || targetMonoTouch;
			bool generateSyncMethods = targetMonoDroid | targetMonoTouch;
			
			var generator = new ServiceContractGenerator (ccu);
			generator.Options = ServiceContractGenerationOptions.ChannelInterface | ServiceContractGenerationOptions.ClientClass;
			if (refGroup.ClientOptions.GenerateAsynchronousMethods || targetCoreClr)
				generator.Options |= ServiceContractGenerationOptions.AsynchronousMethods;
			if (refGroup.ClientOptions.GenerateEventBasedAsynchronousMethods)
				generator.Options |= ServiceContractGenerationOptions.EventBasedAsynchronousMethods;
#if NET_4_5
			if (refGroup.ClientOptions.GenerateTaskBasedAsynchronousMethod)
				generator.Options |= ServiceContractGenerationOptions.TaskBasedAsynchronousMethod;
#endif
			if (refGroup.ClientOptions.GenerateInternalTypes)
				generator.Options |= ServiceContractGenerationOptions.InternalTypes;
			if (refGroup.ClientOptions.GenerateMessageContracts)
				generator.Options |= ServiceContractGenerationOptions.TypedMessages;
//			if (targetMoonlight || targetMonoTouch)
//				generator.Options |= ServiceContractGenerationOptions.EventBasedAsynchronousMethods;
			
			MetadataSet mset;
			mset = protocol != null ? ToMetadataSet (protocol) : metadata;

			CodeDomProvider code_provider = GetProvider (dotNetProject);
			
			var list = new List<IWsdlImportExtension> ();
			list.Add (new TransportBindingElementImporter ());
			list.Add (new XmlSerializerMessageContractImporter ());
			
			var importer = new WsdlImporter (mset);
			try {
				ConfigureImporter (importer);
			} catch {
			}

			Collection<ContractDescription> contracts = importer.ImportAllContracts ();
			
			foreach (ContractDescription cd in contracts) {
				cd.Namespace = proxyNamespace;
				if (targetCoreClr) {
					var moonctx = new MoonlightChannelBaseContext ();
					cd.Behaviors.Add (new MoonlightChannelBaseContractExtension (moonctx, generateSyncMethods));
					foreach (var od in cd.Operations)
						od.Behaviors.Add (new MoonlightChannelBaseOperationExtension (moonctx, generateSyncMethods));
					generator.GenerateServiceContractType (cd);
					moonctx.Fixup ();
				}
				else
					generator.GenerateServiceContractType (cd);
			}
			
			string fileSpec = Path.Combine (basePath, referenceName + "." + code_provider.FileExtension);
			using (TextWriter w = File.CreateText (fileSpec)) {
				code_provider.GenerateCodeFromCompileUnit (ccu, w, null);
			}
			return fileSpec;
		}
Пример #13
0
        public static void GenerateProxyAssembly(string url, string guid, bool fromUi = false)
        {
            TestSuite suite = TestPackage.Suites.Find(s => s.Guid == guid);

            if (suite == null && fromUi)
            {
                suite = new TestSuite()
                {
                    ServiceUrl = url,
                    BaseUrl = url,
                    Wsdl = url + "?wsdl",
                    Guid = guid
                };
                TestPackage.Suites.Add(suite);
                url = suite.Wsdl;
            }

            StreamReader lResponseStream = GetHttpWebResponse(url);

            XmlTextReader xmlreader = new XmlTextReader(lResponseStream);

            //read the downloaded WSDL file
            ServiceDescription desc = ServiceDescription.Read(xmlreader);

            MetadataSection section = MetadataSection.CreateFromServiceDescription(desc);
            MetadataSet metaDocs = new MetadataSet(new[] { section });
            WsdlImporter wsdlimporter = new WsdlImporter(metaDocs);

            //Add any imported files
            foreach (XmlSchema wsdlSchema in desc.Types.Schemas)
            {
                foreach (XmlSchemaObject externalSchema in wsdlSchema.Includes)
                {
                    var import = externalSchema as XmlSchemaImport;
                    if (import != null)
                    {
                        if (suite != null)
                        {
                            Uri baseUri = new Uri(suite.BaseUrl);
                            if (string.IsNullOrEmpty(import.SchemaLocation)) continue;
                            Uri schemaUri = new Uri(baseUri, import.SchemaLocation);
                            StreamReader sr = GetHttpWebResponse(schemaUri.ToString());
                            XmlSchema schema = XmlSchema.Read(sr, null);
                            wsdlimporter.XmlSchemas.Add(schema);
                        }
                    }
                }
            }

            //Additional check in case some services do not generate end points using generator
            for (int w = 0; w < wsdlimporter.WsdlDocuments.Count; w++)
            {
                for (int se = 0; se < wsdlimporter.WsdlDocuments[w].Services.Count; se++)
                {
                    for (int po = 0; po < wsdlimporter.WsdlDocuments[w].Services[se].Ports.Count; po++)
                    {
                        // ReSharper disable once ForCanBeConvertedToForeach
                        for (int ext = 0; ext < wsdlimporter.WsdlDocuments[w].Services[se].Ports[po].Extensions.Count; ext++)
                        {

                            switch (wsdlimporter.WsdlDocuments[w].Services[se].Ports[po].Extensions[ext].GetType().Name)
                            {
                                //BasicHttpBinding
                                case "SoapAddressBinding":
                                    _endPointUrls.Add(((wsdlimporter.WsdlDocuments[w].Services[se].Ports[po])).Binding.Name, ((SoapAddressBinding)(wsdlimporter.WsdlDocuments[w].Services[se].Ports[po].Extensions[ext])).Location);
                                    if (suite != null &&
                                        !suite.EndPoints.ContainsKey(
                                            ((wsdlimporter.WsdlDocuments[w].Services[se].Ports[po])).Binding.Name))
                                    {
                                        suite.EndPoints.Add(
                                            ((wsdlimporter.WsdlDocuments[w].Services[se].Ports[po])).Binding.Name,
                                            ((SoapAddressBinding)
                                                (wsdlimporter.WsdlDocuments[w].Services[se].Ports[po].Extensions[ext]))
                                                .Location);
                                        suite.EndPointType.Add(((wsdlimporter.WsdlDocuments[w].Services[se].Ports[po])).Binding.Name,
                                            "BasicHttpBinding");
                                    }
                                    break;
                                //WSHttpBinding
                                case "Soap12AddressBinding":
                                    _endPointUrls.Add(((wsdlimporter.WsdlDocuments[w].Services[se].Ports[po])).Binding.Name, ((SoapAddressBinding)(wsdlimporter.WsdlDocuments[w].Services[se].Ports[po].Extensions[ext])).Location);
                                    if (suite != null &&
                                        !suite.EndPoints.ContainsKey(
                                            ((wsdlimporter.WsdlDocuments[w].Services[se].Ports[po])).Binding.Name))
                                    {
                                        if (((SoapAddressBinding)
                                            (wsdlimporter.WsdlDocuments[w].Services[se].Ports[po].Extensions[ext]))
                                            .Location.ToLower().StartsWith("net.tcp"))
                                        {
                                            suite.EndPoints.Add(
                                               ((wsdlimporter.WsdlDocuments[w].Services[se].Ports[po])).Binding.Name,
                                               ((SoapAddressBinding)
                                                   (wsdlimporter.WsdlDocuments[w].Services[se].Ports[po].Extensions[ext
                                                       ]))
                                                   .Location);
                                            suite.EndPointType.Add(
                                                ((wsdlimporter.WsdlDocuments[w].Services[se].Ports[po])).Binding.Name,
                                                "NetTcpBinding");
                                        }
                                        else
                                        {
                                            suite.EndPoints.Add(
                                                ((wsdlimporter.WsdlDocuments[w].Services[se].Ports[po])).Binding.Name,
                                                ((SoapAddressBinding)
                                                    (wsdlimporter.WsdlDocuments[w].Services[se].Ports[po].Extensions[ext
                                                        ]))
                                                    .Location);
                                            suite.EndPointType.Add(
                                                ((wsdlimporter.WsdlDocuments[w].Services[se].Ports[po])).Binding.Name,
                                                "WSHttpBinding");
                                        }
                                    }
                                    break;
                                case "XmlElement":
                                    break;
                            }
                        }
                    }
                }
            }

            foreach (Import import in wsdlimporter.WsdlDocuments[0].Imports)
            {
                GenerateProxyAssembly(import.Location, guid);
                return;
            }

            XsdDataContractImporter xsd = new XsdDataContractImporter
            {
                Options = new ImportOptions
                {
                    ImportXmlType = true,
                    GenerateSerializable = true
                }
            };
            xsd.Options.ReferencedTypes.Add(typeof(KeyValuePair<string, string>));
            xsd.Options.ReferencedTypes.Add(typeof(List<KeyValuePair<string, string>>));

            wsdlimporter.State.Add(typeof(XsdDataContractImporter), xsd);

            Collection<ContractDescription> contracts = wsdlimporter.ImportAllContracts();
            ServiceEndpointCollection allEndpoints = wsdlimporter.ImportAllEndpoints();
            // Generate type information for each contract.
            ServiceContractGenerator serviceContractGenerator = new ServiceContractGenerator();

            foreach (var contract in contracts)
            {
                serviceContractGenerator.GenerateServiceContractType(contract);
                // Keep a list of each contract's endpoints.
                if (suite != null)
                {
                    if (suite.EndpointsForContracts == null)
                        suite.EndpointsForContracts = new Dictionary<string, List<EndpointsForContractsClass>>();
                    suite.EndpointsForContracts[contract.Name] =
                        allEndpoints.Where(ep => ep.Contract.Name == contract.Name)
                            .Select(ep => new EndpointsForContractsClass()
                            {
                                Uri = ep.Address.Uri.ToString(),
                                Binding = ep.Binding
                            }).ToList();
                }
            }

            if (serviceContractGenerator.Errors.Count != 0)
                throw new Exception("There were errors during code compilation.");

            //Initialize the CODE DOM tree in which we will import the ServiceDescriptionImporter
            CodeNamespace nm = new CodeNamespace();
            CodeCompileUnit unit = new CodeCompileUnit();
            unit.Namespaces.Add(nm);

            CodeDomProvider compiler = CodeDomProvider.CreateProvider("C#");
            // include the assembly references needed to compile
            var references = new[] { "System.Web.Services.dll", "System.Xml.dll", "System.ServiceModel.dll", "System.configuration.dll", "System.Runtime.Serialization.dll" };
            var parameters = new CompilerParameters(references) { GenerateInMemory = true };
            var results = compiler.CompileAssemblyFromDom(parameters, serviceContractGenerator.TargetCompileUnit);

            if (results.Errors.Cast<CompilerError>().Any())
            {
                throw new Exception("Compilation Error Creating Assembly");
            }

            // all done....
            if (_assembly.ContainsKey(guid))
                _assembly[guid] = results.CompiledAssembly;
            else
                _assembly.Add(guid, results.CompiledAssembly);

            if (_serviceInterface.ContainsKey(guid))
                _serviceInterface[guid] = _assembly[guid].GetTypes()[0];
            else
                _serviceInterface.Add(guid, _assembly[guid].GetTypes()[0]);
        }
		protected override string CreateProxyFile (DotNetProject dotNetProject, FilePath basePath, string proxyNamespace, string referenceName)
		{
			CodeCompileUnit ccu = new CodeCompileUnit ();
			CodeNamespace cns = new CodeNamespace (proxyNamespace);
			ccu.Namespaces.Add (cns);
			
			bool targetMoonlight = dotNetProject.TargetFramework.Id.StartsWith ("SL");
			bool targetMonoTouch = dotNetProject.TargetFramework.Id.StartsWith ("IPhone");
			
			ServiceContractGenerator generator = new ServiceContractGenerator (ccu);
			generator.Options = ServiceContractGenerationOptions.ChannelInterface | ServiceContractGenerationOptions.ClientClass;
			if (refGroup.ClientOptions.GenerateAsynchronousMethods)
				generator.Options |= ServiceContractGenerationOptions.AsynchronousMethods;
			if (refGroup.ClientOptions.GenerateInternalTypes)
				generator.Options |= ServiceContractGenerationOptions.InternalTypes;
			if (refGroup.ClientOptions.GenerateMessageContracts)
				generator.Options |= ServiceContractGenerationOptions.TypedMessages;
//			if (targetMoonlight || targetMonoTouch)
//				generator.Options |= ServiceContractGenerationOptions.EventBasedAsynchronousMethods;
			
			MetadataSet mset;
			if (protocol != null)
				mset = ToMetadataSet (protocol);
			else
				mset = metadata;

			CodeDomProvider code_provider = GetProvider (dotNetProject);
			
			List<IWsdlImportExtension> list = new List<IWsdlImportExtension> ();
			list.Add (new TransportBindingElementImporter ());
			list.Add (new XmlSerializerMessageContractImporter ());
			
			WsdlImporter importer = new WsdlImporter (mset);
			Collection<ContractDescription> contracts = importer.ImportAllContracts ();
			
			foreach (ContractDescription cd in contracts) {
				cd.Namespace = proxyNamespace;
				if (targetMoonlight || targetMonoTouch) {
					var moonctx = new MoonlightChannelBaseContext ();
					cd.Behaviors.Add (new MoonlightChannelBaseContractExtension (moonctx, targetMonoTouch));
					foreach (var od in cd.Operations)
						od.Behaviors.Add (new MoonlightChannelBaseOperationExtension (moonctx, targetMonoTouch));
					generator.GenerateServiceContractType (cd);
					moonctx.Fixup ();
				}
				else
					generator.GenerateServiceContractType (cd);
			}
			
			string fileSpec = Path.Combine (basePath, referenceName + "." + code_provider.FileExtension);
			using (TextWriter w = File.CreateText (fileSpec)) {
				code_provider.GenerateCodeFromCompileUnit (ccu, w, null);
			}
			return fileSpec;
		}
Пример #15
0
        protected void btnFetchRequests_Click(object sender, EventArgs e)
        {
            txtRequest.Text = string.Empty;
            txtResponse.Text = string.Empty;
            string wsdlUrl = txtUrl.Text;
            if (wsdlUrl != null && wsdlUrl != string.Empty && wsdlUrl.IndexOf("wsdl") != -1)// && ValidateRequestURL())
            {
                lblWarning.Visible = false;
                try
                {
                    WSHttpBinding binding = new WSHttpBinding(SecurityMode.None);
                    binding.MaxReceivedMessageSize = 2147483647;
                    MetadataExchangeClient metClient = new MetadataExchangeClient(binding);
                    metClient.ResolveMetadataReferences = true;
                    MetadataSet metSet = metClient.GetMetadata(new Uri(wsdlUrl), MetadataExchangeClientMode.HttpGet);
                    WsdlImporter wsdlImporter = new WsdlImporter(metSet);
                    CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
                    ServiceContractGenerator generator = new ServiceContractGenerator(codeCompileUnit);

                    Collection<ContractDescription> contracts = wsdlImporter.ImportAllContracts();
                    ServiceEndpointCollection endpoints = wsdlImporter.ImportAllEndpoints();

                    List<string> opsList = new List<string>();
                    string serviceName = string.Empty;
                    string nameSpace = string.Empty;

                    foreach (ContractDescription contract in contracts)
                    {
                        foreach (OperationDescription op in contract.Operations)
                        {
                            opsList.Add(op.Name);
                        }
                        generator.GenerateServiceContractType(contract);
                        serviceName = contract.Name;
                        nameSpace = contract.Namespace;
                        break;
                    }
                    ddlOperations.DataSource = opsList;
                    ddlOperations.DataBind();
                    ddlOperations.Visible = true;
                    lblOperations.Visible = true;

                    ViewState.Add("ServiceName", serviceName);
                    ViewState.Add("Namespace", nameSpace);

                    CodeDomProvider provider1 = CodeDomProvider.CreateProvider("CSharp");
                    StringWriter ws = new StringWriter();
                    provider1.GenerateCodeFromCompileUnit(codeCompileUnit, ws, new CodeGeneratorOptions());

                    string serverRoot = System.Configuration.ConfigurationManager.AppSettings["ServerRoot"];
                    string[] assemblyNames = new string[] { "System.Configuration.dll", "System.Xml.dll", Server.MapPath( serverRoot + "bin/") + "System.Runtime.Serialization.dll",
                        "System.dll", "System.Web.Services.dll", "System.Data.dll", Server.MapPath( serverRoot + "bin/") + "System.ServiceModel.dll" };
                    CompilerParameters options = new CompilerParameters(assemblyNames);
                    options.WarningLevel = 0;
                    options.GenerateInMemory = true;

                    string sourceCode = ws.ToString();
                    CompilerResults results = provider1.CompileAssemblyFromSource(options, sourceCode);

                    if (!results.Errors.HasErrors)
                    {
                        Assembly compiledAssembly = results.CompiledAssembly;
                        Type objClientType = compiledAssembly.GetType(serviceName);

                        foreach (MethodInfo minfo in objClientType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly))
                        {
                            StringBuilder sb = new StringBuilder();

                            if (nameSpace != null && nameSpace != string.Empty)
                            {
                                sb.Append("<" + minfo.Name + " xmlns=\"" + nameSpace + "\">");
                            }
                            else
                            {
                                sb.Append("<" + minfo.Name + ">");
                            }

                            ParameterInfo[] paramInfos = minfo.GetParameters();
                            if (paramInfos != null && paramInfos.Length > 0)
                            {
                                foreach (ParameterInfo param in paramInfos)
                                {
                                    ConstructorInfo cons = param.ParameterType.GetConstructor(new Type[] { });
                                    if (cons != null)
                                    {
                                        if (param.ParameterType.IsSerializable)
                                        {
                                            sb.Append("<" + param.Name + ">");
                                            object obj = cons.Invoke(new object[] { });
                                            LoadPropertyMembers(obj, sb, compiledAssembly);
                                            sb.Append("</" + param.Name + ">");
                                        }
                                        else
                                        {
                                            object obj = cons.Invoke(new object[] { });
                                            LoadPropertyMembers(obj, sb, compiledAssembly);
                                        }

                                    }
                                    else
                                    {
                                        if (param.ParameterType.IsEnum)
                                        {
                                            sb.Append("<" + param.Name + ">");
                                            object obj = Activator.CreateInstance(compiledAssembly.GetType(param.ParameterType.FullName));
                                            sb.Append(obj.ToString());
                                            sb.Append("</" + param.Name + ">");
                                        }
                                        else if (param.ParameterType.IsValueType)
                                        {
                                            sb.Append("<" + param.Name + ">");
                                            switch (param.ParameterType.Name)
                                            {
                                                case "Int16":
                                                case "Int32":
                                                case "Int64":
                                                case "Double":
                                                case "Decimal":
                                                    sb.Append("0");
                                                    break;

                                                case "Boolean":
                                                    sb.Append("false");
                                                    break;

                                                case "DateTime":
                                                    sb.Append(DateTime.Now.ToString("yyyy-MM-dd"));
                                                    break;
                                            }
                                            sb.Append("</" + param.Name + ">");
                                        }
                                        else if (param.ParameterType.IsArray)
                                        {
                                            sb.Append("<" + param.Name + ">");
                                            string propName = param.ParameterType.Name;
                                            propName = propName.Replace("[]", string.Empty);
                                            sb.Append("<" + propName + ">");
                                            sb.Append("</" + propName + ">");
                                            sb.Append("</" + param.Name + ">");
                                        }
                                        else
                                        {
                                            sb.Append("<" + param.Name + ">");
                                            sb.Append("</" + param.Name + ">");
                                        }
                                    }
                                }
                            }
                            sb.Append("</" + minfo.Name + ">");


                            string data = "<?xml version=\"1.0\" encoding=\"utf-8\"?><soap:Envelope xmlns:soap=\"http://schemas.xmlsoap.org/soap/envelope/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><soap:Body>";
                            data += sb.ToString();
                            data += "</soap:Body></soap:Envelope>";

                            ViewState.Add(minfo.Name + "Request", data);
                        }
                        txtRequest.Text = IndentXMLString(ViewState[ddlOperations.SelectedValue + "Request"].ToString());
                        ws.Flush();
                        ws.Close();
                    }
                    else
                    {
                        lblWarning.Text = "There was an error in loading XML requests from the assembly." + "\n" +
                            "You can still provide XML request by copy and pasting it in the Request textbox.";
                        lblWarning.Visible = true;
                        //ViewState.Clear();
                    }

                }
                catch (Exception ex)
                {
                    lblWarning.Text = "Following error occured. " + ex.Message;
                    lblWarning.Visible = true;
                    ViewState.Clear();
                    return;
                }
            }
            else
            {
                lblWarning.Text = "Service URL is either empty or incorrect. Please provide a URL with \"wsdl\" extension. Example: http://servicename.com/service.svc?wsdl";
                lblWarning.Visible = true;
                lblWarning.ForeColor = System.Drawing.Color.Red;
                txtRequest.Text = string.Empty;
                txtResponse.Text = string.Empty;
                ddlOperations.Items.Clear();
            }
        }
Пример #16
0
		public static CodeCompileUnit Import (MetadataSet metadata, ImportOptions options)
		{
			var importer = new WsdlImporter (metadata);
			var xsdImporter = new XsdDataContractImporter ();
			xsdImporter.Options = options;
			importer.State.Add (typeof(XsdDataContractImporter), xsdImporter);
			
			var contracts = importer.ImportAllContracts ();
			
			CodeCompileUnit ccu = new CodeCompileUnit ();
			var generator = new ServiceContractGenerator (ccu);

			if (contracts.Count != 1)
				throw new InvalidOperationException (string.Format (
					"Metadata import failed: found {0} contracts.", contracts.Count));
			
			var contract = contracts.First ();
			generator.GenerateServiceContractType (contract);
			
			return ccu;
		}
        public AppDMoviesWSAutoDiscovery(string webserviceBindingUri, string interfaceContractName)
        {
            // Define the metadata address, contract name, operation name, and parameters.
            // You can choose between MEX endpoint and HTTP GET by changing the address and enum value.
            Uri mexAddress = new Uri(webserviceBindingUri);
            // For MEX endpoints use a MEX address and a mexMode of .MetadataExchange
            MetadataExchangeClientMode mexMode = MetadataExchangeClientMode.HttpGet;
            string contractName = interfaceContractName;

            //string creditcard, string expiry, string cvv

            // Get the metadata file from the service.
            MetadataExchangeClient mexClient = new MetadataExchangeClient(mexAddress, mexMode);
            mexClient.ResolveMetadataReferences = true;
            MetadataSet metaSet = mexClient.GetMetadata();

            // Import all contracts and endpoints
            WsdlImporter importer = new WsdlImporter(metaSet);
            Collection<ContractDescription> contracts = importer.ImportAllContracts();
            ServiceEndpointCollection allEndpoints = importer.ImportAllEndpoints();

            // Generate type information for each contract
            ServiceContractGenerator generator = new ServiceContractGenerator();
            var endpointsForContracts = new Dictionary<string, IEnumerable<ServiceEndpoint>>();

            foreach (ContractDescription contract in contracts)
            {
                generator.GenerateServiceContractType(contract);
                // Keep a list of each contract's endpoints
                endpointsForContracts[contract.Name] = allEndpoints.Where(
                    se => se.Contract.Name == contract.Name).ToList();
            }

            if (generator.Errors.Count != 0)
                throw new Exception("There were errors during code compilation.");

            // Generate a code file for the contracts
            CodeGeneratorOptions options = new CodeGeneratorOptions();
            options.BracingStyle = "C";
            CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider("C#");

            // Compile the code file to an in-memory assembly
            // Don't forget to add all WCF-related assemblies as references
            CompilerParameters compilerParameters = new CompilerParameters(
                new string[] {
                    "System.dll", "System.ServiceModel.dll",
                    "System.Runtime.Serialization.dll" });
            compilerParameters.GenerateInMemory = true;

            CompilerResults results = codeDomProvider.CompileAssemblyFromDom(compilerParameters, generator.TargetCompileUnit);
            if (results.Errors.Count > 0)
            {
                throw new Exception("There were errors during generated code compilation");
            }
            else
            {
                // Find the proxy type that was generated for the specified contract
                // (identified by a class that implements the contract and ICommunicationObject)
                Type[] mytypes = results.CompiledAssembly.GetTypes();

                Type clientProxyType = mytypes.First(
                    t => t.IsClass &&
                        t.GetInterface(contractName) != null &&
                        t.GetInterface(typeof(ICommunicationObject).Name) != null);

                // Get the first service endpoint for the contract
                ServiceEndpoint se = endpointsForContracts[contractName].First();

                // Create an instance of the proxy
                // Pass the endpoint's binding and address as parameters
                // to the ctor
                proxyinstance = results.CompiledAssembly.CreateInstance(
                    clientProxyType.Name,
                    false,
                    System.Reflection.BindingFlags.CreateInstance,
                    null,
                    new object[] { se.Binding, se.Address },
                    CultureInfo.CurrentCulture, null);
            }
        }
Пример #18
0
        /// <summary>
        /// Generates the code.
        /// </summary>
        /// <param name="serviceDescription">The service description.</param>
        /// <returns>WebServiceClientCodeDto.</returns>
        /// <exception cref="VeyronException">Service endpoints not found.</exception>
        public WebServiceClientCodeDto GenerateCode(WebServiceDescription serviceDescription)
        {
            var result = new WebServiceClientCodeDto { ServiceId = serviceDescription.Id, ServiceGuid = serviceDescription.Guid };

            using (var codeProvider = new CSharpCodeProvider())
            {
                var metadataSections = new List<MetadataSection>();
                metadataSections.AddRange(serviceDescription.XmlSchemas.Select(MetadataSection.CreateFromSchema));
                metadataSections.AddRange(serviceDescription.ServiceDescriptions.Select(MetadataSection.CreateFromServiceDescription));

                var @namespace = string.Format("sp_{0}", serviceDescription.Guid.ToString().Replace('-', '_'));
                var codeUnit = new CodeCompileUnit();

                var importer = new WsdlImporter(new MetadataSet(metadataSections));
                
                AddStateForXmlSerializerImport(importer, codeUnit, codeProvider, @namespace);
                AddStateForFaultSerializerImport(importer);
                RemoveDataContractSerializerExtension(importer);

                var endpoints = importer.ImportAllEndpoints();

                if (endpoints.Count == 0)
                {
                    if (importer.Errors.Any(e => !e.IsWarning))
                        throw new AggregateException("Service description import failed.", importer.Errors.Select(e => new Exception(e.Message)));

                    throw new VeyronException("Service endpoints not found.");
                }

                var endpoint = endpoints[0];

                var configDirectory = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());

                Directory.CreateDirectory(configDirectory);
                var configPath = Path.Combine(configDirectory, "endpoints.config");
                File.WriteAllText(configPath, EmptyConfiguration, Encoding.UTF8);

                var fileMap = new ExeConfigurationFileMap { ExeConfigFilename = configPath };
                var config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);

                var contractGenerator = new ServiceContractGenerator(codeUnit, config);
                contractGenerator.NamespaceMappings.Add("*", @namespace);
                contractGenerator.Options = ServiceContractGenerationOptions.ClientClass | ServiceContractGenerationOptions.TypedMessages;

                contractGenerator.GenerateServiceContractType(endpoint.Contract);
                ChannelEndpointElement endpointElement;
                contractGenerator.GenerateServiceEndpoint(endpoint, out endpointElement);

                config.Save();
                result.EndpointsConfiguration = File.ReadAllText(configPath);

                Directory.Delete(configDirectory, true);

                using (var stringWriter = new StringWriter())
                {
                    var options = new CodeGeneratorOptions { BracingStyle = "C" };
                    codeProvider.GenerateCodeFromCompileUnit(codeUnit, stringWriter, options);
                    stringWriter.Flush();

                    result.Code = stringWriter.ToString();

                    return result;
                }
            }
        }
Пример #19
0
		public void ImportMethodWithDateTime ()
		{
			var ms = GetMetadataSetFromWsdl ("Test/Resources/DateTime.wsdl");
			var imp = new WsdlImporter (ms);
			var cg = new ServiceContractGenerator ();
			var cd = imp.ImportAllContracts () [0];
			cg.GenerateServiceContractType (cd);
			var sw = new StringWriter ();
			new CSharpCodeProvider ().GenerateCodeFromCompileUnit (
				cg.TargetCompileUnit, sw, null);
			// sort of hacky test
			Assert.IsTrue (sw.ToString ().IndexOf ("System.DateTime GetDate") > 0, "#1");
		}
        /// <summary>
        /// Generate Proxy Code and (if available) configuration
        /// </summary>
        /// <param name="contractGenerator">The contract generator to use</param>
        /// <param name="targetCompileUnit">Compile unit into which we should generate the client code</param>
        /// <param name="proxyNamespace">CLR namespace into which we should generate the client code</param>
        /// <param name="configurationNamespace">Namespace to use in configuration</param>
        /// <param name="contractCollection">The contracts for which we should generate code and optionally config</param>
        /// <param name="bindingCollection">The bindings we should generate config for</param>
        /// <param name="serviceEndpointList">The endpoints we should generate config for</param>
        /// <param name="proxyGenerationErrors">A list of errors encountered while generating the client</param>
        /// <param name="serviceEndpointToChannelEndpointElementMap">Map from service endpoint to the configuration element for the endpoint</param>
        /// <param name="proxyGeneratedContractTypes">The generated contract types</param>
        protected static void GenerateProxy(WsdlImporter importer,
                                            ServiceContractGenerator contractGenerator,
                                            CodeCompileUnit targetCompileUnit,
                                            string proxyNamespace,
                                            string configurationNamespace,
                                            IEnumerable<ContractDescription> contractCollection,
                                            IEnumerable<System.ServiceModel.Channels.Binding> bindingCollection,
                                            List<ServiceEndpoint> serviceEndpointList,
                                            IList<ProxyGenerationError> proxyGenerationErrors,
                                            out Dictionary<ServiceEndpoint, ChannelEndpointElement> serviceEndpointToChannelEndpointElementMap,
                                            out List<GeneratedContractType> proxyGeneratedContractTypes)
        {
            // Parameter checking
            if (serviceEndpointList == null) throw new ArgumentNullException("serviceEndpointList");
            if (bindingCollection == null) throw new ArgumentNullException("bindingCollection");
            if (contractCollection == null) throw new ArgumentNullException("contractCollection");
            if (proxyGenerationErrors == null) throw new ArgumentNullException("proxyGenerationErrors");

            proxyGeneratedContractTypes = new List<GeneratedContractType>();
            serviceEndpointToChannelEndpointElementMap = new Dictionary<ServiceEndpoint, ChannelEndpointElement>();

            try
            {
                HttpBindingExtension httpBindingEx = importer.WsdlImportExtensions.Find<HttpBindingExtension>();

                foreach (ContractDescription contract in contractCollection)
                {
                    if (httpBindingEx == null || !httpBindingEx.IsHttpBindingContract(contract) || serviceEndpointList.Any(endpoint => endpoint.Contract == contract))
                    {
                        CodeTypeReference typeReference = contractGenerator.GenerateServiceContractType(contract);
                        if (typeReference != null)
                        {
                            // keep the (targetNamespace, portType) -> CLR type map table...

                            string baseType = typeReference.BaseType;

                            GeneratedContractType generatedType = new GeneratedContractType(contract.Namespace, contract.Name, baseType, baseType);
                            proxyGeneratedContractTypes.Add(generatedType);
                        }
                    }
                }

                // We should only import the Binding & Endpoints if there is a configuration storage...
                if (contractGenerator.Configuration != null)
                {
                    foreach (ServiceEndpoint endpoint in serviceEndpointList)
                    {
                        ChannelEndpointElement endpointElement = null;
                        contractGenerator.GenerateServiceEndpoint(endpoint, out endpointElement);
                        serviceEndpointToChannelEndpointElementMap[endpoint] = endpointElement;
                    }

                    foreach (System.ServiceModel.Channels.Binding bindingDescription in bindingCollection)
                    {
                        string bindingSectionName = null;
                        string bindingConfigurationName = null;
                        // Generate binding will change the state of the contractGenerator... 
                        contractGenerator.GenerateBinding(bindingDescription, out bindingSectionName, out bindingConfigurationName);
                    }

                }

                PatchConfigurationName(proxyNamespace,
                                       configurationNamespace,
                                       proxyGeneratedContractTypes,
                                       serviceEndpointToChannelEndpointElementMap.Values,
                                       targetCompileUnit);
            }
            finally
            {
                foreach (MetadataConversionError error in contractGenerator.Errors)
                {
                    proxyGenerationErrors.Add(new ProxyGenerationError(error));
                }
            }
        }
        /// <summary>
        /// compile our wsdl file
        /// </summary>
        /// <param name="astrWebServiceURI"></param>
        /// <param name="astrUsername"></param>
        /// <param name="astrPassword"></param>
        /// <param name="astrMethod"></param>
        /// <returns></returns>
        private compiledAssembly generateCompiledAssembly(string astrWebServiceURI, string astrUsername, string astrPassword, string astrMethod)
        {
            CompilerResults result = null;

            // Define the WSDL Get address, contract name and parameters, with this we can extract WSDL details any time
            //Uri address = new Uri("http://ifbenp.indfish.co.nz:16201/mws-ws/services/Vessel?wsdl"); //("http://localhost:64508/Service1.svc?wsdl");
            Uri address = new Uri(astrWebServiceURI);
            // For HttpGet endpoints use a Service WSDL address a mexMode of .HttpGet and for MEX endpoints use a MEX address and a mexMode of .MetadataExchange
            MetadataExchangeClientMode mexMode = MetadataExchangeClientMode.HttpGet;

            // Get the metadata file from the service.
            MetadataExchangeClient metadataExchangeClient = new MetadataExchangeClient(address, mexMode);
            metadataExchangeClient.ResolveMetadataReferences = true;

            //One can also provide credentials if service needs that by the help following two lines.
            ICredentials networkCredential = new NetworkCredential(astrUsername, astrPassword, "");
            metadataExchangeClient.HttpCredentials = networkCredential;

            //Gets the meta data information of the service.
            MetadataSet metadataSet = metadataExchangeClient.GetMetadata();

            // Import all contracts and endpoints.
            WsdlImporter wsdlImporter = new WsdlImporter(metadataSet);

            //Import all contracts.
            Collection<ContractDescription> contracts = wsdlImporter.ImportAllContracts();

            //Import all end points.
            ServiceEndpointCollection allEndpoints = wsdlImporter.ImportAllEndpoints();

            // Generate type information for each contract.
            ServiceContractGenerator serviceContractGenerator = new ServiceContractGenerator();

            //Dictinary has been defined to keep all the contract endpoints present, contract name is key of the dictionary item.
            var endpointsForContracts = new Dictionary<string, IEnumerable<ServiceEndpoint>>();

            string contractName = null;

            foreach (ContractDescription contract in contracts)
            {
                serviceContractGenerator.GenerateServiceContractType(contract);
                // Keep a list of each contract's endpoints.
                endpointsForContracts[contract.Name] = allEndpoints.Where(ep => ep.Contract.Name == contract.Name).ToList();
                contractName = contract.Name;
            }

            // Generate a code file for the contracts.
            CodeGeneratorOptions codeGeneratorOptions = new CodeGeneratorOptions();
            codeGeneratorOptions.BracingStyle = "C";

            // Create Compiler instance of a specified language.
            CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider("C#");

            // Adding WCF-related assemblies references as copiler parameters, so as to do the compilation of particular service contract.
            CompilerParameters compilerParameters = new CompilerParameters(new string[] { "System.dll", "System.ServiceModel.dll", "System.Runtime.Serialization.dll" });
            compilerParameters.GenerateInMemory = true;

            //Gets the compiled assembly.
            result = codeDomProvider.CompileAssemblyFromDom(compilerParameters, serviceContractGenerator.TargetCompileUnit);

            object proxyInstance = null;

            if (result.Errors.Count <= 0)
            {

                // Find the proxy type that was generated for the specified contract (identified by a class that implements the contract and ICommunicationbject - this is contract
                //implemented by all the communication oriented objects).
                Type proxyType = result.CompiledAssembly.GetTypes().First(t => t.IsClass && t.GetInterface(contractName) != null &&
                    t.GetInterface(typeof(ICommunicationObject).Name) != null);

                // Now we get the first service endpoint for the particular contract.
                ServiceEndpoint serviceEndpoint = endpointsForContracts[contractName].First();

                BasicHttpBinding newBinding = new BasicHttpBinding();

                newBinding.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
                newBinding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Basic;
                newBinding.Security.Transport.ProxyCredentialType = HttpProxyCredentialType.None;
                newBinding.Security.Message.AlgorithmSuite = System.ServiceModel.Security.SecurityAlgorithmSuite.Default;

                newBinding.Security.Message.ClientCredentialType = BasicHttpMessageCredentialType.UserName;

                serviceEndpoint.Binding = newBinding;

                // Create an instance of the proxy by passing the endpoint binding and address as parameters.
                proxyInstance = result.CompiledAssembly.CreateInstance(proxyType.Name, false, System.Reflection.BindingFlags.CreateInstance, null,
                    new object[] { serviceEndpoint.Binding, serviceEndpoint.Address }, CultureInfo.CurrentCulture, null);

                PropertyInfo clientCredentials = proxyType.GetProperty("ClientCredentials");
                if(null != clientCredentials)
                {
                    ClientCredentials credentials = new ClientCredentials();
                    credentials.UserName.UserName = astrUsername;
                    credentials.UserName.Password = astrPassword;

                    object objCredentials = clientCredentials.GetValue(proxyInstance);
                    credentials = objCredentials as ClientCredentials;

                    if (null != credentials)
                    {
                        credentials.UserName.Password = astrPassword;
                        credentials.UserName.UserName = astrUsername;
                    }
                }
            }

            compiledAssembly finalResults = new compiledAssembly() { compilerResults = result, instantiatedObject = proxyInstance };

            return (finalResults);
        }