You've already forked linux-packaging-mono
2239 lines
104 KiB
C#
2239 lines
104 KiB
C#
|
//-----------------------------------------------------------------------------
|
||
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
||
|
|
//-----------------------------------------------------------------------------
|
||
|
|
namespace System.ServiceModel.Description
|
||
|
|
{
|
||
|
|
using System;
|
||
|
|
using System.CodeDom;
|
||
|
|
using System.CodeDom.Compiler;
|
||
|
|
using System.Collections;
|
||
|
|
using System.Collections.Generic;
|
||
|
|
using System.Collections.ObjectModel;
|
||
|
|
using System.Diagnostics;
|
||
|
|
using System.IO;
|
||
|
|
using System.Runtime;
|
||
|
|
using System.Runtime.Diagnostics;
|
||
|
|
using System.Runtime.Serialization;
|
||
|
|
using System.ServiceModel;
|
||
|
|
using System.ServiceModel.Channels;
|
||
|
|
using System.ServiceModel.Diagnostics;
|
||
|
|
using System.Xml;
|
||
|
|
using System.Xml.Schema;
|
||
|
|
using System.Xml.Serialization;
|
||
|
|
using WsdlNS = System.Web.Services.Description;
|
||
|
|
|
||
|
|
class MessageContractImporter
|
||
|
|
{
|
||
|
|
static readonly XmlQualifiedName AnyType = new XmlQualifiedName("anyType", XmlSchema.Namespace);
|
||
|
|
|
||
|
|
readonly XmlSchemaSet allSchemas;
|
||
|
|
readonly WsdlContractConversionContext contractContext;
|
||
|
|
readonly WsdlImporter importer;
|
||
|
|
SchemaImporter schemaImporter;
|
||
|
|
readonly FaultImportOptions faultImportOptions;
|
||
|
|
|
||
|
|
static object schemaImporterLock = new object();
|
||
|
|
|
||
|
|
Dictionary<WsdlNS.Message, IList<string>> bodyPartsTable;
|
||
|
|
|
||
|
|
Dictionary<WsdlNS.Message, IList<string>> BodyPartsTable
|
||
|
|
{
|
||
|
|
get
|
||
|
|
{
|
||
|
|
if (bodyPartsTable == null)
|
||
|
|
bodyPartsTable = new Dictionary<WsdlNS.Message, IList<string>>();
|
||
|
|
return bodyPartsTable;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static internal void ImportMessageBinding(WsdlImporter importer, WsdlEndpointConversionContext endpointContext, Type schemaImporterType)
|
||
|
|
{
|
||
|
|
// All the work is done in ImportMessageContract call
|
||
|
|
bool isReferencedContract = IsReferencedContract(importer, endpointContext);
|
||
|
|
|
||
|
|
MarkSoapExtensionsAsHandled(endpointContext.WsdlBinding);
|
||
|
|
|
||
|
|
foreach (WsdlNS.OperationBinding wsdlOperationBinding in endpointContext.WsdlBinding.Operations)
|
||
|
|
{
|
||
|
|
OperationDescription operation = endpointContext.GetOperationDescription(wsdlOperationBinding);
|
||
|
|
if (isReferencedContract || OperationHasBeenHandled(operation))
|
||
|
|
{
|
||
|
|
MarkSoapExtensionsAsHandled(wsdlOperationBinding);
|
||
|
|
|
||
|
|
if (wsdlOperationBinding.Input != null)
|
||
|
|
{
|
||
|
|
MarkSoapExtensionsAsHandled(wsdlOperationBinding.Input);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (wsdlOperationBinding.Output != null)
|
||
|
|
{
|
||
|
|
MarkSoapExtensionsAsHandled(wsdlOperationBinding.Output);
|
||
|
|
}
|
||
|
|
|
||
|
|
foreach (WsdlNS.MessageBinding wsdlMessageBinding in wsdlOperationBinding.Faults)
|
||
|
|
{
|
||
|
|
MarkSoapExtensionsAsHandled(wsdlMessageBinding);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool OperationHasBeenHandled(OperationDescription operation)
|
||
|
|
{
|
||
|
|
return (operation.Behaviors.Find<IOperationContractGenerationExtension>() != null);
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool IsReferencedContract(WsdlImporter importer, WsdlEndpointConversionContext endpointContext)
|
||
|
|
{
|
||
|
|
return importer.KnownContracts.ContainsValue(endpointContext.Endpoint.Contract);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void MarkSoapExtensionsAsHandled(WsdlNS.NamedItem item)
|
||
|
|
{
|
||
|
|
foreach (object o in item.Extensions)
|
||
|
|
{
|
||
|
|
WsdlNS.ServiceDescriptionFormatExtension ext = o as WsdlNS.ServiceDescriptionFormatExtension;
|
||
|
|
if (ext != null && IsSoapBindingExtension(ext))
|
||
|
|
ext.Handled = true;
|
||
|
|
else if (SoapHelper.IsSoapFaultBinding(o as XmlElement))
|
||
|
|
ext.Handled = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool IsSoapBindingExtension(WsdlNS.ServiceDescriptionFormatExtension ext)
|
||
|
|
{
|
||
|
|
if (ext is WsdlNS.SoapBinding
|
||
|
|
|| ext is WsdlNS.SoapBodyBinding
|
||
|
|
|| ext is WsdlNS.SoapHeaderBinding
|
||
|
|
|| ext is WsdlNS.SoapOperationBinding
|
||
|
|
|| ext is WsdlNS.SoapFaultBinding
|
||
|
|
|| ext is WsdlNS.SoapHeaderFaultBinding
|
||
|
|
)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
static internal void ImportMessageContract(WsdlImporter importer, WsdlContractConversionContext contractContext, SchemaImporter schemaImporter)
|
||
|
|
{
|
||
|
|
new MessageContractImporter(importer, contractContext, schemaImporter).ImportMessageContract();
|
||
|
|
}
|
||
|
|
|
||
|
|
MessageContractImporter(WsdlImporter importer, WsdlContractConversionContext contractContext, SchemaImporter schemaImporter)
|
||
|
|
{
|
||
|
|
this.contractContext = contractContext;
|
||
|
|
this.importer = importer;
|
||
|
|
this.allSchemas = GatherSchemas(importer);
|
||
|
|
this.schemaImporter = schemaImporter;
|
||
|
|
|
||
|
|
object faultImportOptions;
|
||
|
|
if (this.importer.State.TryGetValue(typeof(FaultImportOptions), out faultImportOptions))
|
||
|
|
this.faultImportOptions = (FaultImportOptions)faultImportOptions;
|
||
|
|
else
|
||
|
|
this.faultImportOptions = new FaultImportOptions();
|
||
|
|
}
|
||
|
|
|
||
|
|
XmlSchemaSet AllSchemas
|
||
|
|
{
|
||
|
|
get { return this.allSchemas; }
|
||
|
|
}
|
||
|
|
|
||
|
|
SchemaImporter CurrentSchemaImporter
|
||
|
|
{
|
||
|
|
get { return schemaImporter; }
|
||
|
|
}
|
||
|
|
|
||
|
|
internal void AddWarning(string message)
|
||
|
|
{
|
||
|
|
AddError(message, true);
|
||
|
|
}
|
||
|
|
|
||
|
|
void AddError(string message)
|
||
|
|
{
|
||
|
|
AddError(message, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
void AddError(string message, bool isWarning)
|
||
|
|
{
|
||
|
|
MetadataConversionError warning = new MetadataConversionError(message, isWarning);
|
||
|
|
if (!importer.Errors.Contains(warning))
|
||
|
|
importer.Errors.Add(warning);
|
||
|
|
}
|
||
|
|
|
||
|
|
void TraceImportInformation(OperationDescription operation)
|
||
|
|
{
|
||
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
||
|
|
{
|
||
|
|
Dictionary<String, String> ht = new Dictionary<string, string>(2)
|
||
|
|
{
|
||
|
|
{ "Operation", operation.Name },
|
||
|
|
{ "Format", CurrentSchemaImporter.GetFormatName() }
|
||
|
|
};
|
||
|
|
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.CannotBeImportedInCurrentFormat,
|
||
|
|
SR.GetString(SR.TraceCodeCannotBeImportedInCurrentFormat), new DictionaryTraceRecord(ht), null, null);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ImportMessageContract()
|
||
|
|
{
|
||
|
|
if (contractContext.Contract.Operations.Count <= 0)
|
||
|
|
return;
|
||
|
|
CurrentSchemaImporter.PreprocessSchema();
|
||
|
|
|
||
|
|
bool importerUsed = true;
|
||
|
|
|
||
|
|
OperationInfo[] infos = new OperationInfo[contractContext.Contract.Operations.Count];
|
||
|
|
int i = 0;
|
||
|
|
foreach (OperationDescription operation in contractContext.Contract.Operations)
|
||
|
|
{
|
||
|
|
OperationInfo operationInfo;
|
||
|
|
if (!CanImportOperation(operation, out operationInfo))
|
||
|
|
{
|
||
|
|
TraceImportInformation(operation);
|
||
|
|
importerUsed = false;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
infos[i++] = operationInfo;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (importerUsed)
|
||
|
|
{
|
||
|
|
i = 0;
|
||
|
|
foreach (OperationDescription operation in contractContext.Contract.Operations)
|
||
|
|
{
|
||
|
|
ImportOperationContract(operation, infos[i++]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
CurrentSchemaImporter.PostprocessSchema(importerUsed);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CanImportOperation(OperationDescription operation, out OperationInfo operationInfo)
|
||
|
|
{
|
||
|
|
operationInfo = null;
|
||
|
|
if (OperationHasBeenHandled(operation))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
WsdlNS.Operation wsdlOperation = contractContext.GetOperation(operation);
|
||
|
|
Collection<WsdlNS.OperationBinding> wsdlOperationBindings = contractContext.GetOperationBindings(wsdlOperation);
|
||
|
|
|
||
|
|
return CanImportOperation(operation, wsdlOperation, wsdlOperationBindings, out operationInfo)
|
||
|
|
&& CanImportFaults(wsdlOperation, operation);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CanImportFaults(WsdlNS.Operation operation, OperationDescription description)
|
||
|
|
{
|
||
|
|
// When this.faultImportOptions.UseMessageFormat is false, we fall back to the V1 behavior of using DataContractSerializer to import all faults.
|
||
|
|
// We can, therefore, return true in those cases without actually doing the checks involved in CanImportFaults.
|
||
|
|
if (!this.faultImportOptions.UseMessageFormat)
|
||
|
|
return true;
|
||
|
|
|
||
|
|
foreach (WsdlNS.OperationFault fault in operation.Faults)
|
||
|
|
{
|
||
|
|
if (!CanImportFault(fault, description))
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CanImportFault(WsdlNS.OperationFault fault, OperationDescription description)
|
||
|
|
{
|
||
|
|
XmlSchemaElement detailElement;
|
||
|
|
XmlQualifiedName detailElementTypeName;
|
||
|
|
XmlQualifiedName detailElementQname;
|
||
|
|
|
||
|
|
if (!ValidateFault(fault, description, out detailElement, out detailElementTypeName, out detailElementQname))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
return this.CurrentSchemaImporter.CanImportFault(detailElement, detailElementTypeName);
|
||
|
|
}
|
||
|
|
|
||
|
|
void ImportOperationContract(OperationDescription operation, OperationInfo operationInfo)
|
||
|
|
{
|
||
|
|
Fx.Assert(!OperationHasBeenHandled(operation), "");
|
||
|
|
Fx.Assert(operationInfo != null, "");
|
||
|
|
|
||
|
|
WsdlNS.Operation wsdlOperation = contractContext.GetOperation(operation);
|
||
|
|
Collection<WsdlNS.OperationBinding> wsdlOperationBindings = contractContext.GetOperationBindings(wsdlOperation);
|
||
|
|
|
||
|
|
bool isReply = false;
|
||
|
|
foreach (WsdlNS.OperationMessage operationMessage in wsdlOperation.Messages)
|
||
|
|
{
|
||
|
|
ImportMessage(operationMessage, isReply, operationInfo.IsEncoded, operationInfo.AreAllMessagesWrapped);
|
||
|
|
isReply = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (operationInfo.Style == OperationFormatStyle.Rpc)
|
||
|
|
SetWrapperName(operation);
|
||
|
|
this.CurrentSchemaImporter.SetOperationStyle(operation, operationInfo.Style);
|
||
|
|
this.CurrentSchemaImporter.SetOperationIsEncoded(operation, operationInfo.IsEncoded);
|
||
|
|
this.CurrentSchemaImporter.SetOperationSupportFaults(operation,
|
||
|
|
this.faultImportOptions.UseMessageFormat);
|
||
|
|
|
||
|
|
ImportFaults(wsdlOperation, operation, operationInfo.IsEncoded);
|
||
|
|
|
||
|
|
foreach (WsdlNS.OperationBinding wsdlOperationBinding in wsdlOperationBindings)
|
||
|
|
{
|
||
|
|
foreach (MessageDescription message in operation.Messages)
|
||
|
|
{
|
||
|
|
WsdlNS.OperationMessage wsdlOperationMessage = contractContext.GetOperationMessage(message);
|
||
|
|
WsdlNS.ServiceDescriptionCollection wsdlDocuments = wsdlOperationMessage.Operation.PortType.ServiceDescription.ServiceDescriptions;
|
||
|
|
WsdlNS.Message wsdlMessage = wsdlDocuments.GetMessage(wsdlOperationMessage.Message);
|
||
|
|
|
||
|
|
WsdlNS.MessageBinding messageBinding = (message.Direction == MessageDirection.Input)
|
||
|
|
? (WsdlNS.MessageBinding)wsdlOperationBinding.Input
|
||
|
|
: (WsdlNS.MessageBinding)wsdlOperationBinding.Output;
|
||
|
|
|
||
|
|
if (messageBinding != null)
|
||
|
|
ImportMessageBinding(messageBinding, wsdlMessage, message, operationInfo.Style, operationInfo.IsEncoded);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
operation.Behaviors.Add(CurrentSchemaImporter.GetOperationGenerator());
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CanImportOperation(OperationDescription operation, WsdlNS.Operation wsdlOperation, Collection<WsdlNS.OperationBinding> operationBindings,
|
||
|
|
out OperationInfo operationInfo)
|
||
|
|
{
|
||
|
|
operationInfo = null;
|
||
|
|
OperationFormatStyle style = OperationFormatStyle.Document;
|
||
|
|
bool isEncoded = false;
|
||
|
|
bool areAllMessagesWrapped = true;
|
||
|
|
|
||
|
|
// Check if operation bindings can be imported
|
||
|
|
|
||
|
|
StyleAndUse? styleAndUse = null;
|
||
|
|
WsdlNS.ServiceDescriptionCollection documents = wsdlOperation.PortType.ServiceDescription.ServiceDescriptions;
|
||
|
|
WsdlNS.OperationBinding prevOperationBinding = null;
|
||
|
|
foreach (WsdlNS.OperationBinding operationBinding in operationBindings)
|
||
|
|
{
|
||
|
|
OperationFormatStyle operationStyle = GetStyle(operationBinding);
|
||
|
|
bool? isOperationEncoded = null;
|
||
|
|
foreach (MessageDescription message in operation.Messages)
|
||
|
|
{
|
||
|
|
WsdlNS.OperationMessage operationMessage = contractContext.GetOperationMessage(message);
|
||
|
|
|
||
|
|
if (operationMessage.Message.IsEmpty)
|
||
|
|
{
|
||
|
|
if (operationMessage is WsdlNS.OperationInput)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxWsdlOperationInputNeedsMessageAttribute2, wsdlOperation.Name, wsdlOperation.PortType.Name)));
|
||
|
|
if (operationMessage is WsdlNS.OperationOutput)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxWsdlOperationOutputNeedsMessageAttribute2, wsdlOperation.Name, wsdlOperation.PortType.Name)));
|
||
|
|
}
|
||
|
|
WsdlNS.Message wsdlMessage = documents.GetMessage(operationMessage.Message);
|
||
|
|
|
||
|
|
if (wsdlMessage != null)
|
||
|
|
{
|
||
|
|
WsdlNS.MessageBinding messageBinding = (message.Direction == MessageDirection.Input)
|
||
|
|
? (WsdlNS.MessageBinding)operationBinding.Input
|
||
|
|
: (WsdlNS.MessageBinding)operationBinding.Output;
|
||
|
|
|
||
|
|
if (messageBinding != null)
|
||
|
|
{
|
||
|
|
bool isMessageEncoded;
|
||
|
|
if (!CanImportMessageBinding(messageBinding, wsdlMessage, operationStyle, out isMessageEncoded))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
if (isOperationEncoded == null)
|
||
|
|
isOperationEncoded = isMessageEncoded;
|
||
|
|
else if (isOperationEncoded != isMessageEncoded)
|
||
|
|
AddError(SR.GetString(SR.SFxInconsistentWsdlOperationUseInBindingMessages, messageBinding.OperationBinding.Name, messageBinding.OperationBinding.Binding.Name));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
foreach (WsdlNS.FaultBinding faultBinding in operationBinding.Faults)
|
||
|
|
{
|
||
|
|
bool isFaultEncoded;
|
||
|
|
if (!CanImportFaultBinding(faultBinding, operationStyle, out isFaultEncoded))
|
||
|
|
return false;
|
||
|
|
if (isOperationEncoded == null)
|
||
|
|
isOperationEncoded = isFaultEncoded;
|
||
|
|
else if (isOperationEncoded != isFaultEncoded)
|
||
|
|
AddError(SR.GetString(SR.SFxInconsistentWsdlOperationUseInBindingFaults, faultBinding.OperationBinding.Name, faultBinding.OperationBinding.Binding.Name));
|
||
|
|
}
|
||
|
|
isOperationEncoded = isOperationEncoded ?? false;
|
||
|
|
|
||
|
|
if (styleAndUse == null)
|
||
|
|
{
|
||
|
|
styleAndUse = GetStyleAndUse(operationStyle, isOperationEncoded.Value);
|
||
|
|
style = operationStyle;
|
||
|
|
isEncoded = isOperationEncoded.Value;
|
||
|
|
prevOperationBinding = operationBinding;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
StyleAndUse operationStyleAndUse = GetStyleAndUse(operationStyle, isOperationEncoded.Value);
|
||
|
|
if (operationStyleAndUse != styleAndUse)
|
||
|
|
{
|
||
|
|
AddError(SR.GetString(SR.SFxInconsistentWsdlOperationUseAndStyleInBinding,
|
||
|
|
operation.Name, operationBinding.Binding.Name, GetUse(operationStyleAndUse), GetStyle(operationStyleAndUse),
|
||
|
|
prevOperationBinding.Binding.Name, GetUse(styleAndUse.Value), GetStyle(styleAndUse.Value)));
|
||
|
|
}
|
||
|
|
if (operationStyleAndUse < styleAndUse)
|
||
|
|
{
|
||
|
|
styleAndUse = operationStyleAndUse;
|
||
|
|
style = operationStyle;
|
||
|
|
isEncoded = isOperationEncoded.Value;
|
||
|
|
prevOperationBinding = operationBinding;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check if operation can be imported
|
||
|
|
OperationFormatStyle? inferredOperationStyle = null;
|
||
|
|
foreach (WsdlNS.OperationMessage wsdlOperationMessage in wsdlOperation.Messages)
|
||
|
|
{
|
||
|
|
if (wsdlOperationMessage.Message.IsEmpty)
|
||
|
|
{
|
||
|
|
if (wsdlOperationMessage is WsdlNS.OperationInput)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxWsdlOperationInputNeedsMessageAttribute2, wsdlOperation.Name, wsdlOperation.PortType.Name)));
|
||
|
|
if (wsdlOperationMessage is WsdlNS.OperationOutput)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxWsdlOperationOutputNeedsMessageAttribute2, wsdlOperation.Name, wsdlOperation.PortType.Name)));
|
||
|
|
}
|
||
|
|
WsdlNS.Message wsdlMessage = documents.GetMessage(wsdlOperationMessage.Message);
|
||
|
|
|
||
|
|
OperationFormatStyle? inferredMessageStyle;
|
||
|
|
if (!CanImportMessage(wsdlMessage, wsdlOperationMessage.Name, out inferredMessageStyle, ref areAllMessagesWrapped))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
if (wsdlMessage.Parts.Count > 0)
|
||
|
|
{
|
||
|
|
if (inferredOperationStyle == null
|
||
|
|
|| (inferredMessageStyle != null
|
||
|
|
&& inferredMessageStyle != inferredOperationStyle
|
||
|
|
&& inferredMessageStyle.Value == OperationFormatStyle.Document))
|
||
|
|
{
|
||
|
|
inferredOperationStyle = inferredMessageStyle;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Verify that information in operation bindings and operation match
|
||
|
|
if (styleAndUse == null)
|
||
|
|
style = inferredOperationStyle ?? OperationFormatStyle.Document;
|
||
|
|
else if (inferredOperationStyle != null)
|
||
|
|
{
|
||
|
|
if (inferredOperationStyle.Value != style && inferredOperationStyle.Value == OperationFormatStyle.Document)
|
||
|
|
AddError(SR.GetString(SR.SFxInconsistentWsdlOperationStyleInOperationMessages, operation.Name, inferredOperationStyle, style));
|
||
|
|
}
|
||
|
|
operationInfo = new OperationInfo(style, isEncoded, areAllMessagesWrapped);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CanImportMessage(WsdlNS.Message wsdlMessage, string operationName, out OperationFormatStyle? inferredStyle, ref bool areAllMessagesWrapped)
|
||
|
|
{
|
||
|
|
WsdlNS.MessagePartCollection messageParts = wsdlMessage.Parts;
|
||
|
|
// try the special cases: wrapped and Message
|
||
|
|
if (messageParts.Count == 1)
|
||
|
|
{
|
||
|
|
if (CanImportAnyMessage(messageParts[0]))
|
||
|
|
{
|
||
|
|
areAllMessagesWrapped = false;
|
||
|
|
inferredStyle = OperationFormatStyle.Document;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (CanImportStream(messageParts[0], out inferredStyle, ref areAllMessagesWrapped))
|
||
|
|
return true;
|
||
|
|
|
||
|
|
if (areAllMessagesWrapped && CanImportWrappedMessage(messageParts[0]))
|
||
|
|
{
|
||
|
|
inferredStyle = OperationFormatStyle.Document;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
areAllMessagesWrapped = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
inferredStyle = null;
|
||
|
|
IList<string> bodyPartsFromBindings;
|
||
|
|
BodyPartsTable.TryGetValue(wsdlMessage, out bodyPartsFromBindings);
|
||
|
|
foreach (WsdlNS.MessagePart part in messageParts)
|
||
|
|
{
|
||
|
|
if (bodyPartsFromBindings != null && !bodyPartsFromBindings.Contains(part.Name))
|
||
|
|
continue;
|
||
|
|
OperationFormatStyle style;
|
||
|
|
if (!CurrentSchemaImporter.CanImportMessagePart(part, out style))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
if (inferredStyle == null)
|
||
|
|
inferredStyle = style;
|
||
|
|
else if (style != inferredStyle.Value)
|
||
|
|
AddError(SR.GetString(SR.SFxInconsistentWsdlOperationStyleInMessageParts, operationName));
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ImportMessage(WsdlNS.OperationMessage wsdlOperationMessage, bool isReply, bool isEncoded, bool areAllMessagesWrapped)
|
||
|
|
{
|
||
|
|
MessageDescription messageDescription = contractContext.GetMessageDescription(wsdlOperationMessage);
|
||
|
|
OperationDescription operation = contractContext.GetOperationDescription(wsdlOperationMessage.Operation);
|
||
|
|
WsdlNS.ServiceDescriptionCollection wsdlDocuments = wsdlOperationMessage.Operation.PortType.ServiceDescription.ServiceDescriptions;
|
||
|
|
WsdlNS.Message wsdlMessage = wsdlDocuments.GetMessage(wsdlOperationMessage.Message);
|
||
|
|
|
||
|
|
if (wsdlMessage.Parts.Count == 1)
|
||
|
|
{
|
||
|
|
if (TryImportAnyMessage(wsdlMessage.Parts[0], messageDescription, isReply))
|
||
|
|
return;
|
||
|
|
if (TryImportStream(wsdlMessage.Parts[0], messageDescription, isReply, areAllMessagesWrapped))
|
||
|
|
return;
|
||
|
|
if (areAllMessagesWrapped && TryImportWrappedMessage(messageDescription, operation.Messages[0], wsdlMessage, isReply))
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
WsdlNS.MessagePartCollection messageParts = wsdlMessage.Parts;
|
||
|
|
IList<string> bodyPartsFromBindings;
|
||
|
|
BodyPartsTable.TryGetValue(wsdlMessage, out bodyPartsFromBindings);
|
||
|
|
string[] parameterOrder = wsdlOperationMessage.Operation.ParameterOrder;
|
||
|
|
|
||
|
|
foreach (WsdlNS.MessagePart part in messageParts)
|
||
|
|
{
|
||
|
|
if (!ValidWsdl.Check(part, wsdlMessage, AddWarning))
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if (bodyPartsFromBindings != null && !bodyPartsFromBindings.Contains(part.Name))
|
||
|
|
continue;
|
||
|
|
bool isReturn = false;
|
||
|
|
if (parameterOrder != null && isReply)
|
||
|
|
isReturn = Array.IndexOf<string>(parameterOrder, part.Name) == -1;
|
||
|
|
MessagePartDescription partDesc = CurrentSchemaImporter.ImportMessagePart(part, false/*isHeader*/, isEncoded);
|
||
|
|
if (isReturn && messageDescription.Body.ReturnValue == null)
|
||
|
|
messageDescription.Body.ReturnValue = partDesc;
|
||
|
|
else
|
||
|
|
messageDescription.Body.Parts.Add(partDesc);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (isReply && messageDescription.Body.ReturnValue == null)
|
||
|
|
{
|
||
|
|
if (messageDescription.Body.Parts.Count > 0)
|
||
|
|
{
|
||
|
|
if (!CheckIsRef(operation.Messages[0], messageDescription.Body.Parts[0]))
|
||
|
|
{
|
||
|
|
messageDescription.Body.ReturnValue = messageDescription.Body.Parts[0];
|
||
|
|
messageDescription.Body.Parts.RemoveAt(0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
enum StyleAndUse
|
||
|
|
{
|
||
|
|
DocumentLiteral,
|
||
|
|
RpcLiteral,
|
||
|
|
RpcEncoded,
|
||
|
|
DocumentEncoded,
|
||
|
|
}
|
||
|
|
|
||
|
|
static StyleAndUse GetStyleAndUse(OperationFormatStyle style, bool isEncoded)
|
||
|
|
{
|
||
|
|
if (style == OperationFormatStyle.Document)
|
||
|
|
{
|
||
|
|
return isEncoded ? StyleAndUse.DocumentEncoded : StyleAndUse.DocumentLiteral;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return isEncoded ? StyleAndUse.RpcEncoded : StyleAndUse.RpcLiteral;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static string GetStyle(StyleAndUse styleAndUse)
|
||
|
|
{
|
||
|
|
return (styleAndUse == StyleAndUse.RpcLiteral || styleAndUse == StyleAndUse.RpcEncoded) ? "rpc" : "document";
|
||
|
|
}
|
||
|
|
|
||
|
|
static string GetUse(StyleAndUse styleAndUse)
|
||
|
|
{
|
||
|
|
return (styleAndUse == StyleAndUse.RpcEncoded || styleAndUse == StyleAndUse.DocumentEncoded) ? "encoded" : "literal";
|
||
|
|
}
|
||
|
|
|
||
|
|
static void SetWrapperName(OperationDescription operation)
|
||
|
|
{
|
||
|
|
MessageDescriptionCollection messages = operation.Messages;
|
||
|
|
if (messages != null && messages.Count > 0)
|
||
|
|
{
|
||
|
|
MessageDescription request = messages[0];
|
||
|
|
if (request != null)
|
||
|
|
{
|
||
|
|
request.Body.WrapperName = operation.Name;
|
||
|
|
request.Body.WrapperNamespace = operation.DeclaringContract.Namespace;
|
||
|
|
}
|
||
|
|
if (messages.Count > 1)
|
||
|
|
{
|
||
|
|
MessageDescription response = messages[1];
|
||
|
|
if (response != null)
|
||
|
|
{
|
||
|
|
response.Body.WrapperName = TypeLoader.GetBodyWrapperResponseName(operation.Name).EncodedName;
|
||
|
|
response.Body.WrapperNamespace = operation.DeclaringContract.Namespace;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ImportFaults(WsdlNS.Operation operation, OperationDescription description, bool isEncoded)
|
||
|
|
{
|
||
|
|
foreach (WsdlNS.OperationFault fault in operation.Faults)
|
||
|
|
{
|
||
|
|
ImportFault(fault, description, isEncoded);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ImportFault(WsdlNS.OperationFault fault, OperationDescription description, bool isEncoded)
|
||
|
|
{
|
||
|
|
XmlSchemaElement detailElement;
|
||
|
|
XmlQualifiedName detailElementTypeName;
|
||
|
|
XmlQualifiedName detailElementQname;
|
||
|
|
|
||
|
|
if (!ValidateFault(fault, description, out detailElement, out detailElementTypeName, out detailElementQname))
|
||
|
|
return;
|
||
|
|
|
||
|
|
SchemaImporter faultImporter;
|
||
|
|
if (this.faultImportOptions.UseMessageFormat)
|
||
|
|
faultImporter = this.CurrentSchemaImporter;
|
||
|
|
else
|
||
|
|
faultImporter = DataContractSerializerSchemaImporter.Get(this.importer);
|
||
|
|
CodeTypeReference detailElementTypeRef;
|
||
|
|
if (IsNullOrEmpty(detailElementTypeName))
|
||
|
|
detailElementTypeRef = faultImporter.ImportFaultElement(detailElementQname, detailElement, isEncoded);
|
||
|
|
else
|
||
|
|
detailElementTypeRef = faultImporter.ImportFaultType(detailElementQname, detailElementTypeName, isEncoded);
|
||
|
|
FaultDescription faultDescription = contractContext.GetFaultDescription(fault);
|
||
|
|
faultDescription.DetailTypeReference = detailElementTypeRef;
|
||
|
|
faultDescription.ElementName = new XmlName(detailElementQname.Name, true /*isEncoded*/);
|
||
|
|
faultDescription.Namespace = detailElementQname.Namespace;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ValidateFault(WsdlNS.OperationFault fault, OperationDescription description, out XmlSchemaElement detailElement,
|
||
|
|
out XmlQualifiedName detailElementTypeName, out XmlQualifiedName detailElementQname)
|
||
|
|
{
|
||
|
|
detailElement = null;
|
||
|
|
detailElementTypeName = null;
|
||
|
|
detailElementQname = null;
|
||
|
|
|
||
|
|
// this will throw if the message is not found (consider wrapping exception)
|
||
|
|
WsdlNS.ServiceDescriptionCollection wsdlDocuments = fault.Operation.PortType.ServiceDescription.ServiceDescriptions;
|
||
|
|
|
||
|
|
if (fault.Message.IsEmpty)
|
||
|
|
{
|
||
|
|
TraceFaultCannotBeImported(fault.Name, description.Name, SR.GetString(SR.SFxWsdlOperationFaultNeedsMessageAttribute2, fault.Name, fault.Operation.PortType.Name));
|
||
|
|
description.Faults.Remove(contractContext.GetFaultDescription(fault));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
WsdlNS.Message faultMessage = wsdlDocuments.GetMessage(fault.Message);
|
||
|
|
|
||
|
|
// we only recognize faults with a single part (single element inside detail):
|
||
|
|
if (faultMessage.Parts.Count != 1)
|
||
|
|
{
|
||
|
|
TraceFaultCannotBeImported(fault.Name, description.Name, SR.GetString(SR.UnsupportedWSDLOnlyOneMessage));
|
||
|
|
description.Faults.Remove(contractContext.GetFaultDescription(fault));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
WsdlNS.MessagePart faultMessageDetail = faultMessage.Parts[0];
|
||
|
|
detailElementQname = faultMessageDetail.Element;
|
||
|
|
|
||
|
|
if (IsNullOrEmpty(detailElementQname) || !IsNullOrEmpty(faultMessageDetail.Type))
|
||
|
|
{
|
||
|
|
TraceFaultCannotBeImported(fault.Name, description.Name, SR.GetString(SR.UnsupportedWSDLTheFault));
|
||
|
|
description.Faults.Remove(contractContext.GetFaultDescription(fault));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
detailElement = FindSchemaElement(this.AllSchemas, detailElementQname);
|
||
|
|
detailElementTypeName = GetTypeName(detailElement);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CanImportAnyMessage(WsdlNS.MessagePart part)
|
||
|
|
{
|
||
|
|
return CheckPart(part.Type, DataContractSerializerMessageContractImporter.GenericMessageTypeName);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool TryImportAnyMessage(WsdlNS.MessagePart part, MessageDescription description, bool isReply)
|
||
|
|
{
|
||
|
|
return CheckAndAddPart(part.Type, DataContractSerializerMessageContractImporter.GenericMessageTypeName, part.Name, string.Empty, typeof(Message), description, isReply);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CanImportStream(WsdlNS.MessagePart part, out OperationFormatStyle? style, ref bool areAllMessagesWrapped)
|
||
|
|
{
|
||
|
|
style = OperationFormatStyle.Document;
|
||
|
|
string ns;
|
||
|
|
XmlSchemaForm elementFormDefault;
|
||
|
|
if (areAllMessagesWrapped && IsWrapperPart(part))
|
||
|
|
{
|
||
|
|
XmlSchemaComplexType complexType = GetElementComplexType(part.Element, allSchemas, out ns, out elementFormDefault);
|
||
|
|
if (complexType != null)
|
||
|
|
{
|
||
|
|
XmlSchemaSequence rootSequence = GetRootSequence(complexType);
|
||
|
|
if (rootSequence != null && rootSequence.Items.Count == 1 && rootSequence.Items[0] is XmlSchemaElement)
|
||
|
|
return CheckPart(((XmlSchemaElement)rootSequence.Items[0]).SchemaTypeName, DataContractSerializerMessageContractImporter.StreamBodyTypeName);
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
areAllMessagesWrapped = false;
|
||
|
|
XmlQualifiedName typeName = part.Type;
|
||
|
|
style = OperationFormatStyle.Rpc;
|
||
|
|
if (IsNullOrEmpty(typeName))
|
||
|
|
{
|
||
|
|
if (IsNullOrEmpty(part.Element))
|
||
|
|
return false;
|
||
|
|
style = OperationFormatStyle.Document;
|
||
|
|
typeName = GetTypeName(FindSchemaElement(allSchemas, part.Element));
|
||
|
|
}
|
||
|
|
return CheckPart(typeName, DataContractSerializerMessageContractImporter.StreamBodyTypeName);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool TryImportStream(WsdlNS.MessagePart part, MessageDescription description, bool isReply, bool areAllMessagesWrapped)
|
||
|
|
{
|
||
|
|
string ns = string.Empty;
|
||
|
|
XmlSchemaForm elementFormDefault;
|
||
|
|
if (areAllMessagesWrapped && IsWrapperPart(part))
|
||
|
|
{
|
||
|
|
XmlSchemaSequence rootSequence = GetRootSequence(GetElementComplexType(part.Element, allSchemas, out ns, out elementFormDefault));
|
||
|
|
if (rootSequence != null && rootSequence.Items.Count == 1 && rootSequence.Items[0] is XmlSchemaElement)
|
||
|
|
{
|
||
|
|
XmlSchemaElement element = (XmlSchemaElement)rootSequence.Items[0];
|
||
|
|
description.Body.WrapperName = new XmlName(part.Element.Name, true /*isEncoded*/).EncodedName;
|
||
|
|
description.Body.WrapperNamespace = part.Element.Namespace;
|
||
|
|
|
||
|
|
if (element.SchemaTypeName.IsEmpty && element.RefName != null)
|
||
|
|
{
|
||
|
|
return CheckAndAddPart(element.ElementSchemaType.QualifiedName, DataContractSerializerMessageContractImporter.StreamBodyTypeName, element.RefName.Name, GetLocalElementNamespace(element.RefName.Namespace, element, elementFormDefault), typeof(Stream), description, isReply);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return CheckAndAddPart(element.SchemaTypeName, DataContractSerializerMessageContractImporter.StreamBodyTypeName, element.Name, GetLocalElementNamespace(ns, element, elementFormDefault), typeof(Stream), description, isReply);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
XmlQualifiedName typeName = part.Type;
|
||
|
|
if (IsNullOrEmpty(typeName))
|
||
|
|
{
|
||
|
|
if (IsNullOrEmpty(part.Element))
|
||
|
|
return false;
|
||
|
|
ns = part.Element.Namespace;
|
||
|
|
typeName = GetTypeName(FindSchemaElement(allSchemas, part.Element));
|
||
|
|
}
|
||
|
|
return CheckAndAddPart(typeName, DataContractSerializerMessageContractImporter.StreamBodyTypeName, part.Name, ns, typeof(Stream), description, isReply);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CanImportWrappedMessage(WsdlNS.MessagePart wsdlPart)
|
||
|
|
{
|
||
|
|
return (IsWrapperPart(wsdlPart)) ? CurrentSchemaImporter.CanImportWrapperElement(wsdlPart.Element) : false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool TryImportWrappedMessage(MessageDescription messageDescription, MessageDescription requestMessage, WsdlNS.Message wsdlMessage, bool isReply)
|
||
|
|
{
|
||
|
|
|
||
|
|
WsdlNS.MessagePart wsdlPart = wsdlMessage.Parts[0];
|
||
|
|
if (CanImportWrappedMessage(wsdlPart))
|
||
|
|
{
|
||
|
|
XmlQualifiedName elementName = wsdlPart.Element;
|
||
|
|
MessagePartDescription[] parts = CurrentSchemaImporter.ImportWrapperElement(elementName);
|
||
|
|
if (parts == null)
|
||
|
|
return false;
|
||
|
|
messageDescription.Body.WrapperName = new XmlName(elementName.Name, true /*isEncoded*/).EncodedName;
|
||
|
|
messageDescription.Body.WrapperNamespace = elementName.Namespace;
|
||
|
|
|
||
|
|
if (parts.Length > 0)
|
||
|
|
{
|
||
|
|
int partIndex = 0;
|
||
|
|
if (isReply && messageDescription.Body.ReturnValue == null && !CheckIsRef(requestMessage, parts[0]))
|
||
|
|
{
|
||
|
|
messageDescription.Body.ReturnValue = parts[0];
|
||
|
|
partIndex = 1;
|
||
|
|
}
|
||
|
|
for (; partIndex < parts.Length; partIndex++)
|
||
|
|
{
|
||
|
|
MessagePartDescription part = parts[partIndex];
|
||
|
|
messageDescription.Body.Parts.Add(part);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsWrapperPart(WsdlNS.MessagePart wsdlPart)
|
||
|
|
{
|
||
|
|
bool wrapFlag = false; // turn off special-casing for partname="parameters" if "wrapped" flag was set by user
|
||
|
|
object wrappedOptions = null;
|
||
|
|
if (this.importer.State.TryGetValue(typeof(WrappedOptions), out wrappedOptions))
|
||
|
|
{
|
||
|
|
wrapFlag = ((WrappedOptions)wrappedOptions).WrappedFlag;
|
||
|
|
}
|
||
|
|
return wsdlPart.Name == "parameters" && !IsNullOrEmpty(wsdlPart.Element) && !wrapFlag;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CheckIsRef(MessageDescription requestMessage, MessagePartDescription part)
|
||
|
|
{
|
||
|
|
foreach (MessagePartDescription requestPart in requestMessage.Body.Parts)
|
||
|
|
{
|
||
|
|
if (CompareMessageParts(requestPart, part))
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CompareMessageParts(MessagePartDescription x, MessagePartDescription y)
|
||
|
|
{
|
||
|
|
return (x.Name == y.Name && x.Namespace == y.Namespace);
|
||
|
|
}
|
||
|
|
|
||
|
|
static WsdlNS.MessagePart FindPartByName(WsdlNS.Message message, string name)
|
||
|
|
{
|
||
|
|
Fx.Assert(message != null, "Should not attempt to look for a part in an null message.");
|
||
|
|
foreach (WsdlNS.MessagePart part in message.Parts)
|
||
|
|
if (part.Name == name)
|
||
|
|
return part;
|
||
|
|
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxWsdlMessageDoesNotContainPart3, name, message.Name, message.ServiceDescription.TargetNamespace)));
|
||
|
|
}
|
||
|
|
|
||
|
|
static XmlSchemaElement FindSchemaElement(XmlSchemaSet schemaSet, XmlQualifiedName elementName)
|
||
|
|
{
|
||
|
|
XmlSchema schema;
|
||
|
|
return FindSchemaElement(schemaSet, elementName, out schema);
|
||
|
|
}
|
||
|
|
|
||
|
|
static XmlSchemaElement FindSchemaElement(XmlSchemaSet schemaSet, XmlQualifiedName elementName, out XmlSchema containingSchema)
|
||
|
|
{
|
||
|
|
XmlSchemaElement element = null;
|
||
|
|
containingSchema = null;
|
||
|
|
foreach (XmlSchema schema in GetSchema(schemaSet, elementName.Namespace))
|
||
|
|
{
|
||
|
|
element = (XmlSchemaElement)schema.Elements[elementName];
|
||
|
|
if (element != null)
|
||
|
|
{
|
||
|
|
containingSchema = schema;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (element == null)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxSchemaDoesNotContainElement, elementName.Name, elementName.Namespace)));
|
||
|
|
return element;
|
||
|
|
}
|
||
|
|
|
||
|
|
static XmlSchemaType FindSchemaType(XmlSchemaSet schemaSet, XmlQualifiedName typeName)
|
||
|
|
{
|
||
|
|
if (typeName.Namespace == XmlSchema.Namespace)
|
||
|
|
return null;
|
||
|
|
XmlSchema schema;
|
||
|
|
return FindSchemaType(schemaSet, typeName, out schema);
|
||
|
|
}
|
||
|
|
|
||
|
|
static XmlSchemaType FindSchemaType(XmlSchemaSet schemaSet, XmlQualifiedName typeName, out XmlSchema containingSchema)
|
||
|
|
{
|
||
|
|
containingSchema = null;
|
||
|
|
if (StockSchemas.IsKnownSchema(typeName.Namespace))
|
||
|
|
return null;
|
||
|
|
|
||
|
|
XmlSchemaType type = null;
|
||
|
|
foreach (XmlSchema schema in GetSchema(schemaSet, typeName.Namespace))
|
||
|
|
{
|
||
|
|
type = (XmlSchemaType)schema.SchemaTypes[typeName];
|
||
|
|
if (type != null)
|
||
|
|
{
|
||
|
|
containingSchema = schema;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (type == null)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxSchemaDoesNotContainType, typeName.Name, typeName.Namespace)));
|
||
|
|
return type;
|
||
|
|
}
|
||
|
|
|
||
|
|
static XmlSchemaSet GatherSchemas(WsdlImporter importer)
|
||
|
|
{
|
||
|
|
XmlSchemaSet schemaSet = new XmlSchemaSet();
|
||
|
|
schemaSet.XmlResolver = null;
|
||
|
|
|
||
|
|
foreach (WsdlNS.ServiceDescription wsdl in importer.WsdlDocuments)
|
||
|
|
{
|
||
|
|
XmlQualifiedName[] wsdlPrefixNsPairs = wsdl.Namespaces.ToArray();
|
||
|
|
if (wsdl.Types != null && wsdl.Types.Schemas != null)
|
||
|
|
{
|
||
|
|
foreach (XmlSchema xsd in wsdl.Types.Schemas)
|
||
|
|
{
|
||
|
|
XmlSerializerNamespaces xsdNamespaces = xsd.Namespaces;
|
||
|
|
XmlQualifiedName[] xsdPrefixNsPairs = xsdNamespaces.ToArray();
|
||
|
|
Dictionary<string, object> prefixesUsed = new Dictionary<string, object>();
|
||
|
|
foreach (XmlQualifiedName pair in xsdPrefixNsPairs)
|
||
|
|
prefixesUsed.Add(pair.Name, null);
|
||
|
|
foreach (XmlQualifiedName pair in wsdlPrefixNsPairs)
|
||
|
|
if (!prefixesUsed.ContainsKey(pair.Name))
|
||
|
|
xsdNamespaces.Add(pair.Name, pair.Namespace);
|
||
|
|
if (xsd.Items.Count > 0)
|
||
|
|
{
|
||
|
|
schemaSet.Add(xsd);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// only add include schemas
|
||
|
|
foreach (XmlSchemaExternal include in xsd.Includes)
|
||
|
|
{
|
||
|
|
if (include.Schema != null)
|
||
|
|
{
|
||
|
|
schemaSet.Add(include.Schema);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
schemaSet.Add(importer.XmlSchemas);
|
||
|
|
|
||
|
|
return schemaSet;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Segregate the schemas containing abstract types from those
|
||
|
|
// containing regular XML definitions. This is important because
|
||
|
|
// when you import something returning the ur-type (object), then
|
||
|
|
// you need to import ALL types/elements within ALL schemas. We
|
||
|
|
// don't want the RPC-based types leaking over into the XML-based
|
||
|
|
// element definitions or literal types in the encoded schemas,
|
||
|
|
// beacase it can cause schema coimpilation falure.
|
||
|
|
static void CollectEncodedAndLiteralSchemas(WsdlNS.ServiceDescriptionCollection serviceDescriptions, XmlSchemas encodedSchemas, XmlSchemas literalSchemas, XmlSchemaSet allSchemas)
|
||
|
|
{
|
||
|
|
XmlSchema wsdl = StockSchemas.CreateWsdl();
|
||
|
|
XmlSchema soap = StockSchemas.CreateSoap();
|
||
|
|
XmlSchema soapEncoding = StockSchemas.CreateSoapEncoding();
|
||
|
|
|
||
|
|
Hashtable references = new Hashtable();
|
||
|
|
if (!allSchemas.Contains(wsdl.TargetNamespace))
|
||
|
|
{
|
||
|
|
references[soap] = wsdl;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!allSchemas.Contains(soap.TargetNamespace))
|
||
|
|
{
|
||
|
|
references[soap] = soap;
|
||
|
|
}
|
||
|
|
if (!allSchemas.Contains(soapEncoding.TargetNamespace))
|
||
|
|
{
|
||
|
|
references[soapEncoding] = soapEncoding;
|
||
|
|
}
|
||
|
|
foreach (WsdlNS.ServiceDescription description in serviceDescriptions)
|
||
|
|
{
|
||
|
|
foreach (WsdlNS.Message message in description.Messages)
|
||
|
|
{
|
||
|
|
foreach (WsdlNS.MessagePart part in message.Parts)
|
||
|
|
{
|
||
|
|
bool isEncoded;
|
||
|
|
bool isLiteral;
|
||
|
|
FindUse(part, out isEncoded, out isLiteral);
|
||
|
|
if (part.Element != null && !part.Element.IsEmpty)
|
||
|
|
{
|
||
|
|
XmlSchemaElement element = FindSchemaElement(allSchemas, part.Element);
|
||
|
|
if (element != null)
|
||
|
|
{
|
||
|
|
AddSchema(element.Parent as XmlSchema, isEncoded, isLiteral, encodedSchemas, literalSchemas, references);
|
||
|
|
if (element.SchemaTypeName != null && !element.SchemaTypeName.IsEmpty)
|
||
|
|
{
|
||
|
|
XmlSchemaType type = FindSchemaType(allSchemas, element.SchemaTypeName);
|
||
|
|
if (type != null)
|
||
|
|
{
|
||
|
|
AddSchema(type.Parent as XmlSchema, isEncoded, isLiteral, encodedSchemas, literalSchemas, references);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (part.Type != null && !part.Type.IsEmpty)
|
||
|
|
{
|
||
|
|
XmlSchemaType type = FindSchemaType(allSchemas, part.Type);
|
||
|
|
if (type != null)
|
||
|
|
{
|
||
|
|
AddSchema(type.Parent as XmlSchema, isEncoded, isLiteral, encodedSchemas, literalSchemas, references);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Hashtable imports;
|
||
|
|
foreach (XmlSchemas schemas in new XmlSchemas[] { encodedSchemas, literalSchemas })
|
||
|
|
{
|
||
|
|
// collect all imports
|
||
|
|
imports = new Hashtable();
|
||
|
|
foreach (XmlSchema schema in schemas)
|
||
|
|
{
|
||
|
|
AddImport(schema, imports, allSchemas);
|
||
|
|
}
|
||
|
|
// make sure we add them to the corresponding schema collections
|
||
|
|
foreach (XmlSchema schema in imports.Keys)
|
||
|
|
{
|
||
|
|
if (references[schema] == null && !schemas.Contains(schema))
|
||
|
|
{
|
||
|
|
schemas.Add(schema);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// If a schema was not referenced by either a literal or an encoded message part,
|
||
|
|
// add it to both collections. There's no way to tell which it should be.
|
||
|
|
imports = new Hashtable();
|
||
|
|
foreach (XmlSchema schema in allSchemas.Schemas())
|
||
|
|
{
|
||
|
|
if (!encodedSchemas.Contains(schema) && !literalSchemas.Contains(schema))
|
||
|
|
{
|
||
|
|
AddImport(schema, imports, allSchemas);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// make sure we add them to the corresponding schema collections
|
||
|
|
foreach (XmlSchema schema in imports.Keys)
|
||
|
|
{
|
||
|
|
if (references[schema] != null)
|
||
|
|
continue;
|
||
|
|
if (!encodedSchemas.Contains(schema))
|
||
|
|
{
|
||
|
|
encodedSchemas.Add(schema);
|
||
|
|
}
|
||
|
|
if (!literalSchemas.Contains(schema))
|
||
|
|
{
|
||
|
|
literalSchemas.Add(schema);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (encodedSchemas.Count > 0)
|
||
|
|
{
|
||
|
|
foreach (XmlSchema schema in references.Values)
|
||
|
|
{
|
||
|
|
encodedSchemas.AddReference(schema);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (literalSchemas.Count > 0)
|
||
|
|
{
|
||
|
|
foreach (XmlSchema schema in references.Values)
|
||
|
|
{
|
||
|
|
literalSchemas.AddReference(schema);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
AddSoapEncodingSchemaIfNeeded(literalSchemas);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void AddSoapEncodingSchemaIfNeeded(XmlSchemas schemas)
|
||
|
|
{
|
||
|
|
XmlSchema fakeXsdSchema = StockSchemas.CreateFakeXsdSchema();
|
||
|
|
|
||
|
|
foreach (XmlSchema schema in schemas)
|
||
|
|
{
|
||
|
|
foreach (object include in schema.Includes)
|
||
|
|
{
|
||
|
|
XmlSchemaImport import = include as XmlSchemaImport;
|
||
|
|
if (import != null && import.Namespace == fakeXsdSchema.TargetNamespace)
|
||
|
|
{
|
||
|
|
schemas.Add(fakeXsdSchema);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void AddImport(XmlSchema schema, Hashtable imports, XmlSchemaSet allSchemas)
|
||
|
|
{
|
||
|
|
if (schema == null || imports[schema] != null)
|
||
|
|
return;
|
||
|
|
imports.Add(schema, schema);
|
||
|
|
foreach (XmlSchemaExternal external in schema.Includes)
|
||
|
|
{
|
||
|
|
if (external is XmlSchemaImport)
|
||
|
|
{
|
||
|
|
XmlSchemaImport import = (XmlSchemaImport)external;
|
||
|
|
foreach (XmlSchema s in allSchemas.Schemas(import.Namespace))
|
||
|
|
{
|
||
|
|
AddImport(s, imports, allSchemas);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void AddSchema(XmlSchema schema, bool isEncoded, bool isLiteral, XmlSchemas encodedSchemas, XmlSchemas literalSchemas, Hashtable references)
|
||
|
|
{
|
||
|
|
if (schema != null)
|
||
|
|
{
|
||
|
|
if (isEncoded && !encodedSchemas.Contains(schema))
|
||
|
|
{
|
||
|
|
if (references.Contains(schema))
|
||
|
|
{
|
||
|
|
encodedSchemas.AddReference(schema);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
encodedSchemas.Add(schema);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (isLiteral && !literalSchemas.Contains(schema))
|
||
|
|
{
|
||
|
|
if (references.Contains(schema))
|
||
|
|
{
|
||
|
|
literalSchemas.AddReference(schema);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
literalSchemas.Add(schema);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void FindUse(WsdlNS.MessagePart part, out bool isEncoded, out bool isLiteral)
|
||
|
|
{
|
||
|
|
isEncoded = false;
|
||
|
|
isLiteral = false;
|
||
|
|
string messageName = part.Message.Name;
|
||
|
|
WsdlNS.Operation associatedOperation = null;
|
||
|
|
WsdlNS.ServiceDescription description = part.Message.ServiceDescription;
|
||
|
|
foreach (WsdlNS.PortType portType in description.PortTypes)
|
||
|
|
{
|
||
|
|
foreach (WsdlNS.Operation operation in portType.Operations)
|
||
|
|
{
|
||
|
|
foreach (WsdlNS.OperationMessage message in operation.Messages)
|
||
|
|
{
|
||
|
|
if (message.Message.Equals(new XmlQualifiedName(part.Message.Name, description.TargetNamespace)))
|
||
|
|
{
|
||
|
|
associatedOperation = operation;
|
||
|
|
FindUse(associatedOperation, description, messageName, ref isEncoded, ref isLiteral);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (associatedOperation == null)
|
||
|
|
FindUse(null, description, messageName, ref isEncoded, ref isLiteral);
|
||
|
|
}
|
||
|
|
|
||
|
|
static void FindUse(WsdlNS.Operation operation, WsdlNS.ServiceDescription description, string messageName, ref bool isEncoded, ref bool isLiteral)
|
||
|
|
{
|
||
|
|
string targetNamespace = description.TargetNamespace;
|
||
|
|
foreach (WsdlNS.Binding binding in description.Bindings)
|
||
|
|
{
|
||
|
|
if (operation != null && !new XmlQualifiedName(operation.PortType.Name, targetNamespace).Equals(binding.Type))
|
||
|
|
continue;
|
||
|
|
foreach (WsdlNS.OperationBinding bindingOperation in binding.Operations)
|
||
|
|
{
|
||
|
|
if (bindingOperation.Input != null) foreach (object extension in bindingOperation.Input.Extensions)
|
||
|
|
{
|
||
|
|
if (operation != null)
|
||
|
|
{
|
||
|
|
WsdlNS.SoapBodyBinding body = extension as WsdlNS.SoapBodyBinding;
|
||
|
|
if (body != null && operation.IsBoundBy(bindingOperation))
|
||
|
|
{
|
||
|
|
if (body.Use == WsdlNS.SoapBindingUse.Encoded)
|
||
|
|
isEncoded = true;
|
||
|
|
else if (body.Use == WsdlNS.SoapBindingUse.Literal)
|
||
|
|
isLiteral = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
WsdlNS.SoapHeaderBinding header = extension as WsdlNS.SoapHeaderBinding;
|
||
|
|
if (header != null && header.Message.Name == messageName)
|
||
|
|
{
|
||
|
|
if (header.Use == WsdlNS.SoapBindingUse.Encoded)
|
||
|
|
isEncoded = true;
|
||
|
|
else if (header.Use == WsdlNS.SoapBindingUse.Literal)
|
||
|
|
isLiteral = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (bindingOperation.Output != null) foreach (object extension in bindingOperation.Output.Extensions)
|
||
|
|
{
|
||
|
|
if (operation != null)
|
||
|
|
{
|
||
|
|
if (operation.IsBoundBy(bindingOperation))
|
||
|
|
{
|
||
|
|
WsdlNS.SoapBodyBinding body = extension as WsdlNS.SoapBodyBinding;
|
||
|
|
if (body != null)
|
||
|
|
{
|
||
|
|
if (body.Use == WsdlNS.SoapBindingUse.Encoded)
|
||
|
|
isEncoded = true;
|
||
|
|
else if (body.Use == WsdlNS.SoapBindingUse.Literal)
|
||
|
|
isLiteral = true;
|
||
|
|
}
|
||
|
|
else if (extension is WsdlNS.MimeXmlBinding)
|
||
|
|
isLiteral = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
WsdlNS.SoapHeaderBinding header = extension as WsdlNS.SoapHeaderBinding;
|
||
|
|
if (header != null && header.Message.Name == messageName)
|
||
|
|
{
|
||
|
|
if (header.Use == WsdlNS.SoapBindingUse.Encoded)
|
||
|
|
isEncoded = true;
|
||
|
|
else if (header.Use == WsdlNS.SoapBindingUse.Literal)
|
||
|
|
isLiteral = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static string GetLocalElementNamespace(string ns, XmlSchemaElement element, XmlSchemaForm elementFormDefault)
|
||
|
|
{
|
||
|
|
XmlSchemaForm elementForm = (element.Form != XmlSchemaForm.None) ? element.Form : elementFormDefault;
|
||
|
|
if (elementForm != XmlSchemaForm.Qualified)
|
||
|
|
return string.Empty;
|
||
|
|
return ns;
|
||
|
|
}
|
||
|
|
|
||
|
|
static IEnumerable GetSchema(XmlSchemaSet schemaSet, string ns)
|
||
|
|
{
|
||
|
|
ICollection schemas = schemaSet.Schemas(ns);
|
||
|
|
if (schemas == null || schemas.Count == 0)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxSchemaNotFound, ns)));
|
||
|
|
return schemas;
|
||
|
|
}
|
||
|
|
|
||
|
|
static WsdlNS.SoapBindingStyle GetStyle(WsdlNS.Binding binding)
|
||
|
|
{
|
||
|
|
WsdlNS.SoapBindingStyle style = WsdlNS.SoapBindingStyle.Default;
|
||
|
|
if (binding != null)
|
||
|
|
{
|
||
|
|
WsdlNS.SoapBinding soapBinding = binding.Extensions.Find(typeof(WsdlNS.SoapBinding)) as WsdlNS.SoapBinding;
|
||
|
|
if (soapBinding != null)
|
||
|
|
style = soapBinding.Style;
|
||
|
|
}
|
||
|
|
return style;
|
||
|
|
}
|
||
|
|
|
||
|
|
static OperationFormatStyle GetStyle(WsdlNS.OperationBinding operationBinding)
|
||
|
|
{
|
||
|
|
WsdlNS.SoapBindingStyle style = GetStyle(operationBinding.Binding);
|
||
|
|
if (operationBinding != null)
|
||
|
|
{
|
||
|
|
WsdlNS.SoapOperationBinding soapOperationBinding = operationBinding.Extensions.Find(typeof(WsdlNS.SoapOperationBinding)) as WsdlNS.SoapOperationBinding;
|
||
|
|
if (soapOperationBinding != null)
|
||
|
|
{
|
||
|
|
if (soapOperationBinding.Style != WsdlNS.SoapBindingStyle.Default)
|
||
|
|
style = soapOperationBinding.Style;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return (style == WsdlNS.SoapBindingStyle.Rpc) ? OperationFormatStyle.Rpc : OperationFormatStyle.Document;
|
||
|
|
}
|
||
|
|
|
||
|
|
static XmlQualifiedName GetTypeName(XmlSchemaElement element)
|
||
|
|
{
|
||
|
|
if (element.SchemaType != null)
|
||
|
|
return XmlQualifiedName.Empty;
|
||
|
|
else if (IsNullOrEmpty(element.SchemaTypeName))
|
||
|
|
return AnyType;
|
||
|
|
else
|
||
|
|
return element.SchemaTypeName;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool IsNullOrEmpty(XmlQualifiedName qname)
|
||
|
|
{
|
||
|
|
return qname == null || qname.IsEmpty;
|
||
|
|
}
|
||
|
|
|
||
|
|
void TraceFaultCannotBeImported(string faultName, string operationName, string message)
|
||
|
|
{
|
||
|
|
AddWarning(SR.GetString(SR.SFxFaultCannotBeImported, faultName, operationName, message));
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool CheckAndAddPart(XmlQualifiedName typeNameFound, XmlQualifiedName typeNameRequired, string name, string ns, Type type, MessageDescription description, bool isReply)
|
||
|
|
{
|
||
|
|
if (IsNullOrEmpty(typeNameFound) || typeNameFound != typeNameRequired)
|
||
|
|
return false;
|
||
|
|
MessagePartDescription bodyPart = new MessagePartDescription(name, ns);
|
||
|
|
bodyPart.Type = type;
|
||
|
|
if (isReply && description.Body.ReturnValue == null)
|
||
|
|
description.Body.ReturnValue = bodyPart;
|
||
|
|
else
|
||
|
|
description.Body.Parts.Add(bodyPart);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
static bool CheckPart(XmlQualifiedName typeNameFound, XmlQualifiedName typeNameRequired)
|
||
|
|
{
|
||
|
|
return !IsNullOrEmpty(typeNameFound) && typeNameFound == typeNameRequired;
|
||
|
|
}
|
||
|
|
|
||
|
|
static XmlSchemaComplexType GetElementComplexType(XmlQualifiedName elementName, XmlSchemaSet schemaSet, out string ns, out XmlSchemaForm elementFormDefault)
|
||
|
|
{
|
||
|
|
XmlSchema schema;
|
||
|
|
XmlSchemaElement schemaElement = FindSchemaElement(schemaSet, elementName, out schema);
|
||
|
|
ns = elementName.Namespace;
|
||
|
|
elementFormDefault = schema.ElementFormDefault;
|
||
|
|
|
||
|
|
XmlSchemaType schemaType = null;
|
||
|
|
if (schemaElement.SchemaType != null)
|
||
|
|
{
|
||
|
|
schemaType = schemaElement.SchemaType;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
XmlQualifiedName schemaTypeName = GetTypeName(schemaElement);
|
||
|
|
if (schemaTypeName.Namespace == XmlSchema.Namespace)
|
||
|
|
return null;
|
||
|
|
|
||
|
|
schemaType = FindSchemaType(schemaSet, schemaTypeName, out schema);
|
||
|
|
ns = schemaTypeName.Namespace;
|
||
|
|
elementFormDefault = schema.ElementFormDefault;
|
||
|
|
}
|
||
|
|
if (schemaType == null)
|
||
|
|
return null;
|
||
|
|
|
||
|
|
return schemaType as XmlSchemaComplexType;
|
||
|
|
}
|
||
|
|
|
||
|
|
static XmlSchemaSequence GetRootSequence(XmlSchemaComplexType complexType)
|
||
|
|
{
|
||
|
|
if (complexType == null)
|
||
|
|
return null;
|
||
|
|
return complexType.Particle != null ? complexType.Particle as XmlSchemaSequence : null;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CanImportMessageBinding(WsdlNS.MessageBinding messageBinding, WsdlNS.Message wsdlMessage, OperationFormatStyle style, out bool isEncoded)
|
||
|
|
{
|
||
|
|
isEncoded = false;
|
||
|
|
|
||
|
|
bool? isMessageEncoded = null;
|
||
|
|
foreach (object extension in messageBinding.Extensions)
|
||
|
|
{
|
||
|
|
bool currentIsEncoded;
|
||
|
|
WsdlNS.SoapHeaderBinding soapHeaderBinding = extension as WsdlNS.SoapHeaderBinding;
|
||
|
|
|
||
|
|
if (soapHeaderBinding != null)
|
||
|
|
{
|
||
|
|
if (!ValidWsdl.Check(soapHeaderBinding, messageBinding, AddWarning))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
if (!CanImportMessageHeaderBinding(soapHeaderBinding, wsdlMessage, style, out currentIsEncoded))
|
||
|
|
return false;
|
||
|
|
if (isMessageEncoded == null)
|
||
|
|
isMessageEncoded = currentIsEncoded;
|
||
|
|
else if (isMessageEncoded.Value != currentIsEncoded)
|
||
|
|
AddError(SR.GetString(SR.SFxInconsistentWsdlOperationUseInBindingExtensions, messageBinding.OperationBinding.Name, messageBinding.OperationBinding.Binding.Name));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
WsdlNS.SoapBodyBinding soapBodyBinding = extension as WsdlNS.SoapBodyBinding;
|
||
|
|
if (soapBodyBinding != null)
|
||
|
|
{
|
||
|
|
if (!CanImportMessageBodyBinding(soapBodyBinding, style, out currentIsEncoded))
|
||
|
|
return false;
|
||
|
|
if (isMessageEncoded == null)
|
||
|
|
isMessageEncoded = currentIsEncoded;
|
||
|
|
else if (isMessageEncoded.Value != currentIsEncoded)
|
||
|
|
AddError(SR.GetString(SR.SFxInconsistentWsdlOperationUseInBindingExtensions, messageBinding.OperationBinding.Name, messageBinding.OperationBinding.Binding.Name));
|
||
|
|
string[] messageParts = soapBodyBinding.Parts;
|
||
|
|
if (messageParts == null)
|
||
|
|
{
|
||
|
|
messageParts = new string[wsdlMessage.Parts.Count];
|
||
|
|
for (int i = 0; i < messageParts.Length; i++)
|
||
|
|
messageParts[i] = wsdlMessage.Parts[i].Name;
|
||
|
|
}
|
||
|
|
IList<string> bodyPartsFromBindings;
|
||
|
|
bool isFirstBinding = false;
|
||
|
|
if (!BodyPartsTable.TryGetValue(wsdlMessage, out bodyPartsFromBindings))
|
||
|
|
{
|
||
|
|
bodyPartsFromBindings = new List<string>();
|
||
|
|
BodyPartsTable.Add(wsdlMessage, bodyPartsFromBindings);
|
||
|
|
isFirstBinding = true;
|
||
|
|
}
|
||
|
|
foreach (string partName in messageParts)
|
||
|
|
{
|
||
|
|
if (string.IsNullOrEmpty(partName))
|
||
|
|
continue;
|
||
|
|
if (isFirstBinding)
|
||
|
|
bodyPartsFromBindings.Add(partName);
|
||
|
|
else if (!bodyPartsFromBindings.Contains(partName))
|
||
|
|
{
|
||
|
|
AddError(SR.GetString(SR.SFxInconsistentBindingBodyParts, messageBinding.OperationBinding.Name, messageBinding.OperationBinding.Binding.Name, partName));
|
||
|
|
bodyPartsFromBindings.Add(partName);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (isMessageEncoded != null)
|
||
|
|
isEncoded = isMessageEncoded.Value;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool CanImportFaultBinding(WsdlNS.FaultBinding faultBinding, OperationFormatStyle style, out bool isFaultEncoded)
|
||
|
|
{
|
||
|
|
bool? isEncoded = null;
|
||
|
|
bool currentIsEncoded;
|
||
|
|
foreach (object extension in faultBinding.Extensions)
|
||
|
|
{
|
||
|
|
XmlElement soapFaultBindingRaw = extension as XmlElement;
|
||
|
|
if (SoapHelper.IsSoapFaultBinding(soapFaultBindingRaw))
|
||
|
|
{
|
||
|
|
currentIsEncoded = SoapHelper.IsEncoded(soapFaultBindingRaw);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
WsdlNS.SoapFaultBinding soapFaultBinding = extension as WsdlNS.SoapFaultBinding;
|
||
|
|
if (soapFaultBinding == null)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
if (!ValidWsdl.Check(soapFaultBinding, faultBinding, AddWarning))
|
||
|
|
continue;
|
||
|
|
currentIsEncoded = (soapFaultBinding.Use == System.Web.Services.Description.SoapBindingUse.Encoded);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (isEncoded == null)
|
||
|
|
isEncoded = currentIsEncoded;
|
||
|
|
else if (isEncoded.Value != currentIsEncoded)
|
||
|
|
AddError(SR.GetString(SR.SFxInconsistentWsdlOperationUseInBindingExtensions, faultBinding.OperationBinding.Name, faultBinding.OperationBinding.Binding.Name));
|
||
|
|
}
|
||
|
|
isFaultEncoded = isEncoded ?? false;
|
||
|
|
return this.CurrentSchemaImporter.CanImportStyleAndUse(style, isFaultEncoded);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
bool CanImportMessageBodyBinding(WsdlNS.SoapBodyBinding bodyBinding, OperationFormatStyle style, out bool isEncoded)
|
||
|
|
{
|
||
|
|
isEncoded = (bodyBinding.Use == WsdlNS.SoapBindingUse.Encoded);
|
||
|
|
return CurrentSchemaImporter.CanImportStyleAndUse(style, isEncoded);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool CanImportMessageHeaderBinding(WsdlNS.SoapHeaderBinding headerBinding, WsdlNS.Message wsdlMessage, OperationFormatStyle style, out bool isEncoded)
|
||
|
|
{
|
||
|
|
isEncoded = (headerBinding.Use == WsdlNS.SoapBindingUse.Encoded);
|
||
|
|
WsdlNS.Message wsdlHeaderMessage = wsdlMessage.ServiceDescription.ServiceDescriptions.GetMessage(headerBinding.Message);
|
||
|
|
WsdlNS.MessagePart part = FindPartByName(wsdlHeaderMessage, headerBinding.Part);
|
||
|
|
|
||
|
|
OperationFormatStyle headerStyle;
|
||
|
|
if (!CurrentSchemaImporter.CanImportMessagePart(part, out headerStyle))
|
||
|
|
return false;
|
||
|
|
if (headerStyle != style)
|
||
|
|
AddError(SR.GetString(SR.SFxInconsistentWsdlOperationStyleInHeader, part.Name, headerStyle, style));
|
||
|
|
return CurrentSchemaImporter.CanImportStyleAndUse(style, isEncoded);
|
||
|
|
}
|
||
|
|
|
||
|
|
void ImportMessageBinding(WsdlNS.MessageBinding messageBinding, WsdlNS.Message wsdlMessage, MessageDescription description, OperationFormatStyle style, bool isEncoded)
|
||
|
|
{
|
||
|
|
WsdlNS.OperationMessage wsdlOperationMessage = contractContext.GetOperationMessage(description);
|
||
|
|
foreach (object extension in messageBinding.Extensions)
|
||
|
|
{
|
||
|
|
WsdlNS.SoapHeaderBinding soapHeaderBinding = extension as WsdlNS.SoapHeaderBinding;
|
||
|
|
if (soapHeaderBinding != null)
|
||
|
|
{
|
||
|
|
ImportMessageHeaderBinding(soapHeaderBinding, wsdlMessage, description, style, isEncoded, messageBinding.OperationBinding.Name);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
WsdlNS.SoapBodyBinding soapBodyBinding = extension as WsdlNS.SoapBodyBinding;
|
||
|
|
if (soapBodyBinding != null)
|
||
|
|
{
|
||
|
|
ImportMessageBodyBinding(soapBodyBinding, wsdlMessage, description, style, isEncoded, messageBinding.OperationBinding.Name);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ImportMessageBodyBinding(WsdlNS.SoapBodyBinding bodyBinding, WsdlNS.Message wsdlMessage, MessageDescription description, OperationFormatStyle style, bool isEncoded, string operationName)
|
||
|
|
{
|
||
|
|
if (style == OperationFormatStyle.Rpc && bodyBinding.Namespace != null)
|
||
|
|
description.Body.WrapperNamespace = bodyBinding.Namespace;
|
||
|
|
this.CurrentSchemaImporter.ValidateStyleAndUse(style, isEncoded, operationName);
|
||
|
|
}
|
||
|
|
|
||
|
|
void ImportMessageHeaderBinding(WsdlNS.SoapHeaderBinding headerBinding, WsdlNS.Message wsdlMessage, MessageDescription description, OperationFormatStyle style, bool isEncoded, string operationName)
|
||
|
|
{
|
||
|
|
WsdlNS.Message wsdlHeaderMessage = wsdlMessage.ServiceDescription.ServiceDescriptions.GetMessage(headerBinding.Message);
|
||
|
|
WsdlNS.MessagePart part = FindPartByName(wsdlHeaderMessage, headerBinding.Part);
|
||
|
|
if (!description.Headers.Contains(this.CurrentSchemaImporter.GetPartName(part)))
|
||
|
|
{
|
||
|
|
description.Headers.Add((MessageHeaderDescription)schemaImporter.ImportMessagePart(part, true/*isHeader*/, isEncoded));
|
||
|
|
this.CurrentSchemaImporter.ValidateStyleAndUse(style, isEncoded, operationName);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
internal abstract class SchemaImporter
|
||
|
|
{
|
||
|
|
readonly protected XmlSchemaSet schemaSet;
|
||
|
|
readonly protected WsdlImporter importer;
|
||
|
|
|
||
|
|
internal SchemaImporter(WsdlImporter importer)
|
||
|
|
{
|
||
|
|
this.importer = importer;
|
||
|
|
this.schemaSet = GatherSchemas(importer);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal XmlQualifiedName GetPartName(WsdlNS.MessagePart part)
|
||
|
|
{
|
||
|
|
if (!IsNullOrEmpty(part.Element))
|
||
|
|
return part.Element;
|
||
|
|
if (!IsNullOrEmpty(part.Type))
|
||
|
|
return new XmlQualifiedName(part.Name, String.Empty);
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxWsdlPartMustHaveElementOrType, part.Name, part.Message.Name, part.Message.Namespaces)));
|
||
|
|
}
|
||
|
|
|
||
|
|
internal bool CanImportMessagePart(WsdlNS.MessagePart part, out OperationFormatStyle style)
|
||
|
|
{
|
||
|
|
style = OperationFormatStyle.Document;
|
||
|
|
if (!IsNullOrEmpty(part.Element))
|
||
|
|
return CanImportElement(FindSchemaElement(this.schemaSet, part.Element));
|
||
|
|
if (!IsNullOrEmpty(part.Type))
|
||
|
|
{
|
||
|
|
style = OperationFormatStyle.Rpc;
|
||
|
|
return CanImportType(part.Type);
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal MessagePartDescription ImportMessagePart(WsdlNS.MessagePart part, bool isHeader, bool isEncoded)
|
||
|
|
{
|
||
|
|
MessagePartDescription bodyPart = null;
|
||
|
|
if (!IsNullOrEmpty(part.Element))
|
||
|
|
return ImportParameterElement(part.Element, isHeader, false/*isMultiple*/);
|
||
|
|
if (!IsNullOrEmpty(part.Type))
|
||
|
|
{
|
||
|
|
bodyPart = isHeader ? (MessagePartDescription)new MessageHeaderDescription(part.Name, String.Empty) : new MessagePartDescription(part.Name, String.Empty);
|
||
|
|
bodyPart.BaseType = ImportType(bodyPart, part.Type, isEncoded);
|
||
|
|
return bodyPart;
|
||
|
|
}
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxWsdlPartMustHaveElementOrType, part.Name, part.Message.Name, part.Message.Namespaces)));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
internal MessagePartDescription ImportParameterElement(XmlQualifiedName elementName, bool isHeader, bool isMultiple)
|
||
|
|
{
|
||
|
|
return ImportParameterElement(FindSchemaElement(this.schemaSet, elementName), elementName.Namespace, isHeader, isMultiple);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal MessagePartDescription ImportParameterElement(XmlSchemaElement element, string ns, bool isHeader, bool isMultiple)
|
||
|
|
{
|
||
|
|
if (element.MaxOccurs > 1)
|
||
|
|
isMultiple = true;
|
||
|
|
if (!IsNullOrEmpty(element.RefName))
|
||
|
|
return ImportParameterElement(element.RefName, isHeader, isMultiple);
|
||
|
|
|
||
|
|
MessagePartDescription part = isHeader ? (MessagePartDescription)new MessageHeaderDescription(element.Name, ns) : new MessagePartDescription(element.Name, ns);
|
||
|
|
part.Multiple = isMultiple;
|
||
|
|
part.BaseType = ImportElement(part, element, false/*isEncoded*/);
|
||
|
|
return part;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal virtual bool CanImportFault(XmlSchemaElement detailElement, XmlQualifiedName detailElementTypeName)
|
||
|
|
{
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
|
||
|
|
}
|
||
|
|
|
||
|
|
internal virtual CodeTypeReference ImportFaultElement(XmlQualifiedName elementName, XmlSchemaElement element, bool isEncoded)
|
||
|
|
{
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
|
||
|
|
}
|
||
|
|
|
||
|
|
internal virtual CodeTypeReference ImportFaultType(XmlQualifiedName elementName, XmlQualifiedName typeName, bool isEncoded)
|
||
|
|
{
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
|
||
|
|
}
|
||
|
|
|
||
|
|
internal virtual void SetOperationSupportFaults(OperationDescription operation, bool supportFaults)
|
||
|
|
{
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotImplementedException());
|
||
|
|
}
|
||
|
|
|
||
|
|
internal abstract void PreprocessSchema();
|
||
|
|
internal abstract void PostprocessSchema(bool used);
|
||
|
|
internal abstract bool CanImportStyleAndUse(OperationFormatStyle style, bool isEncoded);
|
||
|
|
internal abstract void ValidateStyleAndUse(OperationFormatStyle style, bool isEncoded, string operationName);
|
||
|
|
internal abstract IOperationBehavior GetOperationGenerator();
|
||
|
|
internal abstract bool CanImportType(XmlQualifiedName typeName);
|
||
|
|
internal abstract string ImportType(MessagePartDescription part, XmlQualifiedName typeName, bool isEncoded);
|
||
|
|
internal abstract bool CanImportElement(XmlSchemaElement element);
|
||
|
|
internal abstract string ImportElement(MessagePartDescription part, XmlSchemaElement element, bool isEncoded);
|
||
|
|
internal abstract bool CanImportWrapperElement(XmlQualifiedName elementName);
|
||
|
|
internal abstract MessagePartDescription[] ImportWrapperElement(XmlQualifiedName elementName);
|
||
|
|
internal abstract void SetOperationStyle(OperationDescription operation, OperationFormatStyle style);
|
||
|
|
internal abstract bool GetOperationIsEncoded(OperationDescription operation);
|
||
|
|
internal abstract void SetOperationIsEncoded(OperationDescription operation, bool isEncoded);
|
||
|
|
internal abstract string GetFormatName();
|
||
|
|
}
|
||
|
|
|
||
|
|
internal class DataContractSerializerSchemaImporter : SchemaImporter
|
||
|
|
{
|
||
|
|
// Same string used in DataContractSet of System.Runtime.Serialization.dll
|
||
|
|
internal const String FailedReferenceTypeExceptionKey = "System.Runtime.Serialization.FailedReferenceType";
|
||
|
|
|
||
|
|
DataContractSerializerOperationGenerator DataContractSerializerOperationGenerator;
|
||
|
|
ValidationEventHandler compileValidationEventHandler;
|
||
|
|
Collection<MetadataConversionError> errors;
|
||
|
|
public DataContractSerializerSchemaImporter(WsdlImporter importer)
|
||
|
|
: base(importer)
|
||
|
|
{
|
||
|
|
DataContractSerializerOperationGenerator = new DataContractSerializerOperationGenerator(DataContractImporter.CodeCompileUnit);
|
||
|
|
}
|
||
|
|
|
||
|
|
XsdDataContractImporter DataContractImporter
|
||
|
|
{
|
||
|
|
get
|
||
|
|
{
|
||
|
|
object dataContractImporter;
|
||
|
|
if (!importer.State.TryGetValue(typeof(XsdDataContractImporter), out dataContractImporter))
|
||
|
|
{
|
||
|
|
object compileUnit;
|
||
|
|
if (!importer.State.TryGetValue(typeof(CodeCompileUnit), out compileUnit))
|
||
|
|
{
|
||
|
|
compileUnit = new CodeCompileUnit();
|
||
|
|
importer.State.Add(typeof(CodeCompileUnit), compileUnit);
|
||
|
|
}
|
||
|
|
dataContractImporter = new XsdDataContractImporter((CodeCompileUnit)compileUnit);
|
||
|
|
importer.State.Add(typeof(XsdDataContractImporter), dataContractImporter);
|
||
|
|
}
|
||
|
|
return (XsdDataContractImporter)dataContractImporter;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override bool CanImportElement(XmlSchemaElement element)
|
||
|
|
{
|
||
|
|
if (!element.IsNillable && !SchemaHelper.IsElementValueType(element))
|
||
|
|
return false;
|
||
|
|
return DataContractImporter.CanImport(schemaSet, element);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
internal override bool CanImportType(XmlQualifiedName typeName)
|
||
|
|
{
|
||
|
|
return DataContractImporter.CanImport(schemaSet, typeName);
|
||
|
|
}
|
||
|
|
internal override bool CanImportWrapperElement(XmlQualifiedName elementName)
|
||
|
|
{
|
||
|
|
string ns;
|
||
|
|
XmlSchemaForm elementFormDefault;
|
||
|
|
XmlSchemaComplexType complexType = GetElementComplexType(elementName, schemaSet, out ns, out elementFormDefault);
|
||
|
|
if (complexType == null)
|
||
|
|
return false;
|
||
|
|
if (complexType.Particle == null)
|
||
|
|
return true;
|
||
|
|
XmlSchemaSequence rootSequence = complexType.Particle as XmlSchemaSequence;
|
||
|
|
if (rootSequence == null)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
for (int i = 0; i < rootSequence.Items.Count; i++)
|
||
|
|
{
|
||
|
|
XmlSchemaElement element = rootSequence.Items[i] as XmlSchemaElement;
|
||
|
|
if (element == null)
|
||
|
|
return false;
|
||
|
|
if (!IsNullOrEmpty(element.RefName))
|
||
|
|
element = FindSchemaElement(this.schemaSet, element.RefName);
|
||
|
|
if (element.MaxOccurs > 1)
|
||
|
|
return false;
|
||
|
|
if (!DataContractImporter.CanImport(schemaSet, element))
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override bool CanImportFault(XmlSchemaElement detailElement, XmlQualifiedName detailElementTypeName)
|
||
|
|
{
|
||
|
|
DataContractSerializerSchemaImporter faultImporter = DataContractSerializerSchemaImporter.Get(importer);
|
||
|
|
if (IsNullOrEmpty(detailElementTypeName))
|
||
|
|
return faultImporter.CanImportFaultElement(detailElement);
|
||
|
|
else
|
||
|
|
return faultImporter.CanImportFaultType(detailElementTypeName);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static DataContractSerializerSchemaImporter Get(WsdlImporter importer)
|
||
|
|
{
|
||
|
|
Type type = typeof(DataContractSerializerSchemaImporter);
|
||
|
|
object schemaImporter;
|
||
|
|
if (importer.State.ContainsKey(type))
|
||
|
|
schemaImporter = importer.State[type];
|
||
|
|
else
|
||
|
|
{
|
||
|
|
schemaImporter = new DataContractSerializerSchemaImporter(importer);
|
||
|
|
importer.State.Add(type, schemaImporter);
|
||
|
|
}
|
||
|
|
return (DataContractSerializerSchemaImporter)schemaImporter;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override MessagePartDescription[] ImportWrapperElement(XmlQualifiedName elementName)
|
||
|
|
{
|
||
|
|
string ns;
|
||
|
|
XmlSchemaForm elementFormDefault;
|
||
|
|
XmlSchemaComplexType complexType = GetElementComplexType(elementName, schemaSet, out ns, out elementFormDefault);
|
||
|
|
if (complexType == null)
|
||
|
|
return null;
|
||
|
|
if (complexType.Particle == null)
|
||
|
|
return new MessagePartDescription[0];
|
||
|
|
XmlSchemaSequence rootSequence = complexType.Particle as XmlSchemaSequence;
|
||
|
|
if (rootSequence == null)
|
||
|
|
return null;
|
||
|
|
|
||
|
|
MessagePartDescription[] parts = new MessagePartDescription[rootSequence.Items.Count];
|
||
|
|
|
||
|
|
for (int i = 0; i < rootSequence.Items.Count; i++)
|
||
|
|
{
|
||
|
|
XmlSchemaElement localElement = rootSequence.Items[i] as XmlSchemaElement;
|
||
|
|
if (localElement == null)
|
||
|
|
return null;
|
||
|
|
parts[i] = ImportParameterElement(localElement, GetLocalElementNamespace(ns, localElement, elementFormDefault), false/*isHeader*/, false/*isMultiple*/);
|
||
|
|
if (parts[i] == null)
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
return parts;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override string ImportType(MessagePartDescription part, XmlQualifiedName typeName, bool isEncoded)
|
||
|
|
{
|
||
|
|
if (isEncoded)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxDataContractSerializerDoesNotSupportEncoded, part.Name)));
|
||
|
|
DataContractImporter.Import(schemaSet, typeName);
|
||
|
|
CodeTypeReference typeRef = DataContractImporter.GetCodeTypeReference(typeName);
|
||
|
|
ICollection<CodeTypeReference> knownTypeRefs = DataContractImporter.GetKnownTypeReferences(typeName);
|
||
|
|
DataContractSerializerOperationGenerator.Add(part, typeRef, knownTypeRefs, false/*IsNonNillableReferenceType*/);
|
||
|
|
if (typeRef.ArrayRank == 0)
|
||
|
|
return typeRef.BaseType;
|
||
|
|
else
|
||
|
|
return typeRef.BaseType + "[]";
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static bool TryGetFailedReferenceType(Exception ex, out Type failedReferenceType)
|
||
|
|
{
|
||
|
|
if (null == ex)
|
||
|
|
throw new ArgumentNullException("ex");
|
||
|
|
|
||
|
|
if (ex.Data.Contains(FailedReferenceTypeExceptionKey))
|
||
|
|
{
|
||
|
|
failedReferenceType = ex.Data[FailedReferenceTypeExceptionKey] as Type;
|
||
|
|
if (null != failedReferenceType)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
failedReferenceType = null;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override string ImportElement(MessagePartDescription part, XmlSchemaElement element, bool isEncoded)
|
||
|
|
{
|
||
|
|
if (part.Multiple)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxDataContractSerializerDoesNotSupportBareArray, part.Name)));
|
||
|
|
XmlQualifiedName typeName = null;
|
||
|
|
Type failedReferenceType;
|
||
|
|
|
||
|
|
while (null == typeName)
|
||
|
|
{
|
||
|
|
try
|
||
|
|
{
|
||
|
|
typeName = DataContractImporter.Import(schemaSet, element);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
catch (InvalidDataContractException ex)
|
||
|
|
{
|
||
|
|
if (TryGetFailedReferenceType(ex, out failedReferenceType))
|
||
|
|
{
|
||
|
|
DataContractImporter.Options.ReferencedTypes.Remove(failedReferenceType);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
throw;
|
||
|
|
}
|
||
|
|
catch (InvalidOperationException ex)
|
||
|
|
{
|
||
|
|
if (TryGetFailedReferenceType(ex, out failedReferenceType))
|
||
|
|
{
|
||
|
|
DataContractImporter.Options.ReferencedTypes.Remove(failedReferenceType);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
throw;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
CodeTypeReference typeRef = DataContractImporter.GetCodeTypeReference(typeName, element);
|
||
|
|
ICollection<CodeTypeReference> knownTypeRefs = DataContractImporter.GetKnownTypeReferences(typeName);
|
||
|
|
DataContractSerializerOperationGenerator.Add(part, typeRef, knownTypeRefs, !element.IsNillable && !IsValueType(typeName));
|
||
|
|
if (typeRef.ArrayRank == 0)
|
||
|
|
return typeRef.BaseType;
|
||
|
|
else
|
||
|
|
return typeRef.BaseType + "[]";
|
||
|
|
}
|
||
|
|
|
||
|
|
private bool IsValueType(XmlQualifiedName typeName)
|
||
|
|
{
|
||
|
|
XmlSchemaElement element = new XmlSchemaElement();
|
||
|
|
element.IsNillable = true;
|
||
|
|
CodeTypeReference typeRef = DataContractImporter.GetCodeTypeReference(typeName, element);
|
||
|
|
return typeRef.BaseType == typeof(Nullable<>).FullName;
|
||
|
|
}
|
||
|
|
|
||
|
|
int SetImportXmlType(bool value)
|
||
|
|
{
|
||
|
|
if (DataContractImporter.Options == null)
|
||
|
|
{
|
||
|
|
DataContractImporter.Options = new ImportOptions();
|
||
|
|
DataContractImporter.Options.ImportXmlType = value;
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
if (DataContractImporter.Options.ImportXmlType != value)
|
||
|
|
{
|
||
|
|
DataContractImporter.Options.ImportXmlType = value;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
void RestoreImportXmlType(int oldValue)
|
||
|
|
{
|
||
|
|
if (oldValue == 1)
|
||
|
|
return;
|
||
|
|
if (oldValue == 0)
|
||
|
|
{
|
||
|
|
DataContractImporter.Options.ImportXmlType = !DataContractImporter.Options.ImportXmlType;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
DataContractImporter.Options = null;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override CodeTypeReference ImportFaultElement(XmlQualifiedName elementName, XmlSchemaElement element, bool isEncoded)
|
||
|
|
{
|
||
|
|
int oldValue = SetImportXmlType(true);
|
||
|
|
try
|
||
|
|
{
|
||
|
|
XmlQualifiedName typeName = DataContractImporter.Import(schemaSet, element);
|
||
|
|
return DataContractImporter.GetCodeTypeReference(typeName, element);
|
||
|
|
}
|
||
|
|
finally
|
||
|
|
{
|
||
|
|
RestoreImportXmlType(oldValue);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal bool CanImportFaultElement(XmlSchemaElement element)
|
||
|
|
{
|
||
|
|
int oldValue = SetImportXmlType(false);
|
||
|
|
try
|
||
|
|
{
|
||
|
|
return DataContractImporter.CanImport(schemaSet, element);
|
||
|
|
}
|
||
|
|
finally
|
||
|
|
{
|
||
|
|
RestoreImportXmlType(oldValue);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override CodeTypeReference ImportFaultType(XmlQualifiedName elementName, XmlQualifiedName typeName, bool isEncoded)
|
||
|
|
{
|
||
|
|
int oldValue = SetImportXmlType(true);
|
||
|
|
try
|
||
|
|
{
|
||
|
|
DataContractImporter.Import(schemaSet, typeName);
|
||
|
|
return DataContractImporter.GetCodeTypeReference(typeName);
|
||
|
|
}
|
||
|
|
finally
|
||
|
|
{
|
||
|
|
RestoreImportXmlType(oldValue);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal bool CanImportFaultType(XmlQualifiedName typeName)
|
||
|
|
{
|
||
|
|
int oldValue = SetImportXmlType(false);
|
||
|
|
try
|
||
|
|
{
|
||
|
|
return DataContractImporter.CanImport(schemaSet, typeName);
|
||
|
|
}
|
||
|
|
finally
|
||
|
|
{
|
||
|
|
RestoreImportXmlType(oldValue);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void PreprocessSchema()
|
||
|
|
{
|
||
|
|
errors = new Collection<MetadataConversionError>();
|
||
|
|
compileValidationEventHandler = new ValidationEventHandler(delegate(object sender, ValidationEventArgs args)
|
||
|
|
{
|
||
|
|
SchemaHelper.HandleSchemaValidationError(sender, args, errors);
|
||
|
|
}
|
||
|
|
);
|
||
|
|
schemaSet.ValidationEventHandler += compileValidationEventHandler;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void PostprocessSchema(bool used)
|
||
|
|
{
|
||
|
|
if (used && errors != null)
|
||
|
|
{
|
||
|
|
foreach (MetadataConversionError error in errors)
|
||
|
|
importer.Errors.Add(error);
|
||
|
|
errors.Clear();
|
||
|
|
}
|
||
|
|
schemaSet.ValidationEventHandler -= compileValidationEventHandler;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override IOperationBehavior GetOperationGenerator()
|
||
|
|
{
|
||
|
|
return DataContractSerializerOperationGenerator;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override bool CanImportStyleAndUse(OperationFormatStyle style, bool isEncoded)
|
||
|
|
{
|
||
|
|
return !isEncoded;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void ValidateStyleAndUse(OperationFormatStyle style, bool isEncoded, string operationName)
|
||
|
|
{
|
||
|
|
if (isEncoded)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxDataContractSerializerDoesNotSupportEncoded, operationName)));
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void SetOperationStyle(OperationDescription operation, OperationFormatStyle style)
|
||
|
|
{
|
||
|
|
DataContractSerializerOperationBehavior operationBehavior = operation.Behaviors.Find<DataContractSerializerOperationBehavior>();
|
||
|
|
if (operationBehavior == null)
|
||
|
|
{
|
||
|
|
operationBehavior = new DataContractSerializerOperationBehavior(operation, new DataContractFormatAttribute());
|
||
|
|
operation.Behaviors.Add(operationBehavior);
|
||
|
|
}
|
||
|
|
operationBehavior.DataContractFormatAttribute.Style = style;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override bool GetOperationIsEncoded(OperationDescription operation)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void SetOperationIsEncoded(OperationDescription operation, bool isEncoded)
|
||
|
|
{
|
||
|
|
if (isEncoded)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxDataContractSerializerDoesNotSupportEncoded, operation.Name)));
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void SetOperationSupportFaults(OperationDescription operation, bool supportFaults)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override string GetFormatName()
|
||
|
|
{
|
||
|
|
return "DataContract";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal class XmlSerializerSchemaImporter : SchemaImporter
|
||
|
|
{
|
||
|
|
XmlSerializerOperationGenerator xmlSerializerOperationGenerator;
|
||
|
|
XmlSchemaImporter xmlImporter;
|
||
|
|
SoapSchemaImporter soapImporter;
|
||
|
|
CodeDomProvider codeProvider;
|
||
|
|
XmlSchemas literalSchemas, encodedSchemas;
|
||
|
|
public XmlSerializerSchemaImporter(WsdlImporter importer)
|
||
|
|
: base(importer)
|
||
|
|
{
|
||
|
|
|
||
|
|
XmlSerializerImportOptions options;
|
||
|
|
if (importer.State.ContainsKey(typeof(XmlSerializerImportOptions)))
|
||
|
|
{
|
||
|
|
options = (XmlSerializerImportOptions)importer.State[typeof(XmlSerializerImportOptions)];
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
object compileUnit;
|
||
|
|
if (!importer.State.TryGetValue(typeof(CodeCompileUnit), out compileUnit))
|
||
|
|
{
|
||
|
|
compileUnit = new CodeCompileUnit();
|
||
|
|
importer.State.Add(typeof(CodeCompileUnit), compileUnit);
|
||
|
|
}
|
||
|
|
options = new XmlSerializerImportOptions((CodeCompileUnit)compileUnit);
|
||
|
|
importer.State.Add(typeof(XmlSerializerImportOptions), options);
|
||
|
|
}
|
||
|
|
WsdlNS.WebReferenceOptions webReferenceOptions = options.WebReferenceOptions;
|
||
|
|
codeProvider = options.CodeProvider;
|
||
|
|
|
||
|
|
encodedSchemas = new XmlSchemas();
|
||
|
|
literalSchemas = new XmlSchemas();
|
||
|
|
CollectEncodedAndLiteralSchemas(importer.WsdlDocuments, encodedSchemas, literalSchemas, schemaSet);
|
||
|
|
|
||
|
|
CodeIdentifiers codeIdentifiers = new CodeIdentifiers();
|
||
|
|
|
||
|
|
//SchemaImporter.ctor is not thread safe: MB49115, VSWhidbey580396
|
||
|
|
lock (schemaImporterLock)
|
||
|
|
{
|
||
|
|
xmlImporter = new XmlSchemaImporter(literalSchemas, webReferenceOptions.CodeGenerationOptions, options.CodeProvider, new ImportContext(codeIdentifiers, false));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (webReferenceOptions != null)
|
||
|
|
{
|
||
|
|
foreach (string extTypeName in webReferenceOptions.SchemaImporterExtensions)
|
||
|
|
{
|
||
|
|
xmlImporter.Extensions.Add(extTypeName, Type.GetType(extTypeName, true /*throwOnError*/));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
//SchemaImporter.ctor is not thread safe: MB49115, VSWhidbey580396
|
||
|
|
lock (schemaImporterLock)
|
||
|
|
{
|
||
|
|
soapImporter = new SoapSchemaImporter(encodedSchemas, webReferenceOptions.CodeGenerationOptions, options.CodeProvider, new ImportContext(codeIdentifiers, false));
|
||
|
|
}
|
||
|
|
xmlSerializerOperationGenerator = new XmlSerializerOperationGenerator(options);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override bool CanImportElement(XmlSchemaElement element)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override bool CanImportType(XmlQualifiedName typeName)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override bool CanImportWrapperElement(XmlQualifiedName elementName)
|
||
|
|
{
|
||
|
|
string ns;
|
||
|
|
XmlSchemaForm elementFormDefault;
|
||
|
|
XmlSchemaComplexType complexType = GetElementComplexType(elementName, schemaSet, out ns, out elementFormDefault);
|
||
|
|
if (complexType == null)
|
||
|
|
return false;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override bool CanImportFault(XmlSchemaElement detailElement, XmlQualifiedName detailElementTypeName)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static XmlSerializerSchemaImporter Get(WsdlImporter importer)
|
||
|
|
{
|
||
|
|
Type type = typeof(XmlSerializerSchemaImporter);
|
||
|
|
object schemaImporter;
|
||
|
|
if (importer.State.ContainsKey(type))
|
||
|
|
schemaImporter = importer.State[type];
|
||
|
|
else
|
||
|
|
{
|
||
|
|
schemaImporter = new XmlSerializerSchemaImporter(importer);
|
||
|
|
importer.State.Add(type, schemaImporter);
|
||
|
|
}
|
||
|
|
return (XmlSerializerSchemaImporter)schemaImporter;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override MessagePartDescription[] ImportWrapperElement(XmlQualifiedName elementName)
|
||
|
|
{
|
||
|
|
XmlMembersMapping membersMapping = xmlImporter.ImportMembersMapping(elementName);
|
||
|
|
ArrayList parts = new ArrayList();
|
||
|
|
for (int i = 0; i < membersMapping.Count; i++)
|
||
|
|
{
|
||
|
|
XmlMemberMapping member = membersMapping[i];
|
||
|
|
string xmlName = NamingHelper.XmlName(member.MemberName);
|
||
|
|
MessagePartDescription part = new MessagePartDescription(xmlName, member.Namespace == null ? string.Empty : member.Namespace);
|
||
|
|
xmlSerializerOperationGenerator.Add(part, member, membersMapping, false/*isEncoded*/);
|
||
|
|
part.BaseType = member.GenerateTypeName(codeProvider);
|
||
|
|
parts.Add(part);
|
||
|
|
}
|
||
|
|
return (MessagePartDescription[])parts.ToArray(typeof(MessagePartDescription));
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override CodeTypeReference ImportFaultElement(XmlQualifiedName elementName, XmlSchemaElement element, bool isEncoded)
|
||
|
|
{
|
||
|
|
if (isEncoded)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxDocEncodedFaultNotSupported)));
|
||
|
|
XmlMembersMapping membersMapping = xmlImporter.ImportMembersMapping(new XmlQualifiedName[] { elementName });
|
||
|
|
this.xmlSerializerOperationGenerator.XmlExporter.ExportMembersMapping(membersMapping);
|
||
|
|
return new CodeTypeReference(this.xmlSerializerOperationGenerator.GetTypeName(membersMapping[0]));
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override CodeTypeReference ImportFaultType(XmlQualifiedName elementName, XmlQualifiedName typeName, bool isEncoded)
|
||
|
|
{
|
||
|
|
XmlName memberName = new XmlName(elementName.Name, true /*isEncoded*/);
|
||
|
|
string memberNs = elementName.Namespace;
|
||
|
|
XmlMembersMapping membersMapping;
|
||
|
|
SoapSchemaMember schemaMember = new SoapSchemaMember();
|
||
|
|
schemaMember.MemberName = memberName.EncodedName;
|
||
|
|
schemaMember.MemberType = typeName;
|
||
|
|
if (isEncoded)
|
||
|
|
{
|
||
|
|
membersMapping = soapImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember });
|
||
|
|
this.xmlSerializerOperationGenerator.SoapExporter.ExportMembersMapping(membersMapping);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
membersMapping = xmlImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember });
|
||
|
|
this.xmlSerializerOperationGenerator.XmlExporter.ExportMembersMapping(membersMapping);
|
||
|
|
}
|
||
|
|
return new CodeTypeReference(this.xmlSerializerOperationGenerator.GetTypeName(membersMapping[0]));
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override string ImportType(MessagePartDescription part, XmlQualifiedName typeName, bool isEncoded)
|
||
|
|
{
|
||
|
|
XmlName memberName = new XmlName(part.Name, true /*isEncoded*/);
|
||
|
|
string memberNs = part.Namespace;
|
||
|
|
XmlMembersMapping membersMapping;
|
||
|
|
SoapSchemaMember schemaMember = new SoapSchemaMember();
|
||
|
|
schemaMember.MemberName = memberName.EncodedName;
|
||
|
|
schemaMember.MemberType = typeName;
|
||
|
|
if (isEncoded)
|
||
|
|
membersMapping = soapImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember });
|
||
|
|
else
|
||
|
|
membersMapping = xmlImporter.ImportMembersMapping(memberName.DecodedName, memberNs, new SoapSchemaMember[] { schemaMember });
|
||
|
|
return AddPartType(part, membersMapping, isEncoded);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override string ImportElement(MessagePartDescription part, XmlSchemaElement element, bool isEncoded)
|
||
|
|
{
|
||
|
|
if (isEncoded)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxDocEncodedNotSupported, part.Name)));
|
||
|
|
XmlMembersMapping membersMapping = xmlImporter.ImportMembersMapping(new XmlQualifiedName[] { element.QualifiedName });
|
||
|
|
return AddPartType(part, membersMapping, isEncoded);
|
||
|
|
}
|
||
|
|
|
||
|
|
private string AddPartType(MessagePartDescription part, XmlMembersMapping membersMapping, bool isEncoded)
|
||
|
|
{
|
||
|
|
xmlSerializerOperationGenerator.Add(part, membersMapping[0], membersMapping, isEncoded);
|
||
|
|
return membersMapping[0].GenerateTypeName(codeProvider);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void PreprocessSchema()
|
||
|
|
{
|
||
|
|
XmlSchema wsdl = StockSchemas.CreateWsdl();
|
||
|
|
XmlSchema soap = StockSchemas.CreateSoap();
|
||
|
|
XmlSchema soapEncoding = StockSchemas.CreateSoapEncoding();
|
||
|
|
XmlSchema fakeXsdSchema = StockSchemas.CreateFakeXsdSchema();
|
||
|
|
XmlSchema fakeXmlSchema = StockSchemas.CreateFakeXmlSchema();
|
||
|
|
|
||
|
|
schemaSet.Add(wsdl);
|
||
|
|
schemaSet.Add(soap);
|
||
|
|
schemaSet.Add(soapEncoding);
|
||
|
|
schemaSet.Add(fakeXsdSchema);
|
||
|
|
schemaSet.Add(fakeXmlSchema);
|
||
|
|
SchemaHelper.Compile(schemaSet, importer.Errors);
|
||
|
|
schemaSet.Remove(wsdl);
|
||
|
|
schemaSet.Remove(soap);
|
||
|
|
schemaSet.Remove(soapEncoding);
|
||
|
|
schemaSet.Remove(fakeXsdSchema);
|
||
|
|
schemaSet.Remove(fakeXmlSchema);
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void PostprocessSchema(bool used)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override IOperationBehavior GetOperationGenerator()
|
||
|
|
{
|
||
|
|
return xmlSerializerOperationGenerator;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override bool CanImportStyleAndUse(OperationFormatStyle style, bool isEncoded)
|
||
|
|
{
|
||
|
|
// Intentionally return true in all cases. Warning will be generated later if there are multiple bindings and one is doc-encoded.
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void ValidateStyleAndUse(OperationFormatStyle style, bool isEncoded, string operationName)
|
||
|
|
{
|
||
|
|
if (isEncoded && style != OperationFormatStyle.Rpc)
|
||
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxDocEncodedNotSupported, operationName)));
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static XmlSerializerFormatAttribute GetFormatAttribute(OperationDescription operation, bool createNew)
|
||
|
|
{
|
||
|
|
XmlSerializerOperationBehavior operationBehavior = operation.Behaviors.Find<XmlSerializerOperationBehavior>();
|
||
|
|
|
||
|
|
if (operationBehavior != null)
|
||
|
|
return operationBehavior.XmlSerializerFormatAttribute;
|
||
|
|
if (!createNew)
|
||
|
|
return null;
|
||
|
|
operationBehavior = new XmlSerializerOperationBehavior(operation);
|
||
|
|
operation.Behaviors.Add(operationBehavior);
|
||
|
|
return operationBehavior.XmlSerializerFormatAttribute;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void SetOperationStyle(OperationDescription operation, OperationFormatStyle style)
|
||
|
|
{
|
||
|
|
XmlSerializerFormatAttribute operationAttribute = GetFormatAttribute(operation, true/*createNew*/);
|
||
|
|
operationAttribute.Style = style;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override bool GetOperationIsEncoded(OperationDescription operation)
|
||
|
|
{
|
||
|
|
XmlSerializerFormatAttribute operationAttribute = GetFormatAttribute(operation, false /*createNew*/);
|
||
|
|
if (operationAttribute == null)
|
||
|
|
return TypeLoader.DefaultXmlSerializerFormatAttribute.IsEncoded;
|
||
|
|
return operationAttribute.IsEncoded;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void SetOperationIsEncoded(OperationDescription operation, bool isEncoded)
|
||
|
|
{
|
||
|
|
XmlSerializerFormatAttribute operationAttribute = GetFormatAttribute(operation, true/*createNew*/);
|
||
|
|
operationAttribute.IsEncoded = isEncoded;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override void SetOperationSupportFaults(OperationDescription operation, bool supportFaults)
|
||
|
|
{
|
||
|
|
XmlSerializerFormatAttribute operationAttribute = GetFormatAttribute(operation, true/*createNew*/);
|
||
|
|
operationAttribute.SupportFaults = supportFaults;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal override string GetFormatName()
|
||
|
|
{
|
||
|
|
return "XmlSerializer";
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
class OperationInfo
|
||
|
|
{
|
||
|
|
OperationFormatStyle style;
|
||
|
|
bool isEncoded;
|
||
|
|
bool areAllMessagesWrapped;
|
||
|
|
|
||
|
|
internal OperationInfo(OperationFormatStyle style, bool isEncoded, bool areAllMessagesWrapped)
|
||
|
|
{
|
||
|
|
this.style = style;
|
||
|
|
this.isEncoded = isEncoded;
|
||
|
|
this.areAllMessagesWrapped = areAllMessagesWrapped;
|
||
|
|
}
|
||
|
|
internal OperationFormatStyle Style { get { return style; } }
|
||
|
|
internal bool IsEncoded { get { return isEncoded; } }
|
||
|
|
internal bool AreAllMessagesWrapped { get { return areAllMessagesWrapped; } }
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
internal delegate void WsdlWarningHandler(string warning);
|
||
|
|
|
||
|
|
static class ValidWsdl
|
||
|
|
{
|
||
|
|
internal static bool Check(WsdlNS.SoapHeaderBinding soapHeaderBinding, WsdlNS.MessageBinding messageBinding, WsdlWarningHandler warningHandler)
|
||
|
|
{
|
||
|
|
if (soapHeaderBinding.Message == null || soapHeaderBinding.Message.IsEmpty)
|
||
|
|
{
|
||
|
|
string reason = SR.GetString(SR.XsdMissingRequiredAttribute1, "message");
|
||
|
|
string warning = SR.GetString(SR.IgnoreSoapHeaderBinding3, messageBinding.OperationBinding.Name, messageBinding.OperationBinding.Binding.ServiceDescription.TargetNamespace, reason);
|
||
|
|
warningHandler(warning);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (string.IsNullOrEmpty(soapHeaderBinding.Part))
|
||
|
|
{
|
||
|
|
string reason = SR.GetString(SR.XsdMissingRequiredAttribute1, "part");
|
||
|
|
string warning = SR.GetString(SR.IgnoreSoapHeaderBinding3, messageBinding.OperationBinding.Name, messageBinding.OperationBinding.Binding.ServiceDescription.TargetNamespace, reason);
|
||
|
|
warningHandler(warning);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static bool Check(WsdlNS.SoapFaultBinding soapFaultBinding, WsdlNS.FaultBinding faultBinding, WsdlWarningHandler warningHandler)
|
||
|
|
{
|
||
|
|
if (string.IsNullOrEmpty(soapFaultBinding.Name))
|
||
|
|
{
|
||
|
|
string reason = SR.GetString(SR.XsdMissingRequiredAttribute1, "name");
|
||
|
|
string warning = SR.GetString(SR.IgnoreSoapFaultBinding3, faultBinding.OperationBinding.Name, faultBinding.OperationBinding.Binding.ServiceDescription.TargetNamespace, reason);
|
||
|
|
warningHandler(warning);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
internal static bool Check(WsdlNS.MessagePart part, WsdlNS.Message message, WsdlWarningHandler warningHandler)
|
||
|
|
{
|
||
|
|
// check required name attribute, do not check NCName validity
|
||
|
|
if (string.IsNullOrEmpty(part.Name))
|
||
|
|
{
|
||
|
|
string reason = SR.GetString(SR.XsdMissingRequiredAttribute1, "name");
|
||
|
|
string warning = SR.GetString(SR.IgnoreMessagePart3, message.Name, message.ServiceDescription.TargetNamespace, reason);
|
||
|
|
warningHandler(warning);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|