public override void ImportClass() { // grab this here so it gets marked "handled" for both client and server SoapAddressBinding soapAddress = ImportContext.Port == null ? null : (SoapAddressBinding)ImportContext.Port.Extensions.Find(typeof(SoapAddressBinding)); if (ImportContext.Style == ServiceDescriptionImportStyle.Client) { ImportContext.CodeTypeDeclaration.BaseTypes.Add(typeof(SoapHttpClientProtocol).FullName); CodeConstructor ctor = WebCodeGenerator.AddConstructor(ImportContext.CodeTypeDeclaration, new string[0], new string[0], null, CodeFlags.IsPublic); ctor.Comments.Add(new CodeCommentStatement("<remarks/>", true)); if (ImportContext is Soap12ProtocolImporter) { // add version code CodeTypeReferenceExpression versionEnumTypeReference = new CodeTypeReferenceExpression(typeof(SoapProtocolVersion)); CodeFieldReferenceExpression versionEnumFieldReference = new CodeFieldReferenceExpression(versionEnumTypeReference, Enum.Format(typeof(SoapProtocolVersion), SoapProtocolVersion.Soap12, "G")); CodePropertyReferenceExpression versionPropertyReference = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "SoapVersion"); CodeAssignStatement assignVersionStatement = new CodeAssignStatement(versionPropertyReference, versionEnumFieldReference); ctor.Statements.Add(assignVersionStatement); } ServiceDescription serviceDescription = ImportContext.Binding.ServiceDescription; string url = (soapAddress != null) ? soapAddress.Location : null; string urlKey = serviceDescription.AppSettingUrlKey; string baseUrl = serviceDescription.AppSettingBaseUrl; ProtocolImporterUtil.GenerateConstructorStatements(ctor, url, urlKey, baseUrl); } else { ImportContext.CodeTypeDeclaration.BaseTypes.Add(typeof(WebService).FullName); } }
protected virtual SoapAddressBinding CreateSoapAddressBinding(string serviceUrl) { SoapAddressBinding soapAddress = new SoapAddressBinding(); soapAddress.Location = serviceUrl; return(soapAddress); }
bool ImportBasicHttpEndpoint(WsdlEndpointConversionContext context) { var http = context.Endpoint.Binding as BasicHttpBinding; if (http == null) { return(false); } WS.SoapAddressBinding address = null; foreach (var extension in context.WsdlPort.Extensions) { var check = extension as WS.SoapAddressBinding; if (check != null) { address = check; break; } } if (address == null) { return(false); } context.Endpoint.Address = new EndpointAddress(address.Location); context.Endpoint.ListenUri = new Uri(address.Location); context.Endpoint.ListenUriMode = ListenUriMode.Explicit; return(true); }
internal static bool ConvertSoapAddressBinding(ref object src, EnvelopeVersion version) { WsdlNS.SoapAddressBinding binding = src as WsdlNS.SoapAddressBinding; if (src != null) { if (binding == null) { return(false); // no match } else if (GetBindingVersion <WsdlNS.Soap12AddressBinding>(src) == version) { return(true); // matched but same version; no change } } if (version == EnvelopeVersion.None) { src = null; return(true); } WsdlNS.SoapAddressBinding dest = version == EnvelopeVersion.Soap12 ? new WsdlNS.Soap12AddressBinding() : new WsdlNS.SoapAddressBinding(); if (binding != null) { dest.Required = binding.Required; dest.Location = binding.Location; } src = dest; return(true); }
public override void ImportClass() { SoapAddressBinding binding = (base.ImportContext.Port == null) ? null : ((SoapAddressBinding)base.ImportContext.Port.Extensions.Find(typeof(SoapAddressBinding))); if (base.ImportContext.Style == ServiceDescriptionImportStyle.Client) { base.ImportContext.CodeTypeDeclaration.BaseTypes.Add(typeof(SoapHttpClientProtocol).FullName); CodeConstructor ctor = WebCodeGenerator.AddConstructor(base.ImportContext.CodeTypeDeclaration, new string[0], new string[0], null, CodeFlags.IsPublic); ctor.Comments.Add(new CodeCommentStatement(Res.GetString("CodeRemarks"), true)); bool flag = true; if (base.ImportContext is Soap12ProtocolImporter) { flag = false; CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression(typeof(SoapProtocolVersion)); CodeFieldReferenceExpression right = new CodeFieldReferenceExpression(targetObject, Enum.Format(typeof(SoapProtocolVersion), SoapProtocolVersion.Soap12, "G")); CodePropertyReferenceExpression left = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "SoapVersion"); CodeAssignStatement statement = new CodeAssignStatement(left, right); ctor.Statements.Add(statement); } ServiceDescription serviceDescription = base.ImportContext.Binding.ServiceDescription; string url = (binding != null) ? binding.Location : null; string appSettingUrlKey = serviceDescription.AppSettingUrlKey; string appSettingBaseUrl = serviceDescription.AppSettingBaseUrl; ProtocolImporterUtil.GenerateConstructorStatements(ctor, url, appSettingUrlKey, appSettingBaseUrl, flag && !base.ImportContext.IsEncodedBinding); } else if (base.ImportContext.Style == ServiceDescriptionImportStyle.Server) { base.ImportContext.CodeTypeDeclaration.BaseTypes.Add(typeof(WebService).FullName); } }
protected override void BeginClass () { SoapBinding sb = new SoapBinding (); sb.Transport = SoapBinding.HttpTransport; sb.Style = ((SoapTypeStubInfo)TypeInfo).SoapBindingStyle; Binding.Extensions.Add (sb); SoapAddressBinding abind = new SoapAddressBinding (); abind.Location = ServiceUrl; Port.Extensions.Add (abind); }
override void ReflectDescription() { SoapBinding sb = CreateSoapBinding(); sb.Transport = SoapBinding.HttpTransport; sb.Style = ((SoapTypeStubInfo)ReflectionContext.TypeInfo).SoapBindingStyle; ReflectionContext.Binding.Extensions.Add(sb); SoapAddressBinding abind = CreateSoapAddressBinding(); abind.Location = ReflectionContext.ServiceUrl; ReflectionContext.Port.Extensions.Add(abind); }
protected virtual SoapAddressBinding CreateSoapAddressBinding(string serviceUrl) { SoapAddressBinding soapAddress = new SoapAddressBinding(); soapAddress.Location = serviceUrl; if (this.UriFixups != null) { this.UriFixups.Add(delegate(Uri current) { soapAddress.Location = DiscoveryServerType.CombineUris(current, soapAddress.Location); }); } return(soapAddress); }
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext context) { var soap_binding = new WS.SoapBinding(); soap_binding.Transport = WS.SoapBinding.HttpTransport; soap_binding.Style = WS.SoapBindingStyle.Document; context.WsdlBinding.Extensions.Add(soap_binding); var soap_address = new WS.SoapAddressBinding(); soap_address.Location = context.Endpoint.Address.Uri.AbsoluteUri; context.WsdlPort.Extensions.Add(soap_address); }
static WsdlNS.SoapAddressBinding CreateSoapAddressBinding(EnvelopeVersion version, WsdlNS.Port wsdlPort) { WsdlNS.SoapAddressBinding soapAddressBinding = null; if (version == EnvelopeVersion.Soap12) { soapAddressBinding = new WsdlNS.Soap12AddressBinding(); } else if (version == EnvelopeVersion.Soap11) { soapAddressBinding = new WsdlNS.SoapAddressBinding(); } Fx.Assert(soapAddressBinding != null, "EnvelopeVersion is not recognized. Please update the SoapHelper class"); wsdlPort.Extensions.Add(soapAddressBinding); return(soapAddressBinding); }
// ----------------------------------------------------------------------------------------------------------------------- // Developers Note: We go through a little song an dance here to Get or Create an exsisting SoapBinding from the WSDL // Extensions for a number of reasons: // 1. Multiple Extensions may contribute to the settings in the soap binding and so to make this work without // relying on ordering, we need the GetOrCreate method. // 2. There are diffrent classes for diffrent SOAP versions and the extensions that determines the version is // also un-ordered so when we finally figure out the version we may need to recreate the BindingExtension and // clone it. internal static WsdlNS.SoapAddressBinding GetOrCreateSoapAddressBinding(WsdlNS.Binding wsdlBinding, WsdlNS.Port wsdlPort, WsdlExporter exporter) { if (GetSoapVersionState(wsdlBinding, exporter) == EnvelopeVersion.None) { return(null); } WsdlNS.SoapAddressBinding existingSoapAddressBinding = GetSoapAddressBinding(wsdlPort); EnvelopeVersion version = GetSoapVersion(wsdlBinding); if (existingSoapAddressBinding != null) { return(existingSoapAddressBinding); } WsdlNS.SoapAddressBinding soapAddressBinding = CreateSoapAddressBinding(version, wsdlPort); return(soapAddressBinding); }
void CheckDuplicateSoapAddressBinding(ConformanceCheckContext ctx, ServiceDescription value) { ArrayList locations = new ArrayList(); foreach (PortType p in value.PortTypes) { SoapAddressBinding b = (SoapAddressBinding)p.Extensions.Find(typeof(SoapAddressBinding)); if (b == null || b.Location == null || b.Location.Length == 0) { continue; } if (locations.Contains(b.Location)) { ctx.ReportRuleViolation(value, BasicProfileRules.R2711); // One report for one ServiceDescription should be enough. return; } locations.Add(b.Location); } }
void IWsdlExportExtension.ExportEndpoint(WsdlExporter exporter, WsdlEndpointConversionContext endpointContext) { bool createdNew; MessageEncodingBindingElement encodingBindingElement = FindMessageEncodingBindingElement(endpointContext, out createdNew); bool useWebSocketTransport = WebSocketHelper.UseWebSocketTransport(this.WebSocketSettings.TransportUsage, endpointContext.ContractConversionContext.Contract.IsDuplex()); EndpointAddress address = endpointContext.Endpoint.Address; if (useWebSocketTransport) { address = new EndpointAddress(WebSocketHelper.GetWebSocketUri(endpointContext.Endpoint.Address.Uri), endpointContext.Endpoint.Address); WsdlNS.SoapAddressBinding binding = SoapHelper.GetSoapAddressBinding(endpointContext.WsdlPort); if (binding != null) { binding.Location = address.Uri.AbsoluteUri; } } TransportBindingElement.ExportWsdlEndpoint(exporter, endpointContext, this.GetWsdlTransportUri(useWebSocketTransport), address, encodingBindingElement.MessageVersion.Addressing); }
//this imports the address of the endpoint. void ImportAddress(WsdlEndpointConversionContext context) { EndpointAddress address = null; if (context.WsdlPort != null) { XmlElement addressing10Element = context.WsdlPort.Extensions.Find("EndpointReference", AddressingVersionConstants.WSAddressing10NameSpace); XmlElement addressing200408Element = context.WsdlPort.Extensions.Find("EndpointReference", AddressingVersionConstants.WSAddressingAugust2004NameSpace); WsdlNS.SoapAddressBinding soapAddressBinding = (WsdlNS.SoapAddressBinding)context.WsdlPort.Extensions.Find(typeof(WsdlNS.SoapAddressBinding)); if (addressing10Element != null) { address = EndpointAddress.ReadFrom(AddressingVersion.WSAddressing10, new XmlNodeReader(addressing10Element)); } if (addressing200408Element != null) { address = EndpointAddress.ReadFrom(AddressingVersion.WSAddressingAugust2004, new XmlNodeReader(addressing200408Element)); } else if (soapAddressBinding != null) { // checking for soapAddressBinding checks for both Soap 1.1 and Soap 1.2 address = new EndpointAddress(soapAddressBinding.Location); } } if (address != null) { context.Endpoint.Address = address; } }
protected override CodeTypeDeclaration BeginClass() { soapBinding = (SoapBinding)Binding.Extensions.Find(typeof(SoapBinding)); CodeTypeDeclaration codeClass = new CodeTypeDeclaration(ClassName); #if NET_2_0 codeClass.IsPartial = true; #endif string location = null; if (Port != null) { SoapAddressBinding sab = (SoapAddressBinding)Port.Extensions.Find(typeof(SoapAddressBinding)); if (sab != null) { location = sab.Location; } } string namspace = (Port != null ? Port.Binding.Namespace : Binding.ServiceDescription.TargetNamespace); string name = (Port != null ? Port.Name : Binding.Name); if (Style == ServiceDescriptionImportStyle.Client) { CodeTypeReference ctr = new CodeTypeReference("System.Web.Services.Protocols.SoapHttpClientProtocol"); codeClass.BaseTypes.Add(ctr); } else { CodeTypeReference ctr = new CodeTypeReference("System.Web.Services.WebService"); codeClass.BaseTypes.Add(ctr); CodeAttributeDeclaration attws = new CodeAttributeDeclaration("System.Web.Services.WebServiceAttribute"); attws.Arguments.Add(GetArg("Namespace", namspace)); AddCustomAttribute(codeClass, attws, true); } CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Web.Services.WebServiceBinding"); att.Arguments.Add(GetArg("Name", name)); att.Arguments.Add(GetArg("Namespace", namspace)); AddCustomAttribute(codeClass, att, true); if (Style == ServiceDescriptionImportStyle.Client) { CodeConstructor cc = new CodeConstructor(); cc.Attributes = MemberAttributes.Public; GenerateServiceUrl(location, cc.Statements); #if NET_2_0 if (ProtocolName.ToUpper() == "SOAP12") { CodeExpression thisSoapVer = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "SoapVersion"); CodeFieldReferenceExpression soap12Enum = new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(SoapProtocolVersion)), "Soap12"); cc.Statements.Add(new CodeAssignStatement(thisSoapVer, soap12Enum)); } #endif codeClass.Members.Add(cc); } memberIds = new CodeIdentifiers(); headerVariables = new Hashtable(); return(codeClass); }
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; }
static void BasicHttpBinding_inner( TestContext context, MetadataSet doc, BasicHttpSecurityMode security, WSMessageEncoding encoding, HttpClientCredentialType clientCred, AuthenticationSchemes authScheme, bool isHttps, TestLabel label) { var sd = (WS.ServiceDescription)doc.MetadataSections [0].Metadata; label.EnterScope("wsdl"); label.EnterScope("bindings"); Assert.That(sd.Bindings.Count, Is.EqualTo(1), label.Get()); var binding = sd.Bindings [0]; Assert.That(binding.ExtensibleAttributes, Is.Null, label.Get()); Assert.That(binding.Extensions, Is.Not.Null, label.Get()); bool hasPolicyXml; switch (security) { case BasicHttpSecurityMode.None: if (isHttps) { throw new InvalidOperationException(); } hasPolicyXml = encoding == WSMessageEncoding.Mtom; break; case BasicHttpSecurityMode.Message: case BasicHttpSecurityMode.Transport: case BasicHttpSecurityMode.TransportWithMessageCredential: if (encoding == WSMessageEncoding.Mtom) { throw new InvalidOperationException(); } hasPolicyXml = true; break; case BasicHttpSecurityMode.TransportCredentialOnly: if (isHttps) { throw new InvalidOperationException(); } hasPolicyXml = true; break; default: throw new InvalidOperationException(); } label.LeaveScope(); WS.SoapBinding soap = null; XmlElement xml = null; foreach (var ext in binding.Extensions) { if (ext is WS.SoapBinding) { soap = (WS.SoapBinding)ext; } else if (ext is XmlElement) { xml = (XmlElement)ext; } } CheckSoapBinding(soap, WS.SoapBinding.HttpTransport, label); label.LeaveScope(); label.EnterScope("policy-xml"); if (!hasPolicyXml) { Assert.That(xml, Is.Null, label.Get()); } else { Assert.That(xml, Is.Not.Null, label.Get()); var assertions = AssertPolicy(sd, xml, label); Assert.That(assertions, Is.Not.Null, label.Get()); if (clientCred == HttpClientCredentialType.Ntlm) { AssertPolicy(assertions, NtlmAuthenticationQName, label); } if (encoding == WSMessageEncoding.Mtom) { AssertPolicy(assertions, MtomEncodingQName, label); } switch (security) { case BasicHttpSecurityMode.Message: AssertPolicy(assertions, AsymmetricBindingQName, label); AssertPolicy(assertions, Wss10QName, label); break; case BasicHttpSecurityMode.Transport: AssertPolicy(assertions, TransportBindingQName, label); break; case BasicHttpSecurityMode.TransportWithMessageCredential: AssertPolicy(assertions, SignedSupportingQName, label); AssertPolicy(assertions, TransportBindingQName, label); AssertPolicy(assertions, Wss10QName, label); break; default: break; } Assert.That(assertions.Count, Is.EqualTo(0), label.Get()); } label.LeaveScope(); label.EnterScope("services"); Assert.That(sd.Services, Is.Not.Null, label.Get()); Assert.That(sd.Services.Count, Is.EqualTo(1), label.Get()); var service = sd.Services [0]; Assert.That(service.Ports, Is.Not.Null, label.Get()); Assert.That(service.Ports.Count, Is.EqualTo(1), label.Get()); var port = service.Ports [0]; label.EnterScope("port"); Assert.That(port.Extensions, Is.Not.Null, label.Get()); Assert.That(port.Extensions.Count, Is.EqualTo(1), label.Get()); WS.SoapAddressBinding soap_addr_binding = null; foreach (var extension in port.Extensions) { if (extension is WS.SoapAddressBinding) { soap_addr_binding = (WS.SoapAddressBinding)extension; } else { Assert.Fail(label.Get()); } } Assert.That(soap_addr_binding, Is.Not.Null, label.Get()); label.LeaveScope(); label.LeaveScope(); // wsdl var importer = new WsdlImporter(doc); label.EnterScope("bindings"); var bindings = importer.ImportAllBindings(); CheckImportErrors(importer, label); Assert.That(bindings, Is.Not.Null, label.Get()); Assert.That(bindings.Count, Is.EqualTo(1), label.Get()); string scheme; if ((security == BasicHttpSecurityMode.Transport) || (security == BasicHttpSecurityMode.TransportWithMessageCredential)) { scheme = "https"; } else { scheme = "http"; } CheckBasicHttpBinding( bindings [0], scheme, security, encoding, clientCred, authScheme, label); label.LeaveScope(); label.EnterScope("endpoints"); var endpoints = importer.ImportAllEndpoints(); CheckImportErrors(importer, label); Assert.That(endpoints, Is.Not.Null, label.Get()); Assert.That(endpoints.Count, Is.EqualTo(1), label.Get()); var uri = isHttps ? MetadataSamples.HttpsUri : MetadataSamples.HttpUri; CheckEndpoint(endpoints [0], uri, label); label.LeaveScope(); }
protected virtual SoapAddressBinding CreateSoapAddressBinding(string serviceUrl) { SoapAddressBinding soapAddress = new SoapAddressBinding(); soapAddress.Location = serviceUrl; if (this.UriFixups != null) { this.UriFixups.Add(delegate(Uri current) { soapAddress.Location = DiscoveryServerType.CombineUris(current, soapAddress.Location); }); } return soapAddress; }
private void Write119_SoapAddressBinding(string n, string ns, SoapAddressBinding o, bool isNullable, bool needType) { if (o == null) { if (isNullable) { base.WriteNullTagLiteral(n, ns); } } else { if (!needType && !(o.GetType() == typeof(SoapAddressBinding))) { throw base.CreateUnknownTypeException(o); } base.WriteStartElement(n, ns, o, false, null); if (needType) { base.WriteXsiType("SoapAddressBinding", "http://schemas.xmlsoap.org/wsdl/soap/"); } if (o.Required) { base.WriteAttribute("required", "http://schemas.xmlsoap.org/wsdl/", XmlConvert.ToString(o.Required)); } base.WriteAttribute("location", "", o.Location); base.WriteEndElement(o); } }
private static void ConstructServiceElement(InterfaceContract serviceInterfaceContract, bool isRoundTrip, System.Web.Services.Description.ServiceDescription desc, string serviceName, string portTypeName, List<ServiceEndpoint> endpoints) { // Generate <service> element optionally - sometimes necessary for interop reasons if (serviceInterfaceContract.NeedsServiceElement) { Service defaultService = null; if (isRoundTrip || desc.Services.Count == 0) { // Create a new service element. defaultService = new Service(); defaultService.Name = serviceName; foreach (ServiceEndpoint endpoint in endpoints) { if (endpoint.Binding.MessageVersion.Envelope == EnvelopeVersion.Soap11) { Port defaultPort = new Port(); defaultPort.Name = serviceInterfaceContract.ServiceName + "Port"; defaultPort.Binding = new XmlQualifiedName(endpoint.Name.Replace(Constants.InternalContractName, portTypeName), desc.TargetNamespace); SoapAddressBinding defaultSoapAddressBinding = new SoapAddressBinding(); defaultSoapAddressBinding.Location = GetDefaultEndpoint(endpoint.Binding, serviceInterfaceContract.ServiceName); defaultPort.Extensions.Add(defaultSoapAddressBinding); defaultService.Ports.Add(defaultPort); } else if (endpoint.Binding.MessageVersion.Envelope == EnvelopeVersion.Soap12) { Port soap12Port = new Port(); soap12Port.Name = serviceInterfaceContract.ServiceName + "SOAP12Port"; soap12Port.Binding = new XmlQualifiedName(endpoint.Name.Replace(Constants.InternalContractName, portTypeName), desc.TargetNamespace); Soap12AddressBinding soap12AddressBinding = new Soap12AddressBinding(); soap12AddressBinding.Location = GetDefaultEndpoint(endpoint.Binding, serviceInterfaceContract.ServiceName); soap12Port.Extensions.Add(soap12AddressBinding); defaultService.Ports.Add(soap12Port); } } desc.Services.Add(defaultService); } else { defaultService = desc.Services[0]; defaultService.Name = serviceName; } } }
private void ConvertService(DescriptionType wsdl2, ServiceDescription wsdl1) { var services = wsdl2.Items.Where(s => s is ServiceType); foreach (ServiceType s2 in services) { var s1 = new Service(); wsdl1.Services.Add(s1); s1.Name = s2.name; foreach (EndpointType e2 in s2.Items) { var p1 = new Port(); s1.Ports.Add(p1); p1.Name = e2.name; p1.Binding = e2.binding; var sab = new SoapAddressBinding() { Location = e2.address }; var sab12 = new Soap12AddressBinding() { Location = e2.address }; p1.Extensions.Add(sab); p1.Extensions.Add(sab12); } } }
/// <summary> /// Generates the WSDL file for a specified <see cref="InterfaceContract"/>. /// </summary> /// <param name="serviceInterfaceContract"> /// <see cref="InterfaceContract"/> to use for the WSDL generation. /// </param> /// <param name="wsdlSaveLocation">Location to save the generated WSDL file.</param> /// <param name="xmlComment">XML comment to add to the top of the WSDL file.</param> /// <param name="wsdlLocation">Path of an existing WSDL file to overwrite with the generated /// WSDL file.</param> /// <returns>The path of the WSDL file generated.</returns> /// <remarks> /// This methods loads the information, it receive in a <see cref="InterfaceContract"/> to /// a <see cref="System.Web.Services.Description.ServiceDescription"/> class, which is later /// used to generate the WSDL file. The loading process takes place in several steps. <br></br> /// 1. Load the basic meta data from <see cref="InterfaceContract"/>.<br></br> /// 2. Load the schema imports in the <see cref="SchemaImports"/> collection.<br></br> /// 3. Load the messages in <see cref="OperationsCollection"/>.<br></br> /// 4. Create the WSDL Port Type.<br></br> /// 5. Add each operation and it's corresponding in/out messages to the Port Type.<br></br> /// 6. Create a WSDL Binding section and add OperationBinding for each operation.<br></br> /// 7. Generate the WSDL 'service' tags if required.<br></br> /// 8. Finally write the file to the output stream.<br></br> /// /// This method generates <see cref="WsdlGenerationException"/> exception, if it fails to create the WSDL file. /// If a file is specified to overwrite with the new file, the original file is restored in case of /// a failure. /// </remarks> public static string GenerateWsdl(InterfaceContract serviceInterfaceContract, string wsdlSaveLocation, string xmlComment, string wsdlLocation) { System.Web.Services.Description.ServiceDescription desc = null; string serviceAttributeName = ""; string bindingName = ""; string serviceName = ""; string portTypeName = ""; // Load the existing WSDL if one specified. if (wsdlLocation != null) { #region Round-tripping desc = System.Web.Services.Description.ServiceDescription.Read(wsdlLocation); // Read the existing name values. serviceAttributeName = desc.Name; bindingName = desc.Bindings[0].Name; portTypeName = desc.PortTypes[0].Name; // Check whether we have a service element and save it's name for the // future use. if (desc.Services.Count > 0) { serviceName = desc.Services[0].Name; } else { serviceName = serviceInterfaceContract.ServiceName + "Port"; ; } // Check for the place which has the Service name and assign the new value // appropriatly. if (serviceAttributeName != null && serviceAttributeName != "") { serviceAttributeName = serviceInterfaceContract.ServiceName; } else if (serviceName != null && serviceName != "") { // If the user has selected to remove the service element, // use the service name in the attribute by default. if (serviceInterfaceContract.NeedsServiceElement) { serviceName = serviceInterfaceContract.ServiceName; } else { serviceAttributeName = serviceInterfaceContract.ServiceName; } } else if (bindingName != null && bindingName != "") { bindingName = serviceInterfaceContract.ServiceName; } // Clear the service description. But do not clear the types definitions. desc.Extensions.Clear(); desc.Bindings.Clear(); desc.Documentation = ""; desc.Imports.Clear(); desc.Messages.Clear(); desc.PortTypes.Clear(); desc.RetrievalUrl = ""; if (desc.ServiceDescriptions != null) { desc.ServiceDescriptions.Clear(); } if (!serviceInterfaceContract.NeedsServiceElement) { desc.Services.Clear(); } #endregion } else { #region New WSDL desc = new System.Web.Services.Description.ServiceDescription(); // Create the default names. serviceAttributeName = serviceInterfaceContract.ServiceName; bindingName = serviceInterfaceContract.ServiceName; portTypeName = serviceInterfaceContract.ServiceName + "Interface"; serviceName = serviceInterfaceContract.ServiceName + "Port"; #endregion } #region Load the basic meta data. if (serviceAttributeName != null && serviceAttributeName != "") { desc.Name = serviceAttributeName; } desc.TargetNamespace = serviceInterfaceContract.ServiceNamespace; desc.Documentation = serviceInterfaceContract.ServiceDocumentation; #endregion #region Load the schema imports. XmlSchema typesSchema = null; // Are we round-tripping? Then we have to access the existing types // section. // Otherwise we just initialize a new XmlSchema for types. if (wsdlLocation != null) { typesSchema = desc.Types.Schemas[desc.TargetNamespace]; // if we don't have a types section belonging to the same namespace as service description // we take the first types section available. if (typesSchema == null) { typesSchema = desc.Types.Schemas[0]; } // Remove the includes. We gonna re-add them later in this operation. typesSchema.Includes.Clear(); } else { typesSchema = new XmlSchema(); } // Add imports to the types section resolved above. foreach (SchemaImport import in serviceInterfaceContract.Imports) { XmlSchemaExternal importedSchema = null; if (import.SchemaNamespace == null || import.SchemaNamespace == "") { importedSchema = new XmlSchemaInclude(); } else { importedSchema = new XmlSchemaImport(); ((XmlSchemaImport)importedSchema).Namespace = import.SchemaNamespace; } if (serviceInterfaceContract.UseAlternateLocationForImports) { importedSchema.SchemaLocation = import.AlternateLocation; } else { importedSchema.SchemaLocation = import.SchemaLocation; } typesSchema.Includes.Add(importedSchema); } // If we are not round-tripping we have to link the types schema we just created to // the service description. if (wsdlLocation == null) { // Finally add the type schema to the ServiceDescription.Types.Schemas collection. desc.Types.Schemas.Add(typesSchema); } #endregion #region Load the messages in all the operations MessageCollection msgs = desc.Messages; foreach (Operation op in serviceInterfaceContract.OperationsCollection) { foreach (Message msg in op.MessagesCollection) { FxMessage tempMsg = new FxMessage(); tempMsg.Name = msg.Name; tempMsg.Documentation = msg.Documentation; MessagePart msgPart = new MessagePart(); msgPart.Name = Constants.DefaultMessagePartName; msgPart.Element = new XmlQualifiedName(msg.Element.ElementName, msg.Element.ElementNamespace); tempMsg.Parts.Add(msgPart); msgs.Add(tempMsg); } foreach (Message msg in op.Faults) { Message messageName = msg; if (msgs.OfType<FxMessage>().Any(m => m.Name == messageName.Name)) continue; FxMessage tempMsg = new FxMessage(); tempMsg.Name = msg.Name; tempMsg.Documentation = msg.Documentation; MessagePart msgPart = new MessagePart(); msgPart.Name = Constants.FaultMessagePartName; msgPart.Element = new XmlQualifiedName(msg.Element.ElementName, msg.Element.ElementNamespace); tempMsg.Parts.Add(msgPart); msgs.Add(tempMsg); } } #endregion #region Create the Port Type PortTypeCollection portTypes = desc.PortTypes; PortType portType = new PortType(); portType.Name = portTypeName; portType.Documentation = serviceInterfaceContract.ServiceDocumentation; // Add each operation and it's corresponding in/out messages to the WSDL Port Type. foreach (Operation op in serviceInterfaceContract.OperationsCollection) { FxOperation tempOperation = new FxOperation(); tempOperation.Name = op.Name; tempOperation.Documentation = op.Documentation; int i = 0; OperationInput operationInput = new OperationInput(); operationInput.Message = new XmlQualifiedName(op.MessagesCollection[i].Name, desc.TargetNamespace); tempOperation.Messages.Add(operationInput); if (op.Mep == Mep.RequestResponse) { OperationOutput operationOutput = new OperationOutput(); operationOutput.Message = new XmlQualifiedName(op.MessagesCollection[i + 1].Name, desc.TargetNamespace); tempOperation.Messages.Add(operationOutput); } foreach (Message fault in op.Faults) { OperationFault operationFault = new OperationFault(); operationFault.Name = fault.Name; operationFault.Message = new XmlQualifiedName(fault.Name, desc.TargetNamespace); tempOperation.Faults.Add(operationFault); } portType.Operations.Add(tempOperation); i++; } portTypes.Add(portType); #endregion // Here we have a list of WCF endpoints. // Currently we populate this list with only two endpoints that has default // BasicHttpBinding and default NetTcpBinding. List<ServiceEndpoint> endpoints = new List<ServiceEndpoint>(); BasicHttpBinding basicHttpBinding = new BasicHttpBinding(); endpoints.Add(ServiceEndpointFactory<IDummyContract>.CreateServiceEndpoint(basicHttpBinding)); // BDS (10/22/2007): Commented out the TCP binding generation as we are not going to support this feature // in this version. //NetTcpBinding netTcpBinding = new NetTcpBinding(); //endpoints.Add(ServiceEndpointFactory<IDummyContract>.CreateServiceEndpoint(netTcpBinding)); // Now, for each endpoint we have to create a binding in our service description. foreach (ServiceEndpoint endpoint in endpoints) { // Create a WSDL BindingCollection. BindingCollection bindings = desc.Bindings; System.Web.Services.Description.Binding binding = new System.Web.Services.Description.Binding(); binding.Name = endpoint.Name.Replace(Constants.InternalContractName, portTypeName); binding.Type = new XmlQualifiedName(portType.Name, desc.TargetNamespace); // Create Operation binding for each operation and add it the the BindingCollection. foreach (Operation op in serviceInterfaceContract.OperationsCollection) { // SOAP 1.1 Operation bindings. OperationBinding operationBinding1 = new OperationBinding(); operationBinding1.Name = op.Name; InputBinding inputBinding1 = new InputBinding(); object bodyBindingExtension = GetSoapBodyBinding(endpoint.Binding); if (bodyBindingExtension != null) { inputBinding1.Extensions.Add(bodyBindingExtension); } operationBinding1.Input = inputBinding1; // Faults. foreach (Message fault in op.Faults) { FaultBinding faultBinding = new FaultBinding(); faultBinding.Name = fault.Name; SoapFaultBinding faultBindingExtension = GetFaultBodyBinding(endpoint.Binding); if (faultBindingExtension != null) { faultBindingExtension.Name = fault.Name; faultBinding.Extensions.Add(faultBindingExtension); } operationBinding1.Faults.Add(faultBinding); } // Input message. // Look up the message headers for each Message and add them to the current binding. foreach (MessageHeader inHeader in op.MessagesCollection[0].HeadersCollection) { object headerBindingExtension = GetSoapHeaderBinding(endpoint.Binding, inHeader.Message, desc.TargetNamespace); if (headerBindingExtension != null) { inputBinding1.Extensions.Add(headerBindingExtension); } } if (op.Mep == Mep.RequestResponse) { // Output message. OutputBinding outputBinding1 = new OutputBinding(); object responseBodyBindingExtension = GetSoapBodyBinding(endpoint.Binding); if (responseBodyBindingExtension != null) { outputBinding1.Extensions.Add(responseBodyBindingExtension); } operationBinding1.Output = outputBinding1; // Look up the message headers for each Message and add them to the current binding. foreach (MessageHeader outHeader in op.MessagesCollection[1].HeadersCollection) { object headerBindingExtension = GetSoapHeaderBinding(endpoint.Binding, outHeader.Message, desc.TargetNamespace); if (headerBindingExtension != null) { outputBinding1.Extensions.Add(headerBindingExtension); } } } string action = desc.TargetNamespace + ":" + op.Input.Name; object operationBindingExtension = GetSoapOperationBinding(endpoint.Binding, action); if (operationBindingExtension != null) { operationBinding1.Extensions.Add(operationBindingExtension); } binding.Operations.Add(operationBinding1); // End of SOAP 1.1 operation bindings. } object soapBindingExtension = GetSoapBinding(endpoint.Binding); if (soapBindingExtension != null) { binding.Extensions.Add(soapBindingExtension); } bindings.Add(binding); } // Generate <service> element optionally - sometimes necessary for interop reasons if (serviceInterfaceContract.NeedsServiceElement) { Service defaultService = null; if (wsdlLocation == null || desc.Services.Count == 0) { // Create a new service element. defaultService = new Service(); defaultService.Name = serviceName; foreach (ServiceEndpoint endpoint in endpoints) { if (endpoint.Binding.MessageVersion.Envelope == EnvelopeVersion.Soap11) { Port defaultPort = new Port(); defaultPort.Name = serviceInterfaceContract.ServiceName + "Port"; defaultPort.Binding = new XmlQualifiedName(endpoint.Name.Replace(Constants.InternalContractName, portTypeName), desc.TargetNamespace); SoapAddressBinding defaultSoapAddressBinding = new SoapAddressBinding(); defaultSoapAddressBinding.Location = GetDefaultEndpoint(endpoint.Binding, serviceInterfaceContract.ServiceName); defaultPort.Extensions.Add(defaultSoapAddressBinding); defaultService.Ports.Add(defaultPort); } else if (endpoint.Binding.MessageVersion.Envelope == EnvelopeVersion.Soap12) { Port soap12Port = new Port(); soap12Port.Name = serviceInterfaceContract.ServiceName + "SOAP12Port"; soap12Port.Binding = new XmlQualifiedName(endpoint.Name.Replace(Constants.InternalContractName, portTypeName), desc.TargetNamespace); Soap12AddressBinding soap12AddressBinding = new Soap12AddressBinding(); soap12AddressBinding.Location = GetDefaultEndpoint(endpoint.Binding, serviceInterfaceContract.ServiceName); soap12Port.Extensions.Add(soap12AddressBinding); defaultService.Ports.Add(soap12Port); } } desc.Services.Add(defaultService); } else { defaultService = desc.Services[0]; defaultService.Name = serviceName; } } // Generate the WSDL file. string fileName = string.Empty; string bkFileName = string.Empty; // Overwrite the existing file if one specified. if (wsdlLocation == null) { fileName = wsdlSaveLocation + @"\" + serviceInterfaceContract.ServiceName + ".wsdl"; } else { fileName = wsdlLocation; } // Backup existing file before proceeding. if (File.Exists(fileName)) { int index = 1; // Create the backup file name. // See whether the generated backup file name is already taken by an existing file and // generate a new file name. while (File.Exists(fileName + "." + index.ToString())) { index++; } bkFileName = fileName + "." + index.ToString(); // Backup the file. try { File.Copy(fileName, bkFileName); } catch (Exception ex) { throw new WsdlGenerationException("An error occured while trying to generate a WSDL. Failed to backup the existing WSDL file.", ex); } } StreamWriter writer1 = new StreamWriter(fileName); try { XmlTextWriter writer11 = new XmlTextWriter(writer1); writer11.Formatting = Formatting.Indented; writer11.Indentation = 2; writer11.WriteComment(xmlComment); // BDS: Added a new comment line with the date time of WSDL file. CultureInfo ci = new CultureInfo("en-US"); writer11.WriteComment(DateTime.Now.ToString("dddd", ci) + ", " + DateTime.Now.ToString("dd-MM-yyyy - hh:mm tt", ci)); XmlSerializer serializer1 = System.Web.Services.Description.ServiceDescription.Serializer; XmlSerializerNamespaces nsSer = new XmlSerializerNamespaces(); nsSer.Add("soap", "http://schemas.xmlsoap.org/wsdl/soap/"); nsSer.Add("soap12", "http://schemas.xmlsoap.org/wsdl/soap12/"); nsSer.Add("xsd", "http://www.w3.org/2001/XMLSchema"); nsSer.Add("tns", desc.TargetNamespace); // Add the imported namespaces to the WSDL <description> element. for (int importIndex = 0; importIndex < serviceInterfaceContract.Imports.Count; importIndex++) { if (serviceInterfaceContract.Imports[importIndex].SchemaNamespace != null && serviceInterfaceContract.Imports[importIndex].SchemaNamespace != "") { nsSer.Add("import" + importIndex.ToString(), serviceInterfaceContract.Imports[importIndex].SchemaNamespace); } } // // Finally write the file to the output stram. serializer1.Serialize(writer11, desc, nsSer); // Close the stream and delete the backupfile. writer1.Close(); if (bkFileName != string.Empty) { File.Delete(bkFileName); } WsdlWorkshop workshop = new WsdlWorkshop(endpoints, fileName, portTypeName); workshop.BuildWsdl(); return fileName; } catch (Exception ex) { writer1.Close(); string message = ex.Message; if (ex.InnerException != null) { message += ex.InnerException.Message; } // Restore the original file. if (bkFileName != string.Empty) { try { File.Copy(bkFileName, fileName, true); File.Delete(bkFileName); } catch { throw new WsdlGenerationException( message + "\nFailed to restore the original file."); } } else if (File.Exists(fileName)) { File.Delete(fileName); } throw new WsdlGenerationException( message, ex); } }