public CustomPolicyConversionContext (WS.Binding binding, ServiceEndpoint endpoint)
: base (endpoint)
{
this.binding = binding;
assertions = new PolicyAssertionCollection ();
binding_elements = ((CustomBinding)endpoint.Binding).Elements;
}
internal WsdlContractConversionContext(ContractDescription contract, WsdlNS.PortType wsdlPortType)
{
this.contract = contract;
this.wsdlPortType = wsdlPortType;
this.wsdlOperations = new Dictionary<OperationDescription, WsdlNS.Operation>();
this.operationDescriptions = new Dictionary<WsdlNS.Operation, OperationDescription>();
this.wsdlOperationMessages = new Dictionary<MessageDescription, WsdlNS.OperationMessage>();
this.messageDescriptions = new Dictionary<WsdlNS.OperationMessage, MessageDescription>();
this.wsdlOperationFaults = new Dictionary<FaultDescription, WsdlNS.OperationFault>();
this.faultDescriptions = new Dictionary<WsdlNS.OperationFault, FaultDescription>();
this.operationBindings = new Dictionary<WsdlNS.Operation, Collection<WsdlNS.OperationBinding>>();
}
internal WsdlEndpointConversionContext(WsdlEndpointConversionContext bindingContext, ServiceEndpoint endpoint, WsdlNS.Port wsdlport)
{
this.endpoint = endpoint;
this.wsdlBinding = bindingContext.WsdlBinding;
this.wsdlPort = wsdlport;
this.contractContext = bindingContext.contractContext;
this.wsdlOperationBindings = bindingContext.wsdlOperationBindings;
this.operationDescriptionBindings = bindingContext.operationDescriptionBindings;
this.wsdlMessageBindings = bindingContext.wsdlMessageBindings;
this.messageDescriptionBindings = bindingContext.messageDescriptionBindings;
this.wsdlFaultBindings = bindingContext.wsdlFaultBindings;
this.faultDescriptionBindings = bindingContext.faultDescriptionBindings;
}
internal WsdlEndpointConversionContext(WsdlContractConversionContext contractContext, ServiceEndpoint endpoint, WsdlNS.Binding wsdlBinding, WsdlNS.Port wsdlport)
{
this.endpoint = endpoint;
this.wsdlBinding = wsdlBinding;
this.wsdlPort = wsdlport;
this.contractContext = contractContext;
this.wsdlOperationBindings = new Dictionary<OperationDescription, WsdlNS.OperationBinding>();
this.operationDescriptionBindings = new Dictionary<WsdlNS.OperationBinding, OperationDescription>();
this.wsdlMessageBindings = new Dictionary<MessageDescription, WsdlNS.MessageBinding>();
this.messageDescriptionBindings = new Dictionary<WsdlNS.MessageBinding, MessageDescription>();
this.wsdlFaultBindings = new Dictionary<FaultDescription, WsdlNS.FaultBinding>();
this.faultDescriptionBindings = new Dictionary<WsdlNS.FaultBinding, FaultDescription>();
}
static bool ContainsHttpBindingExtension(WsdlNS.Binding wsdlBinding)
{
//avoiding using wsdlBinding.Extensions.Find(typeof(WsdlNS.HttpBinding)) so the extension won't be marked as handled
foreach (object extension in wsdlBinding.Extensions)
{
if (extension is WsdlNS.HttpBinding)
{
string httpVerb = ((WsdlNS.HttpBinding)extension).Verb;
if (httpVerb.Equals("GET", StringComparison.OrdinalIgnoreCase) || httpVerb.Equals("POST", StringComparison.OrdinalIgnoreCase))
{
return true;
}
}
}
return false;
}
public void BeforeImport(WsdlNS.ServiceDescriptionCollection wsdlDocuments, Xml.Schema.XmlSchemaSet xmlSchemas, ICollection<Xml.XmlElement> policy)
{
foreach (WsdlNS.ServiceDescription wsdl in wsdlDocuments)
{
if (wsdl != null)
{
foreach (WsdlNS.Binding wsdlBinding in wsdl.Bindings)
{
if (wsdlBinding != null && wsdlBinding.Extensions != null)
{
WsdlNS.SoapBinding soapBinding = (WsdlNS.SoapBinding)wsdlBinding.Extensions.Find(typeof(WsdlNS.SoapBinding));
if (soapBinding != null)
{
string transportUri = soapBinding.Transport;
if (!string.IsNullOrEmpty(transportUri) && transportUri.Equals(UdpConstants.WsdlSoapUdpTransportUri, StringComparison.Ordinal))
{
WsdlImporter.SoapInPolicyWorkaroundHelper.InsertAdHocPolicy(wsdlBinding, soapBinding.Transport, this.udpTransportUriKey);
}
}
}
}
}
}
}
static void TestSoapBody (WS.SoapBodyBinding soap, bool soap12, TestLabel label)
{
label.EnterScope ("soap-body");
var type = soap12 ? typeof (WS.Soap12BodyBinding) : typeof (WS.SoapBodyBinding);
Assert.That (soap.GetType (), Is.EqualTo (type), label.Get ());
Assert.That (soap.Encoding, Is.Empty, label.Get ());
Assert.That (soap.Namespace, Is.Empty, label.Get ());
Assert.That (soap.Parts, Is.Null, label.Get ());
Assert.That (soap.Use, Is.EqualTo (WS.SoapBindingUse.Literal), label.Get ());
label.LeaveScope ();
}
static void TestSoap (WS.SoapOperationBinding soap, bool soap12, TestLabel label)
{
label.EnterScope ("soap");
var type = soap12 ? typeof (WS.Soap12OperationBinding) : typeof (WS.SoapOperationBinding);
Assert.That (soap.GetType (), Is.EqualTo (type), label.Get ());
Assert.That (soap.Style, Is.EqualTo (WS.SoapBindingStyle.Document), label.Get ());
Assert.That (soap.SoapAction, Is.EqualTo ("http://tempuri.org/IMyContract/Hello"), label.Get ());
Assert.That (soap.Required, Is.False, label.Get ());
label.LeaveScope ();
}
public static PolicyAssertionCollection AssertPolicy (
WS.Binding binding, TestLabel label)
{
label.EnterScope ("FindPolicy");
XmlElement policy = null;
foreach (var extension in binding.Extensions) {
var xml = extension as XmlElement;
if (xml == null)
continue;
Assert.That (policy, Is.Null, label.Get ());
policy = xml;
}
Assert.That (policy, Is.Not.Null, label.Get ());
try {
return AssertPolicy (binding.ServiceDescription, policy, label);
} finally {
label.LeaveScope ();
}
}
void AddToMetadataIfNotNull(WSDescription.ServiceDescription serviceDescription)
{
if (serviceDescription != null) {
AddMetadataSection(MetadataSection.ServiceDescriptionDialect, serviceDescription);
}
}
void ExportMessageBodyBinding(MessageDescription messageDescription, bool isRpc, bool isEncoded, WsdlNS.MessageBinding messageBinding)
{
WsdlNS.SoapBodyBinding bodyBinding = SoapHelper.GetOrCreateSoapBodyBinding(endpointContext, messageBinding, exporter);
if (bodyBinding == null)
return;
bodyBinding.Use = isEncoded ? WsdlNS.SoapBindingUse.Encoded : WsdlNS.SoapBindingUse.Literal;
if (isRpc)
{
string ns;
if (!ExportedMessages.WrapperNamespaces.TryGetValue(new MessageDescriptionDictionaryKey(endpointContext.ContractConversionContext.Contract, messageDescription), out ns))
ns = messageDescription.Body.WrapperNamespace;
bodyBinding.Namespace = ns;
}
if (isEncoded)
bodyBinding.Encoding = XmlSerializerOperationFormatter.GetEncoding(soapVersion);
}
protected void ExportMessagePart(WsdlNS.Message message, MessagePartDescription part, XmlQualifiedName typeName, XmlSchemaType xsdType, bool isOptional, bool isNillable, bool skipSchemaExport, bool generateElement, string wrapperNs, XmlSchemaSequence wrapperSequence, XmlSchemaSet schemaSet)
{
if (IsNullOrEmpty(typeName) && xsdType == null)
return;
#if DEBUG
if (xsdType == null)
Fx.Assert(NamingHelper.IsValidNCName(typeName.Name), "Name value has to be a valid NCName.");
#endif
string elementName = part.Name;
string partName = string.IsNullOrEmpty(part.UniquePartName) ? elementName : part.UniquePartName;
WsdlNS.MessagePart wsdlPart = null;
if (generateElement)
{
if (wrapperSequence != null)
{
if (!skipSchemaExport)
ExportLocalElement(wrapperNs, partName, part.Namespace, typeName, xsdType, part.Multiple, isOptional, isNillable, wrapperSequence, schemaSet);
}
else
{
if (!skipSchemaExport)
ExportGlobalElement(elementName, part.Namespace, isNillable, typeName, xsdType, schemaSet);
wsdlPart = AddMessagePart(message, partName, new XmlQualifiedName(elementName, part.Namespace), XmlQualifiedName.Empty);
}
}
else
{
if (String.IsNullOrEmpty(typeName.Name))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxAnonymousTypeNotSupported, message.Name, partName)));
wsdlPart = AddMessagePart(message, partName, XmlQualifiedName.Empty, typeName);
}
if (wsdlPart != null)
{
part.UniquePartName = wsdlPart.Name;
}
}
void ExportMembersMapping(XmlMembersMapping membersMapping, WsdlNS.Message message, bool skipSchemaExport, bool isEncoded, bool isRpc, bool isDocWrapped, bool isHeader)
{
if (!skipSchemaExport)
{
if (isEncoded)
SoapExporter.ExportMembersMapping(membersMapping);
else
XmlExporter.ExportMembersMapping(membersMapping, !isRpc);
}
if (isDocWrapped)
{
if (isHeader)
{
Fx.Assert("Header cannot be Document Wrapped");
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Header cannot be Document Wrapped")));
}
AddMessagePart(message, "parameters", new XmlQualifiedName(membersMapping.XsdElementName, membersMapping.Namespace), XmlQualifiedName.Empty);
return;
}
bool generateElement = !isRpc && !isEncoded;
for (int i = 0; i < membersMapping.Count; i++)
{
XmlMemberMapping member = membersMapping[i];
string partName = (isHeader || generateElement) ? NamingHelper.XmlName(member.MemberName) : member.XsdElementName;
if (generateElement)
AddMessagePart(message, partName, new XmlQualifiedName(member.XsdElementName, member.Namespace), XmlQualifiedName.Empty);
else
{
if (string.IsNullOrEmpty(member.TypeName))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.SFxAnonymousTypeNotSupported, message.Name, partName)));
AddMessagePart(message, partName, XmlQualifiedName.Empty, new XmlQualifiedName(member.TypeName, member.TypeNamespace));
}
}
}
static string CreateFaultBindingPolicyKey(WsdlNS.FaultBinding wsdlFaultBinding)
{
WsdlNS.OperationBinding wsdlOperationBinding = wsdlFaultBinding.OperationBinding;
WsdlNS.Binding wsdlBinding = wsdlOperationBinding.Binding;
if (string.IsNullOrEmpty(wsdlFaultBinding.Name))
{
return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_Fault", wsdlBinding.Name, wsdlOperationBinding.Name);
}
else
{
return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_{2}_Fault", wsdlBinding.Name, wsdlOperationBinding.Name, wsdlFaultBinding.Name);
}
}
static string CreateMessageBindingPolicyKey(WsdlNS.MessageBinding wsdlMessageBinding, MessageDirection direction)
{
WsdlNS.OperationBinding wsdlOperationBinding = wsdlMessageBinding.OperationBinding;
WsdlNS.Binding wsdlBinding = wsdlOperationBinding.Binding;
if (direction == MessageDirection.Input)
return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_Input_policy", wsdlBinding.Name, wsdlOperationBinding.Name);
else
return string.Format(CultureInfo.InvariantCulture, "{0}_{1}_output_policy", wsdlBinding.Name, wsdlOperationBinding.Name);
}
protected bool CreateHeaderMessage(MessageDescription message, out WsdlNS.Message wsdlMessage)
{
wsdlMessage = null;
if (ExportedMessages.WsdlHeaderMessages.ContainsKey(new MessageDescriptionDictionaryKey(contractContext.Contract, message)))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.MultipleCallsToExportContractWithSameContract)));
TypedMessageKey typedMessageKey = null;
if (message.IsTypedMessage)
{
typedMessageKey = new TypedMessageKey(message.MessageType, operation.DeclaringContract.Namespace, GetExtensionData());
if (ExportedMessages.TypedHeaderMessages.TryGetValue(typedMessageKey, out wsdlMessage))
{
this.ExportedMessages.WsdlHeaderMessages.Add(new MessageDescriptionDictionaryKey(contractContext.Contract, message), wsdlMessage);
return false;
}
}
string messageName = GetHeaderMessageName(message);
wsdlMessage = new WsdlNS.Message();
wsdlMessage.Name = messageName;
contractContext.WsdlPortType.ServiceDescription.Messages.Add(wsdlMessage);
if (message.IsTypedMessage)
ExportedMessages.TypedHeaderMessages.Add(typedMessageKey, wsdlMessage);
this.ExportedMessages.WsdlHeaderMessages.Add(new MessageDescriptionDictionaryKey(contractContext.Contract, message), wsdlMessage);
return true;
}
string GetUniqueMessageName(WsdlNS.ServiceDescription wsdl, string messageNameBase)
{
return NamingHelper.GetUniqueName(messageNameBase, DoesMessageNameExist, wsdl);
}
void ExportAnyMessage(WsdlNS.Message message, MessagePartDescription part)
{
XmlSchemaSet schemas = this.exporter.GeneratedXmlSchemas;
XmlSchema schema = SchemaHelper.GetSchema(DataContractSerializerMessageContractImporter.GenericMessageTypeName.Namespace, schemas);
if (!schema.SchemaTypes.Contains(DataContractSerializerMessageContractImporter.GenericMessageTypeName))
{
XmlSchemaComplexType genericMessageType = new XmlSchemaComplexType();
genericMessageType.Name = DataContractSerializerMessageContractImporter.GenericMessageTypeName.Name;
XmlSchemaSequence bodySequence = new XmlSchemaSequence();
genericMessageType.Particle = bodySequence;
XmlSchemaAny anyElement = new XmlSchemaAny();
anyElement.MinOccurs = 0;
anyElement.MaxOccurs = decimal.MaxValue;
anyElement.Namespace = "##any";
bodySequence.Items.Add(anyElement);
SchemaHelper.AddTypeToSchema(genericMessageType, schema, schemas);
}
string partName = string.IsNullOrEmpty(part.UniquePartName) ? part.Name : part.UniquePartName;
WsdlNS.MessagePart wsdlPart = AddMessagePart(message, partName, XmlQualifiedName.Empty, DataContractSerializerMessageContractImporter.GenericMessageTypeName);
part.UniquePartName = wsdlPart.Name;
}
void ExportFaultBinding(FaultDescription fault, bool isEncoded, WsdlNS.OperationBinding operationBinding)
{
SoapHelper.CreateSoapFaultBinding(fault.Name, endpointContext, endpointContext.GetFaultBinding(fault), isEncoded);
}
protected void ExportStreamBody(WsdlNS.Message message, string wrapperName, string wrapperNs, string partName, string partNs, bool isRpc, bool skipSchemaExport)
{
XmlSchemaSet schemas = this.exporter.GeneratedXmlSchemas;
XmlSchema schema = SchemaHelper.GetSchema(DataContractSerializerMessageContractImporter.StreamBodyTypeName.Namespace, schemas);
if (!schema.SchemaTypes.Contains(DataContractSerializerMessageContractImporter.StreamBodyTypeName))
{
XmlSchemaSimpleType streamBodyType = new XmlSchemaSimpleType();
streamBodyType.Name = DataContractSerializerMessageContractImporter.StreamBodyTypeName.Name;
XmlSchemaSimpleTypeRestriction contentRestriction = new XmlSchemaSimpleTypeRestriction();
contentRestriction.BaseTypeName = XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Base64Binary).QualifiedName;
streamBodyType.Content = contentRestriction;
SchemaHelper.AddTypeToSchema(streamBodyType, schema, schemas);
}
XmlSchemaSequence wrapperSequence = null;
if (!isRpc && wrapperName != null)
wrapperSequence = ExportWrappedPart(message, wrapperName, wrapperNs, schemas, skipSchemaExport);
MessagePartDescription streamPart = new MessagePartDescription(partName, partNs);
ExportMessagePart(message, streamPart, DataContractSerializerMessageContractImporter.StreamBodyTypeName, null/*xsdType*/, false/*isOptional*/, false/*isNillable*/, skipSchemaExport, !isRpc, wrapperNs, wrapperSequence, schemas);
}
void ExportMessageHeaderBinding(MessageHeaderDescription header, XmlQualifiedName messageName, bool isEncoded, WsdlNS.MessageBinding messageBinding)
{
#if DEBUG
Fx.Assert(NamingHelper.IsValidNCName(messageName.Name), "Name value has to be a valid NCName.");
#endif
WsdlNS.SoapHeaderBinding headerBinding = SoapHelper.CreateSoapHeaderBinding(endpointContext, messageBinding);
headerBinding.Part = string.IsNullOrEmpty(header.UniquePartName) ? header.Name : header.UniquePartName;
headerBinding.Message = messageName;
headerBinding.Use = isEncoded ? WsdlNS.SoapBindingUse.Encoded : WsdlNS.SoapBindingUse.Literal;
if (isEncoded)
headerBinding.Encoding = XmlSerializerOperationFormatter.GetEncoding(soapVersion);
}
static protected WsdlNS.MessagePart AddMessagePart(WsdlNS.Message message, string partName, XmlQualifiedName elementName, XmlQualifiedName typeName)
{
if (message.Parts[partName] != null)
{
if (IsNullOrEmpty(elementName))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.SFxPartNameMustBeUniqueInRpc, partName)));
int i = 1;
while (message.Parts[partName + i] != null)
{
if (i == Int32.MaxValue)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.SFxTooManyPartsWithSameName, partName)));
i++;
}
partName = partName + i.ToString(CultureInfo.InvariantCulture);
}
WsdlNS.MessagePart part = new WsdlNS.MessagePart();
part.Name = partName;
part.Element = elementName;
part.Type = typeName;
message.Parts.Add(part);
EnsureXsdImport(IsNullOrEmpty(elementName) ? typeName.Namespace : elementName.Namespace, message.ServiceDescription);
return part;
}
static XmlElement ResolvePolicy (WS.ServiceDescription sd, XmlElement policy)
{
if (policy.LocalName.Equals ("Policy"))
return policy;
var uri = policy.GetAttribute ("URI");
if (!uri.StartsWith ("#"))
return null;
foreach (var sext in sd.Extensions) {
var sxml = sext as XmlElement;
if (sxml == null)
continue;
if (!sxml.NamespaceURI.Equals (WspNamespace))
continue;
if (!sxml.LocalName.Equals ("Policy"))
continue;
var id = sxml.GetAttribute ("Id", WsuNamespace);
if (uri.Substring (1).Equals (id))
return sxml;
}
return null;
}
static void EnsureXsdImport(string ns, WsdlNS.ServiceDescription wsdl)
{
string refNs = wsdl.TargetNamespace;
if (!refNs.EndsWith("/", StringComparison.Ordinal))
refNs = refNs + "/Imports";
else
refNs += "Imports";
if (refNs == ns)
refNs = wsdl.TargetNamespace;
XmlSchema xsd = GetContainedSchema(wsdl, refNs);
if (xsd != null)
{
foreach (object include in xsd.Includes)
{
XmlSchemaImport import = include as XmlSchemaImport;
if (import != null && SchemaHelper.NamespacesEqual(import.Namespace, ns))
return;
}
}
else
{
xsd = new XmlSchema();
xsd.TargetNamespace = refNs;
wsdl.Types.Schemas.Add(xsd);
}
XmlSchemaImport imp = new XmlSchemaImport();
if (ns != null && ns.Length > 0)
imp.Namespace = ns;
xsd.Includes.Add(imp);
}
public static PolicyAssertionCollection AssertPolicy (
WS.ServiceDescription sd, XmlElement element, TestLabel label)
{
label.EnterScope ("wsp:Policy");
Assert.That (element.NamespaceURI, Is.EqualTo (WspNamespace), label.Get ());
Assert.That (element.LocalName, Is.EqualTo ("Policy") | Is.EqualTo ("PolicyReference"), label.Get ());
var policy = ResolvePolicy (sd, element);
Assert.That (policy, Is.Not.Null, label.Get ());
label.EnterScope ("wsp:ExactlyOne");
var exactlyOne = AssertExactlyOneChildElement (policy);
Assert.That (exactlyOne, Is.Not.Null, label.Get ());
Assert.That (exactlyOne.NamespaceURI, Is.EqualTo (WspNamespace), label.Get ());
Assert.That (exactlyOne.LocalName, Is.EqualTo ("ExactlyOne"), label.Get ());
label.LeaveScope ();
label.EnterScope ("wsp:Any");
var all = AssertExactlyOneChildElement (exactlyOne);
Assert.That (all, Is.Not.Null, label.Get ());
Assert.That (all.NamespaceURI, Is.EqualTo (WspNamespace), label.Get ());
Assert.That (all.LocalName, Is.EqualTo ("All"), label.Get ());
label.LeaveScope ();
var collection = new PolicyAssertionCollection ();
label.EnterScope ("assertions");
foreach (var node in all.ChildNodes) {
if (node is XmlWhitespace)
continue;
Assert.That (node, Is.InstanceOfType (typeof (XmlElement)), label.ToString ());
collection.Add ((XmlElement)node);
}
label.LeaveScope ();
label.LeaveScope ();
return collection;
}
static XmlSchema GetContainedSchema(WsdlNS.ServiceDescription wsdl, string ns)
{
foreach (XmlSchema xsd in wsdl.Types.Schemas)
if (SchemaHelper.NamespacesEqual(xsd.TargetNamespace, ns))
return xsd;
return null;
}
static void TestSoapMessage (WS.MessageBinding binding, bool soap12, TestLabel label)
{
label.EnterScope (binding is WS.InputBinding ? "input" : "output");
Assert.That (binding, Is.Not.Null, label.Get ());
Assert.That (binding.Name, Is.Null, label.Get ());
Assert.That (binding.ExtensibleAttributes, Is.Null, label.Get ());
Assert.That (binding.Extensions, Is.Not.Null, label.Get ());
Assert.That (binding.Extensions.Count, Is.EqualTo (1), label.Get ());
Assert.That (binding.Extensions [0], Is.InstanceOfType (typeof (WS.SoapBodyBinding)), label.Get ());
var body = (WS.SoapBodyBinding)binding.Extensions [0];
TestSoapBody (body, soap12, label);
label.LeaveScope ();
}
protected XmlSchemaSequence ExportWrappedPart(WsdlNS.Message message, string elementName, string elementNs, XmlSchemaSet schemaSet, bool skipSchemaExport)
{
#if DEBUG
Fx.Assert(NamingHelper.IsValidNCName(elementName), "Name value has to be a valid NCName.");
#endif
AddMessagePart(message, "parameters", new XmlQualifiedName(elementName, elementNs), XmlQualifiedName.Empty);
if (skipSchemaExport)
return emptySequence; //return empty to denote it is wrapped part
XmlSchemaElement wrapperGlobalElement = new XmlSchemaElement();
wrapperGlobalElement.Name = elementName;
XmlSchemaComplexType wrapperType = new XmlSchemaComplexType();
wrapperGlobalElement.SchemaType = wrapperType; // generating an anonymous type for wrapper
XmlSchemaSequence rootSequence = new XmlSchemaSequence();
wrapperType.Particle = rootSequence;
AddElementToSchema(wrapperGlobalElement, elementNs, schemaSet);
return rootSequence;
}
public void BeforeImport(WsdlNS.ServiceDescriptionCollection wsdlDocuments,
System.Xml.Schema.XmlSchemaSet xmlSchemas, ICollection<XmlElement> policy)
{
}
protected bool CreateMessage(MessageDescription message, int messageIndex, out WsdlNS.Message wsdlMessage)
{
wsdlMessage = null;
bool isNewMessage = true;
if (ExportedMessages.WsdlMessages.ContainsKey(new MessageDescriptionDictionaryKey(contractContext.Contract, message)))
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.MultipleCallsToExportContractWithSameContract)));
TypedMessageKey typedMessageKey = null;
OperationMessageKey messageKey = null;
if (message.IsTypedMessage)
{
typedMessageKey = new TypedMessageKey(message.MessageType, operation.DeclaringContract.Namespace, this.GetExtensionData());
if (ExportedMessages.TypedMessages.TryGetValue(typedMessageKey, out wsdlMessage))
isNewMessage = false;
}
else if (operation.OperationMethod != null)
{
messageKey = new OperationMessageKey(operation, messageIndex);
if (ExportedMessages.ParameterMessages.TryGetValue(messageKey, out wsdlMessage))
isNewMessage = false;
}
WsdlNS.ServiceDescription wsdl = contractContext.WsdlPortType.ServiceDescription;
if (isNewMessage)
{
wsdlMessage = new WsdlNS.Message();
wsdlMessage.Name = GetMessageName(message);
wsdl.Messages.Add(wsdlMessage);
if (message.IsTypedMessage)
ExportedMessages.TypedMessages.Add(typedMessageKey, wsdlMessage);
else if (messageKey != null)
ExportedMessages.ParameterMessages.Add(messageKey, wsdlMessage);
}
//Add Name to OperationMessage
WsdlNS.OperationMessage wsdlOperationMessage = contractContext.GetOperationMessage(message);
wsdlOperationMessage.Message = new XmlQualifiedName(wsdlMessage.Name, wsdlMessage.ServiceDescription.TargetNamespace);
this.ExportedMessages.WsdlMessages.Add(new MessageDescriptionDictionaryKey(contractContext.Contract, message), wsdlMessage);
return isNewMessage;
}
