protected override CodeMemberMethod GenerateMethod()
{
try
{
HttpOperationBinding httpOper = OperationBinding.Extensions.Find(typeof(HttpOperationBinding)) as HttpOperationBinding;
if (httpOper == null)
{
throw new Exception("Http operation binding not found");
}
XmlMembersMapping inputMembers = ImportInMembersMapping(InputMessage);
XmlTypeMapping outputMember = ImportOutMembersMapping(OutputMessage);
CodeMemberMethod met = GenerateMethod(memberIds, httpOper, inputMembers, outputMember);
xmlExporter.ExportMembersMapping(inputMembers);
if (outputMember != null)
{
xmlExporter.ExportTypeMapping(outputMember);
}
return(met);
}
catch (Exception ex)
{
UnsupportedOperationBindingWarning(ex.Message);
return(null);
}
}
private void WriteMembersElement(object o, XmlMembersMapping mapping)
{
// #10675: we should implement this method. WCF is the major customer of the method
// as WCF uses XmlReflectionImporter.ImportMembersMapping and generates special
// serializers for OperationContracts.
throw new NotImplementedException();
}
[Category("NotDotNet")] // hangs on .NET 1.1
#endif
public void HandleOutAttributeParameters()
{
XmlReflectionMember m = new XmlReflectionMember();
m.MemberName = "hooray";
m.MemberType = typeof(string);
m.XmlAttributes = new XmlAttributes();
m.XmlAttributes.XmlAttribute = new XmlAttributeAttribute();
XmlReflectionImporter imp = new XmlReflectionImporter();
XmlMembersMapping map = imp.ImportMembersMapping(
"elem", "urn:x", new XmlReflectionMember [] { m }, true);
XmlSerializer ser = XmlSerializer.FromMappings(
new XmlMapping [] { map }) [0];
string xml = "<elem xmlns='urn:x' hooray='doh' />";
object [] arr = ser.Deserialize(new StringReader(xml))
as object [];
Assert.IsNotNull(arr, "#1");
Assert.AreEqual(1, arr.Length, "#2");
Assert.AreEqual("doh", arr [0], "#3");
xml = "<elem xmlns='urn:x' hooray='doh'></elem>";
arr = ser.Deserialize(new StringReader(xml)) as object [];
Assert.IsNotNull(arr, "#4");
Assert.AreEqual(1, arr.Length, "#5");
Assert.AreEqual("doh", arr [0], "#6");
}
XmlSerializer GetSerializer(MessageBodyDescription desc)
{
if (bodySerializers.ContainsKey(desc))
{
return(bodySerializers [desc]);
}
int count = desc.Parts.Count + (HasReturnValue(desc) ? 1 : 0);
XmlReflectionMember [] members = new XmlReflectionMember [count];
int ind = 0;
if (HasReturnValue(desc))
{
members [ind++] = CreateReflectionMember(desc.ReturnValue, true);
}
foreach (MessagePartDescription partDesc in desc.Parts)
{
members [ind++] = CreateReflectionMember(partDesc, false);
}
XmlReflectionImporter xmlImporter = new XmlReflectionImporter();
// Register known types into xmlImporter.
foreach (var type in OperationKnownTypes)
{
xmlImporter.IncludeType(type);
}
XmlMembersMapping [] partsMapping = new XmlMembersMapping [1];
partsMapping [0] = xmlImporter.ImportMembersMapping(desc.WrapperName, desc.WrapperNamespace, members, true);
bodySerializers [desc] = XmlSerializer.FromMappings(partsMapping) [0];
return(bodySerializers [desc]);
}
void CreateEncodedMessage(Message message, MessageBinding messageBinding, XmlMembersMapping members, bool wrapped)
{
SoapExporter.ExportMembersMapping(members, wrapped);
if (wrapped)
{
MessagePart part = new MessagePart();
part.Name = "parameters";
part.Type = new XmlQualifiedName(members.TypeName, members.TypeNamespace);
message.Parts.Add(part);
}
else
{
for (int i = 0; i < members.Count; i++)
{
XmlMemberMapping member = members[i];
MessagePart part = new MessagePart();
part.Name = member.XsdElementName;
part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace);
message.Parts.Add(part);
}
}
messageBinding.Extensions.Add(CreateSoapBodyBinding(SoapBindingUse.Encoded, members.Namespace));
}
private void MoveToMethod(MethodInfo targetMethod)
{
operation = GetOperation(this.wsDescriptions, this.wsBinding, targetMethod);
operationBinding = GetOperationBinding(operation, this.wsBinding);
soapOperationBinding = (SoapOperationBinding)operationBinding.Extensions.Find(typeof(SoapOperationBinding));
string inputMessageName = (!StringUtils.IsNullOrEmpty(operationBinding.Input.Name) && (soapOperationBinding.Style != SoapBindingStyle.Rpc)) ? operationBinding.Input.Name : operation.Name;
SoapBodyBinding inputSoapBodyBinding = (SoapBodyBinding)operationBinding.Input.Extensions.Find(typeof(SoapBodyBinding));
if (inputSoapBodyBinding.Use != SoapBindingUse.Literal)
{
throw new NotSupportedException("WebServiceProxyFactory only supports document-literal and rpc-literal SOAP messages to conform to WS-I Basic Profiles.");
}
Message inputMessage = this.wsDescriptions.GetMessage(operation.Messages.Input.Message);
inputMembersMapping = GetMembersMapping(inputMessageName, inputMessage.Parts, inputSoapBodyBinding, soapOperationBinding.Style);
outputMembersMapping = null;
if (operation.Messages.Output != null)
{
string outputMessageName = (!StringUtils.IsNullOrEmpty(operationBinding.Output.Name) && (soapOperationBinding.Style != SoapBindingStyle.Rpc)) ? operationBinding.Output.Name : (operation.Name + "Response");
SoapBodyBinding outputSoapBodyBinding = (SoapBodyBinding)operationBinding.Output.Extensions.Find(typeof(SoapBodyBinding));
Message outputMessage = this.wsDescriptions.GetMessage(operation.Messages.Output.Message);
outputMembersMapping = GetMembersMapping(outputMessageName, outputMessage.Parts, outputSoapBodyBinding, soapOperationBinding.Style);
}
}
private XmlSerializer[] GenerateSerializers()
{
//this.Mappings may have duplicate mappings (for e.g. same message contract is used by more than one operation)
//XmlSerializer.FromMappings require unique mappings. The following code uniquifies, calls FromMappings and deuniquifies
List <XmlMembersMapping> uniqueMappings = new List <XmlMembersMapping>();
int[] uniqueIndexes = new int[_mappings.Count];
for (int srcIndex = 0; srcIndex < _mappings.Count; srcIndex++)
{
XmlMembersMapping mapping = _mappings[srcIndex];
int uniqueIndex = uniqueMappings.IndexOf(mapping);
if (uniqueIndex < 0)
{
uniqueMappings.Add(mapping);
uniqueIndex = uniqueMappings.Count - 1;
}
uniqueIndexes[srcIndex] = uniqueIndex;
}
XmlSerializer[] uniqueSerializers = CreateSerializersFromMappings(uniqueMappings.ToArray(), _type);
if (uniqueMappings.Count == _mappings.Count)
{
return(uniqueSerializers);
}
XmlSerializer[] serializers = new XmlSerializer[_mappings.Count];
for (int i = 0; i < _mappings.Count; i++)
{
serializers[i] = uniqueSerializers[uniqueIndexes[i]];
}
return(serializers);
}
protected override void ExportBody(int messageIndex, object state)
{
MessageDescription messageDescription = base.operation.Messages[messageIndex];
string name = base.contractContext.WsdlPortType.Name;
string targetNamespace = base.contractContext.WsdlPortType.ServiceDescription.TargetNamespace;
MessageContractExporter.MessageDescriptionDictionaryKey key = new MessageContractExporter.MessageDescriptionDictionaryKey(base.contractContext.Contract, messageDescription);
Message message = base.ExportedMessages.WsdlMessages[key];
System.ServiceModel.Description.XmlSerializerOperationBehavior.Reflector.OperationReflector reflector = (System.ServiceModel.Description.XmlSerializerOperationBehavior.Reflector.OperationReflector)state;
XmlMembersMapping membersMapping = null;
if (messageIndex == 0)
{
membersMapping = reflector.Request.BodyMapping;
}
else
{
membersMapping = reflector.Reply.BodyMapping;
}
if (membersMapping != null)
{
bool isDocWrapped = !reflector.IsRpc && (messageDescription.Body.WrapperName != null);
this.ExportMembersMapping(membersMapping, message, false, reflector.IsEncoded, reflector.IsRpc, isDocWrapped, false);
if (reflector.IsRpc)
{
base.AddParameterOrder(base.operation.Messages[messageIndex]);
base.ExportedMessages.WrapperNamespaces.Add(key, membersMapping.Namespace);
}
}
}
private static void AddMappings(ArrayList mappingsList, XmlMembersMapping mappings)
{
for (int i = 0; i < mappings.Count; i++)
{
mappingsList.Add(mappings[i]);
}
}
protected override void ExportHeaders(int messageIndex, object state)
{
string name = base.contractContext.WsdlPortType.Name;
string targetNamespace = base.contractContext.WsdlPortType.ServiceDescription.TargetNamespace;
MessageDescription description = base.operation.Messages[messageIndex];
if (description.Headers.Count > 0)
{
Message message;
System.ServiceModel.Description.XmlSerializerOperationBehavior.Reflector.OperationReflector reflector = (System.ServiceModel.Description.XmlSerializerOperationBehavior.Reflector.OperationReflector)state;
XmlMembersMapping membersMapping = null;
if (messageIndex == 0)
{
membersMapping = reflector.Request.HeadersMapping;
}
else
{
membersMapping = reflector.Reply.HeadersMapping;
}
if ((membersMapping != null) && base.CreateHeaderMessage(description, out message))
{
this.ExportMembersMapping(membersMapping, message, false, reflector.IsEncoded, false, false, true);
}
}
}
/// <summary>
/// Creates a <see cref="SoapDocumentMethodAttribute"/> or a <see cref="SoapRpcMethodAttribute"/>
/// that should be applied to proxy method.
/// </summary>
private static CustomAttributeBuilder CreateSoapMethodAttribute(Operation operation,
OperationBinding operationBinding, SoapOperationBinding soapOperationBinding,
XmlMembersMapping inputMembersMapping, XmlMembersMapping outputMembersMapping)
{
ReflectionUtils.CustomAttributeBuilderBuilder cabb;
string inputMembersMappingElementName = inputMembersMapping.ElementName;
string inputMembersMappingNamespace = inputMembersMapping.Namespace;
if (soapOperationBinding.Style == SoapBindingStyle.Rpc)
{
cabb = new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(SoapRpcMethodAttribute));
}
else
{
cabb = new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(SoapDocumentMethodAttribute));
cabb.AddPropertyValue("ParameterStyle", SoapParameterStyle.Wrapped);
}
cabb.AddContructorArgument(soapOperationBinding.SoapAction);
cabb.AddPropertyValue("Use", SoapBindingUse.Literal);
if (inputMembersMappingElementName.Length > 0 &&
inputMembersMappingElementName != operation.Name)
{
cabb.AddPropertyValue("RequestElementName", inputMembersMappingElementName);
}
if (inputMembersMappingNamespace != null)
{
cabb.AddPropertyValue("RequestNamespace", inputMembersMappingNamespace);
}
if (outputMembersMapping == null)
{
cabb.AddPropertyValue("OneWay", true);
}
else
{
string outputMembersMappingElementName = outputMembersMapping.ElementName;
string outputMembersMappingNamespace = outputMembersMapping.Namespace;
if (outputMembersMappingElementName.Length > 0 &&
outputMembersMappingElementName != (operation.Name + "Response"))
{
cabb.AddPropertyValue("ResponseElementName", outputMembersMappingElementName);
}
if (outputMembersMappingNamespace != null)
{
cabb.AddPropertyValue("ResponseNamespace", outputMembersMappingNamespace);
}
}
return(cabb.Build());
}
void GenerateReturnAttributes(XmlMembersMapping members, XmlMemberMapping member, SoapBindingUse use, CodeMemberMethod method)
{
if (use == SoapBindingUse.Literal)
{
xmlExporter.AddMappingMetadata(method.ReturnTypeCustomAttributes, member, members.Namespace, (member.ElementName != method.Name + "Result"));
}
else
{
soapExporter.AddMappingMetadata(method.ReturnTypeCustomAttributes, member, (member.ElementName != method.Name + "Result"));
}
}
void GenerateMemberAttributes(XmlMembersMapping members, XmlMemberMapping member, SoapBindingUse use, CodeParameterDeclarationExpression param)
{
if (use == SoapBindingUse.Literal)
{
xmlExporter.AddMappingMetadata(param.CustomAttributes, member, members.Namespace);
}
else
{
soapExporter.AddMappingMetadata(param.CustomAttributes, member);
}
}
// returns a stub to a serializer
internal SerializerStub AddSerializer(XmlMembersMapping mapping)
{
int handle = -1;
if (mapping != null)
{
handle = ((IList)_mappings).Add(mapping);
}
return(new SerializerStub(this, mapping, handle));
}
private XmlQualifiedName ExportFaultElement(FaultDescription fault, System.ServiceModel.Description.XmlSerializerOperationBehavior.Reflector.OperationReflector operationReflector)
{
XmlQualifiedName name;
XmlMembersMapping xmlMembersMapping = operationReflector.ImportFaultElement(fault, out name);
if (operationReflector.IsEncoded)
{
this.SoapExporter.ExportMembersMapping(xmlMembersMapping);
return(name);
}
this.XmlExporter.ExportMembersMapping(xmlMembersMapping);
return(name);
}
private void GenerateXmlSerializerFaultContractInfos()
{
SynchronizedCollection <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo> synchronizeds = new SynchronizedCollection <XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo>();
for (int i = 0; i < this.Operation.Faults.Count; i++)
{
XmlQualifiedName name;
FaultDescription fault = this.Operation.Faults[i];
FaultContractInfo faultContractInfo = new FaultContractInfo(fault.Action, fault.DetailType, fault.ElementName, fault.Namespace, this.Operation.KnownTypes);
XmlMembersMapping mapping = this.ImportFaultElement(fault, out name);
XmlSerializerOperationBehavior.Reflector.SerializerStub serializerStub = this.parent.generation.AddSerializer(mapping);
synchronizeds.Add(new XmlSerializerOperationBehavior.Reflector.XmlSerializerFaultContractInfo(faultContractInfo, serializerStub, name));
}
this.xmlSerializerFaultContractInfos = synchronizeds;
}
void CreateLiteralMessage(Message message, MessageBinding messageBinding, XmlMembersMapping members, bool wrapped, bool rpc)
{
if (members.Count == 1 && members[0].Any && members[0].ElementName.Length == 0 && !wrapped)
{
string typeName = SchemaExporter.ExportAnyType(members[0].Namespace);
MessagePart part = new MessagePart();
part.Name = members[0].MemberName;
part.Type = new XmlQualifiedName(typeName, members[0].Namespace);
message.Parts.Add(part);
}
else
{
SchemaExporter.ExportMembersMapping(members, !rpc);
if (wrapped)
{
MessagePart part = new MessagePart();
part.Name = "parameters";
part.Element = new XmlQualifiedName(members.XsdElementName, members.Namespace);
message.Parts.Add(part);
}
else
{
for (int i = 0; i < members.Count; i++)
{
XmlMemberMapping member = members[i];
MessagePart part = new MessagePart();
if (rpc)
{
// Generate massage part with the type attribute
if (member.TypeName == null || member.TypeName.Length == 0)
{
throw new InvalidOperationException(Res.GetString(Res.WsdlGenRpcLitAnonimousType, Method.DeclaringType.Name, Method.Name, member.MemberName));
}
part.Name = member.XsdElementName;
part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace);
}
else
{
part.Name = XmlConvert.EncodeLocalName(member.MemberName);
part.Element = new XmlQualifiedName(member.XsdElementName, member.Namespace);
}
message.Parts.Add(part);
}
}
}
messageBinding.Extensions.Add(CreateSoapBodyBinding(SoapBindingUse.Literal, rpc ? members.Namespace : null));
}
/// <include file='doc\SoapReflectionImporter.uex' path='docs/doc[@for="SoapReflectionImporter.ImportMembersMapping3"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlMembersMapping ImportMembersMapping(string elementName, string ns, XmlReflectionMember[] members, bool hasWrapperElement, bool writeAccessors, bool validate, XmlMappingAccess access)
{
ElementAccessor element = new ElementAccessor();
element.IsSoap = true;
element.Name = elementName == null || elementName.Length == 0 ? elementName : XmlConvert.EncodeLocalName(elementName);
element.Mapping = ImportMembersMapping(members, ns, hasWrapperElement, writeAccessors, validate, new RecursionLimiter());
element.Mapping.TypeName = elementName;
element.Namespace = element.Mapping.Namespace == null ? ns : element.Mapping.Namespace;
element.Form = XmlSchemaForm.Qualified;
XmlMembersMapping xmlMapping = new XmlMembersMapping(_typeScope, element, access);
xmlMapping.IsSoap = true;
xmlMapping.GenerateSerializer = true;
return(xmlMapping);
}
private void GenerateXmlSerializerFaultContractInfos()
{
SynchronizedCollection <XmlSerializerFaultContractInfo> faultInfos = new SynchronizedCollection <XmlSerializerFaultContractInfo>();
for (int i = 0; i < this.Operation.Faults.Count; i++)
{
FaultDescription fault = this.Operation.Faults[i];
FaultContractInfo faultContractInfo = new FaultContractInfo(fault.Action, fault.DetailType, fault.ElementName, fault.Namespace, this.Operation.KnownTypes);
XmlQualifiedName elementName;
XmlMembersMapping xmlMembersMapping = this.ImportFaultElement(fault, out elementName);
SerializerStub serializerStub = _parent._generation.AddSerializer(xmlMembersMapping);
faultInfos.Add(new XmlSerializerFaultContractInfo(faultContractInfo, serializerStub, elementName));
}
_xmlSerializerFaultContractInfos = faultInfos;
}
private void ExportMembersMapping(XmlMembersMapping membersMapping, Message message, bool skipSchemaExport, bool isEncoded, bool isRpc, bool isDocWrapped, bool isHeader)
{
if (!skipSchemaExport)
{
if (isEncoded)
{
this.SoapExporter.ExportMembersMapping(membersMapping);
}
else
{
this.XmlExporter.ExportMembersMapping(membersMapping, !isRpc);
}
}
if (isDocWrapped)
{
if (isHeader)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Header cannot be Document Wrapped", new object[0])));
}
MessageContractExporter.AddMessagePart(message, "parameters", new XmlQualifiedName(membersMapping.XsdElementName, membersMapping.Namespace), XmlQualifiedName.Empty);
}
else
{
bool flag = !isRpc && !isEncoded;
for (int i = 0; i < membersMapping.Count; i++)
{
XmlMemberMapping mapping = membersMapping[i];
string partName = (isHeader || flag) ? NamingHelper.XmlName(mapping.MemberName) : mapping.XsdElementName;
if (flag)
{
MessageContractExporter.AddMessagePart(message, partName, new XmlQualifiedName(mapping.XsdElementName, mapping.Namespace), XmlQualifiedName.Empty);
}
else
{
if (string.IsNullOrEmpty(mapping.TypeName))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxAnonymousTypeNotSupported", new object[] { message.Name, partName })));
}
MessageContractExporter.AddMessagePart(message, partName, XmlQualifiedName.Empty, new XmlQualifiedName(mapping.TypeName, mapping.TypeNamespace));
}
}
}
}
private static XmlMembersMapping ImportMembersMapping(XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, bool serviceDefaultIsEncoded, bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle, string elementName, string elementNamespace, bool nsIsDefault, XmlReflectionMember[] members, bool validate, bool openModel, string key, bool writeAccess)
{
XmlMembersMapping mapping = null;
if (use == SoapBindingUse.Encoded)
{
string ns = ((!rpc && (paramStyle != SoapParameterStyle.Bare)) && nsIsDefault) ? GetEncodedNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace;
mapping = soapImporter.ImportMembersMapping(elementName, ns, members, rpc || (paramStyle != SoapParameterStyle.Bare), rpc, validate, writeAccess ? XmlMappingAccess.Write : XmlMappingAccess.Read);
}
else
{
string str2 = nsIsDefault ? GetLiteralNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace;
mapping = xmlImporter.ImportMembersMapping(elementName, str2, members, paramStyle != SoapParameterStyle.Bare, rpc, openModel, writeAccess ? XmlMappingAccess.Write : XmlMappingAccess.Read);
}
if (mapping != null)
{
mapping.SetKey(key);
}
return(mapping);
}
private XmlSerializerOperationBehavior.Reflector.MessageInfo CreateMessageInfo(MessageDescription message, string key)
{
MessagePartDescriptionCollection descriptions;
if (message.IsUntypedMessage)
{
return(null);
}
XmlSerializerOperationBehavior.Reflector.MessageInfo info = new XmlSerializerOperationBehavior.Reflector.MessageInfo();
if (message.IsTypedMessage)
{
key = string.Concat(new object[] { message.MessageType.FullName, ":", this.IsEncoded, ":", this.IsRpc });
}
XmlMembersMapping mapping = this.LoadHeadersMapping(message, key + ":Headers");
info.SetHeaders(this.parent.generation.AddSerializer(mapping));
info.SetBody(this.parent.generation.AddSerializer(this.LoadBodyMapping(message, key, out descriptions)), descriptions);
this.CreateHeaderDescriptionTable(message, info, mapping);
return(info);
}
private MessageInfo CreateMessageInfo(MessageDescription message, string key)
{
if (message.IsUntypedMessage)
{
return(null);
}
MessageInfo info = new MessageInfo();
bool isEncoded = false;
if (message.IsTypedMessage)
{
key = message.MessageType.FullName + ":" + isEncoded + ":" + IsRpc;
}
XmlMembersMapping headersMapping = LoadHeadersMapping(message, key + ":Headers");
info.SetHeaders(_parent._generation.AddSerializer(headersMapping));
MessagePartDescriptionCollection rpcEncodedTypedMessgeBodyParts;
info.SetBody(_parent._generation.AddSerializer(LoadBodyMapping(message, key, out rpcEncodedTypedMessgeBodyParts)), rpcEncodedTypedMessgeBodyParts);
CreateHeaderDescriptionTable(message, info, headersMapping);
return(info);
}
public void ExportXmlSerializable_NestedClassMapping()
{
XmlSchemas schemas = new XmlSchemas();
XmlReflectionMember xmlReflectionMember = new XmlReflectionMember();
XmlSchemaExporter xmlSchemaExporter = new XmlSchemaExporter(schemas);
XmlReflectionImporter xmlReflectionImporter = new XmlReflectionImporter();
//Export mapping for DataSet1 class.
xmlReflectionMember.MemberType = typeof(DataSet1);
XmlMembersMapping xmlMembersMapping = xmlReflectionImporter.ImportMembersMapping("DataSet1Response", "ResponseNamespace",
new XmlReflectionMember [] { xmlReflectionMember }, true);
xmlSchemaExporter.ExportMembersMapping(xmlMembersMapping);
//Export mapping for nested of DataSet1 class.
xmlReflectionMember.MemberType = typeof(DataSet1.DataTable1DataTable);
xmlMembersMapping = xmlReflectionImporter.ImportMembersMapping("DataTable1DataTableResponse", "ResponseNamespace",
new XmlReflectionMember [] { xmlReflectionMember }, true);
xmlSchemaExporter.ExportMembersMapping(xmlMembersMapping);
}
private void GeneratePartType(Dictionary <XmlMembersMapping, XmlMembersMapping> alreadyExported, MessagePartDescription part, string partNamespace)
{
if (!partInfoTable.ContainsKey(part))
{
return;
}
PartInfo partInfo = partInfoTable[part];
XmlMembersMapping membersMapping = partInfo.MembersMapping;
XmlMemberMapping memberMapping = partInfo.MemberMapping;
if (!alreadyExported.ContainsKey(membersMapping))
{
if (partInfo.IsEncoded)
{
SoapExporter.ExportMembersMapping(membersMapping);
}
else
{
XmlExporter.ExportMembersMapping(membersMapping);
}
alreadyExported.Add(membersMapping, membersMapping);
}
CodeAttributeDeclarationCollection additionalAttributes = new CodeAttributeDeclarationCollection();
if (partInfo.IsEncoded)
{
SoapExporter.AddMappingMetadata(additionalAttributes, memberMapping, false /*forceUseMemberName*/);
}
else
{
XmlExporter.AddMappingMetadata(additionalAttributes, memberMapping, partNamespace, false /*forceUseMemberName*/);
}
part.BaseType = GetTypeName(memberMapping);
operationGenerator.ParameterTypes.Add(part, new CodeTypeReference(part.BaseType));
operationGenerator.ParameterAttributes.Add(part, additionalAttributes);
}
CodeMemberMethod GenerateMethod(CodeIdentifiers memberIds, SoapOperationBinding soapOper, SoapBodyBinding bodyBinding, XmlMembersMapping inputMembers, XmlMembersMapping outputMembers)
{
CodeIdentifiers pids = new CodeIdentifiers();
CodeMemberMethod method = new CodeMemberMethod();
CodeMemberMethod methodBegin = new CodeMemberMethod();
CodeMemberMethod methodEnd = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
methodBegin.Attributes = MemberAttributes.Public | MemberAttributes.Final;
methodEnd.Attributes = MemberAttributes.Public | MemberAttributes.Final;
SoapBindingStyle style = soapOper.Style != SoapBindingStyle.Default ? soapOper.Style : soapBinding.Style;
// Find unique names for temporary variables
for (int n = 0; n < inputMembers.Count; n++)
{
pids.AddUnique(inputMembers[n].MemberName, inputMembers[n]);
}
if (outputMembers != null)
{
for (int n = 0; n < outputMembers.Count; n++)
{
pids.AddUnique(outputMembers[n].MemberName, outputMembers[n]);
}
}
string varAsyncResult = pids.AddUnique("asyncResult", "asyncResult");
string varResults = pids.AddUnique("results", "results");
string varCallback = pids.AddUnique("callback", "callback");
string varAsyncState = pids.AddUnique("asyncState", "asyncState");
string messageName = memberIds.AddUnique(CodeIdentifier.MakeValid(Operation.Name), method);
method.Name = CodeIdentifier.MakeValid(Operation.Name);
if (method.Name == ClassName)
{
method.Name += "1";
}
methodBegin.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("Begin" + method.Name), method);
methodEnd.Name = memberIds.AddUnique(CodeIdentifier.MakeValid("End" + method.Name), method);
method.ReturnType = new CodeTypeReference(typeof(void));
methodEnd.ReturnType = new CodeTypeReference(typeof(void));
methodEnd.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IAsyncResult), varAsyncResult));
CodeExpression[] paramArray = new CodeExpression [inputMembers.Count];
CodeParameterDeclarationExpression[] outParams = new CodeParameterDeclarationExpression [outputMembers != null ? outputMembers.Count : 0];
for (int n = 0; n < inputMembers.Count; n++)
{
CodeParameterDeclarationExpression param = GenerateParameter(inputMembers[n], FieldDirection.In);
method.Parameters.Add(param);
GenerateMemberAttributes(inputMembers, inputMembers[n], bodyBinding.Use, param);
methodBegin.Parameters.Add(GenerateParameter(inputMembers[n], FieldDirection.In));
paramArray [n] = new CodeVariableReferenceExpression(param.Name);
}
if (outputMembers != null)
{
bool hasReturn = false;
for (int n = 0; n < outputMembers.Count; n++)
{
CodeParameterDeclarationExpression cpd = GenerateParameter(outputMembers[n], FieldDirection.Out);
outParams [n] = cpd;
bool found = false;
foreach (CodeParameterDeclarationExpression ip in method.Parameters)
{
if (ip.Name == cpd.Name && ip.Type.BaseType == cpd.Type.BaseType)
{
ip.Direction = FieldDirection.Ref;
methodEnd.Parameters.Add(GenerateParameter(outputMembers[n], FieldDirection.Out));
found = true;
break;
}
}
if (found)
{
continue;
}
if (!hasReturn)
{
hasReturn = true;
method.ReturnType = cpd.Type;
methodEnd.ReturnType = cpd.Type;
GenerateReturnAttributes(outputMembers, outputMembers[n], bodyBinding.Use, method);
outParams [n] = null;
continue;
}
method.Parameters.Add(cpd);
GenerateMemberAttributes(outputMembers, outputMembers[n], bodyBinding.Use, cpd);
methodEnd.Parameters.Add(GenerateParameter(outputMembers[n], FieldDirection.Out));
}
}
methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(AsyncCallback), varCallback));
methodBegin.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), varAsyncState));
methodBegin.ReturnType = new CodeTypeReference(typeof(IAsyncResult));
// Array of input parameters
CodeArrayCreateExpression methodParams;
if (paramArray.Length > 0)
{
methodParams = new CodeArrayCreateExpression(typeof(object), paramArray);
}
else
{
methodParams = new CodeArrayCreateExpression(typeof(object), 0);
}
// Assignment of output parameters
CodeStatementCollection outAssign = new CodeStatementCollection();
CodeVariableReferenceExpression arrVar = new CodeVariableReferenceExpression(varResults);
for (int n = 0; n < outParams.Length; n++)
{
CodeExpression index = new CodePrimitiveExpression(n);
if (outParams[n] == null)
{
CodeExpression res = new CodeCastExpression(method.ReturnType, new CodeArrayIndexerExpression(arrVar, index));
outAssign.Add(new CodeMethodReturnStatement(res));
}
else
{
CodeExpression res = new CodeCastExpression(outParams[n].Type, new CodeArrayIndexerExpression(arrVar, index));
CodeExpression var = new CodeVariableReferenceExpression(outParams[n].Name);
outAssign.Insert(0, new CodeAssignStatement(var, res));
}
}
if (Style == ServiceDescriptionImportStyle.Client)
{
// Invoke call
CodeThisReferenceExpression ethis = new CodeThisReferenceExpression();
CodePrimitiveExpression varMsgName = new CodePrimitiveExpression(messageName);
CodeMethodInvokeExpression inv;
CodeVariableDeclarationStatement dec;
inv = new CodeMethodInvokeExpression(ethis, "Invoke", varMsgName, methodParams);
if (outputMembers != null && outputMembers.Count > 0)
{
dec = new CodeVariableDeclarationStatement(typeof(object[]), varResults, inv);
method.Statements.Add(dec);
method.Statements.AddRange(outAssign);
}
else
{
method.Statements.Add(inv);
}
// Begin Invoke Call
CodeExpression expCallb = new CodeVariableReferenceExpression(varCallback);
CodeExpression expAsyncs = new CodeVariableReferenceExpression(varAsyncState);
inv = new CodeMethodInvokeExpression(ethis, "BeginInvoke", varMsgName, methodParams, expCallb, expAsyncs);
methodBegin.Statements.Add(new CodeMethodReturnStatement(inv));
// End Invoke call
CodeExpression varAsyncr = new CodeVariableReferenceExpression(varAsyncResult);
inv = new CodeMethodInvokeExpression(ethis, "EndInvoke", varAsyncr);
if (outputMembers != null && outputMembers.Count > 0)
{
dec = new CodeVariableDeclarationStatement(typeof(object[]), varResults, inv);
methodEnd.Statements.Add(dec);
methodEnd.Statements.AddRange(outAssign);
}
else
{
methodEnd.Statements.Add(inv);
}
}
else
{
method.Attributes = MemberAttributes.Public | MemberAttributes.Abstract;
}
// Attributes
ImportHeaders(method);
CodeAttributeDeclaration att = new CodeAttributeDeclaration("System.Web.Services.WebMethodAttribute");
if (messageName != method.Name)
{
att.Arguments.Add(GetArg("MessageName", messageName));
}
AddCustomAttribute(method, att, (Style == ServiceDescriptionImportStyle.Server));
if (style == SoapBindingStyle.Rpc)
{
att = new CodeAttributeDeclaration("System.Web.Services.Protocols.SoapRpcMethodAttribute");
att.Arguments.Add(GetArg(soapOper.SoapAction));
if (inputMembers.ElementName != method.Name)
{
att.Arguments.Add(GetArg("RequestElementName", inputMembers.ElementName));
}
if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response"))
{
att.Arguments.Add(GetArg("ResponseElementName", outputMembers.ElementName));
}
att.Arguments.Add(GetArg("RequestNamespace", inputMembers.Namespace));
if (outputMembers != null)
{
att.Arguments.Add(GetArg("ResponseNamespace", outputMembers.Namespace));
}
if (outputMembers == null)
{
att.Arguments.Add(GetArg("OneWay", true));
}
}
else
{
if (outputMembers != null && (inputMembers.ElementName == "" && outputMembers.ElementName != "" ||
inputMembers.ElementName != "" && outputMembers.ElementName == ""))
{
throw new InvalidOperationException("Parameter style is not the same for the input message and output message");
}
att = new CodeAttributeDeclaration("System.Web.Services.Protocols.SoapDocumentMethodAttribute");
att.Arguments.Add(GetArg(soapOper.SoapAction));
if (inputMembers.ElementName != "")
{
if (inputMembers.ElementName != method.Name)
{
att.Arguments.Add(GetArg("RequestElementName", inputMembers.ElementName));
}
if (outputMembers != null && outputMembers.ElementName != (method.Name + "Response"))
{
att.Arguments.Add(GetArg("ResponseElementName", outputMembers.ElementName));
}
att.Arguments.Add(GetArg("RequestNamespace", inputMembers.Namespace));
if (outputMembers != null)
{
att.Arguments.Add(GetArg("ResponseNamespace", outputMembers.Namespace));
}
att.Arguments.Add(GetEnumArg("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Wrapped"));
}
else
{
att.Arguments.Add(GetEnumArg("ParameterStyle", "System.Web.Services.Protocols.SoapParameterStyle", "Bare"));
}
if (outputMembers == null)
{
att.Arguments.Add(GetArg("OneWay", true));
}
att.Arguments.Add(GetEnumArg("Use", "System.Web.Services.Description.SoapBindingUse", bodyBinding.Use.ToString()));
}
AddCustomAttribute(method, att, true);
CodeTypeDeclaration.Members.Add(method);
if (Style == ServiceDescriptionImportStyle.Client)
{
CodeTypeDeclaration.Members.Add(methodBegin);
CodeTypeDeclaration.Members.Add(methodEnd);
}
return(method);
}
protected override CodeMemberMethod GenerateMethod()
{
try
{
SoapOperationBinding soapOper = OperationBinding.Extensions.Find(typeof(SoapOperationBinding)) as SoapOperationBinding;
if (soapOper == null)
{
throw new InvalidOperationException("Soap operation binding not found");
}
SoapBindingStyle style = soapOper.Style != SoapBindingStyle.Default ? soapOper.Style : soapBinding.Style;
SoapBodyBinding isbb = null;
XmlMembersMapping inputMembers = null;
bool isWrapped = CheckIsWrapped();
isbb = OperationBinding.Input.Extensions.Find(typeof(SoapBodyBinding)) as SoapBodyBinding;
if (isbb == null)
{
throw new InvalidOperationException("Soap body binding not found");
}
inputMembers = ImportMembersMapping(InputMessage, isbb, style, false, isWrapped);
if (inputMembers == null)
{
throw new InvalidOperationException("Input message not declared");
}
// If OperationBinding.Output is null, it is an OneWay operation
SoapBodyBinding osbb = null;
XmlMembersMapping outputMembers = null;
if (OperationBinding.Output != null)
{
osbb = OperationBinding.Output.Extensions.Find(typeof(SoapBodyBinding)) as SoapBodyBinding;
if (osbb == null)
{
throw new InvalidOperationException("Soap body binding not found");
}
outputMembers = ImportMembersMapping(OutputMessage, osbb, style, true, isWrapped);
if (outputMembers == null)
{
throw new InvalidOperationException("Output message not declared");
}
}
CodeMemberMethod met = GenerateMethod(memberIds, soapOper, isbb, inputMembers, outputMembers);
if (isbb.Use == SoapBindingUse.Literal)
{
xmlExporter.ExportMembersMapping(inputMembers);
}
else
{
soapExporter.ExportMembersMapping(inputMembers);
}
if (osbb != null)
{
if (osbb.Use == SoapBindingUse.Literal)
{
xmlExporter.ExportMembersMapping(outputMembers);
}
else
{
soapExporter.ExportMembersMapping(outputMembers);
}
}
foreach (SoapExtensionImporter eximporter in extensionImporters)
{
eximporter.ImportContext = this;
eximporter.ImportMethod(met.CustomAttributes);
}
return(met);
}
catch (InvalidOperationException ex)
{
UnsupportedOperationBindingWarning(ex.Message);
return(null);
}
}
public System.Xml.XmlQualifiedName ExportTypeMapping(XmlMembersMapping xmlMembersMapping)
{
}
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping, bool exportEnclosingType)
{
}
public void ExportMembersMapping(XmlMembersMapping xmlMembersMapping)
{
}
public string ExportAnyType(XmlMembersMapping members)
{
}
private void CreateLiteralMessage(Message message, MessageBinding messageBinding, XmlMembersMapping members, bool wrapped, bool rpc)
{
if (((members.Count == 1) && members[0].Any) && ((members[0].ElementName.Length == 0) && !wrapped))
{
string name = base.SchemaExporter.ExportAnyType(members[0].Namespace);
MessagePart messagePart = new MessagePart {
Name = members[0].MemberName,
Type = new XmlQualifiedName(name, members[0].Namespace)
};
message.Parts.Add(messagePart);
}
else
{
base.SchemaExporter.ExportMembersMapping(members, !rpc);
if (wrapped)
{
MessagePart part2 = new MessagePart {
Name = "parameters",
Element = new XmlQualifiedName(members.XsdElementName, members.Namespace)
};
message.Parts.Add(part2);
}
else
{
for (int i = 0; i < members.Count; i++)
{
XmlMemberMapping mapping = members[i];
MessagePart part3 = new MessagePart();
if (rpc)
{
if ((mapping.TypeName == null) || (mapping.TypeName.Length == 0))
{
throw new InvalidOperationException(System.Web.Services.Res.GetString("WsdlGenRpcLitAnonimousType", new object[] { base.Method.DeclaringType.Name, base.Method.Name, mapping.MemberName }));
}
part3.Name = mapping.XsdElementName;
part3.Type = new XmlQualifiedName(mapping.TypeName, mapping.TypeNamespace);
}
else
{
part3.Name = XmlConvert.EncodeLocalName(mapping.MemberName);
part3.Element = new XmlQualifiedName(mapping.XsdElementName, mapping.Namespace);
}
message.Parts.Add(part3);
}
}
}
messageBinding.Extensions.Add(this.CreateSoapBodyBinding(SoapBindingUse.Literal, rpc ? members.Namespace : null));
}
private void CreateHeaderMessages(string methodName, SoapBindingUse use, XmlMembersMapping inHeaderMappings, XmlMembersMapping outHeaderMappings, SoapReflectedHeader[] headers, bool rpc)
{
if (use == SoapBindingUse.Encoded)
{
this.SoapExporter.ExportMembersMapping(inHeaderMappings, false);
if (outHeaderMappings != null)
{
this.SoapExporter.ExportMembersMapping(outHeaderMappings, false);
}
}
else
{
base.SchemaExporter.ExportMembersMapping(inHeaderMappings);
if (outHeaderMappings != null)
{
base.SchemaExporter.ExportMembersMapping(outHeaderMappings);
}
}
CodeIdentifiers identifiers = new CodeIdentifiers();
int num = 0;
int num2 = 0;
for (int i = 0; i < headers.Length; i++)
{
SoapReflectedHeader header = headers[i];
if (header.custom)
{
XmlMemberMapping mapping;
Message message;
if ((header.direction & SoapHeaderDirection.In) != 0)
{
mapping = inHeaderMappings[num++];
if (header.direction != SoapHeaderDirection.In)
{
num2++;
}
}
else
{
mapping = outHeaderMappings[num2++];
}
MessagePart messagePart = new MessagePart {
Name = mapping.XsdElementName
};
if (use == SoapBindingUse.Encoded)
{
messagePart.Type = new XmlQualifiedName(mapping.TypeName, mapping.TypeNamespace);
}
else
{
messagePart.Element = new XmlQualifiedName(mapping.XsdElementName, mapping.Namespace);
}
message = new Message {
Name = identifiers.AddUnique(methodName + messagePart.Name, message)
};
message.Parts.Add(messagePart);
base.HeaderMessages.Add(message);
ServiceDescriptionFormatExtension extension = this.CreateSoapHeaderBinding(new XmlQualifiedName(message.Name, base.Binding.ServiceDescription.TargetNamespace), messagePart.Name, rpc ? mapping.Namespace : null, use);
if ((header.direction & SoapHeaderDirection.In) != 0)
{
base.OperationBinding.Input.Extensions.Add(extension);
}
if ((header.direction & SoapHeaderDirection.Out) != 0)
{
base.OperationBinding.Output.Extensions.Add(extension);
}
if ((header.direction & SoapHeaderDirection.Fault) != 0)
{
if (this.soapMethod.IsClaimsConformance)
{
throw new InvalidOperationException(System.Web.Services.Res.GetString("BPConformanceHeaderFault", new object[] { this.soapMethod.methodInfo.ToString(), this.soapMethod.methodInfo.DeclaringType.FullName, "Direction", typeof(SoapHeaderDirection).Name, SoapHeaderDirection.Fault.ToString() }));
}
base.OperationBinding.Output.Extensions.Add(extension);
}
}
}
}
private void CreateMessage(bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle, Message message, MessageBinding messageBinding, XmlMembersMapping members)
{
bool flag = paramStyle != SoapParameterStyle.Bare;
if (use == SoapBindingUse.Encoded)
{
this.CreateEncodedMessage(message, messageBinding, members, flag && !rpc);
}
else
{
this.CreateLiteralMessage(message, messageBinding, members, flag && !rpc, rpc);
}
}
