private void GeneratePartType(Dictionary <XmlMembersMapping, XmlMembersMapping> alreadyExported, MessagePartDescription part)
{
if (this.partInfoTable.ContainsKey(part))
{
PartInfo info = this.partInfoTable[part];
XmlMembersMapping membersMapping = info.MembersMapping;
XmlMemberMapping memberMapping = info.MemberMapping;
if (!alreadyExported.ContainsKey(membersMapping))
{
if (info.IsEncoded)
{
this.SoapExporter.ExportMembersMapping(membersMapping);
}
else
{
this.XmlExporter.ExportMembersMapping(membersMapping);
}
alreadyExported.Add(membersMapping, membersMapping);
}
CodeAttributeDeclarationCollection metadata = new CodeAttributeDeclarationCollection();
if (info.IsEncoded)
{
this.SoapExporter.AddMappingMetadata(metadata, memberMapping, false);
}
else
{
this.XmlExporter.AddMappingMetadata(metadata, memberMapping, part.Namespace, false);
}
part.BaseType = this.GetTypeName(memberMapping);
this.operationGenerator.ParameterTypes.Add(part, new CodeTypeReference(part.BaseType));
this.operationGenerator.ParameterAttributes.Add(part, metadata);
}
}
void CreateLiteralMessage(Message message, MessageBinding messageBinding, XmlMembersMapping members, bool wrapped)
{
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);
if (wrapped)
{
MessagePart part = new MessagePart();
part.Name = "parameters";
part.Element = new XmlQualifiedName(members.ElementName, members.Namespace);
message.Parts.Add(part);
}
else
{
for (int i = 0; i < members.Count; i++)
{
XmlMemberMapping member = members[i];
MessagePart part = new MessagePart();
part.Name = member.MemberName;
part.Element = new XmlQualifiedName(member.ElementName, member.Namespace);
message.Parts.Add(part);
}
}
}
messageBinding.Extensions.Add(CreateSoapBodyBinding(SoapBindingUse.Literal, null));
}
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.ElementName;
part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace);
message.Parts.Add(part);
}
}
messageBinding.Extensions.Add(CreateSoapBodyBinding(SoapBindingUse.Encoded, members.Namespace));
}
private void CreateEncodedMessage(Message message, MessageBinding messageBinding, XmlMembersMapping members, bool wrapped)
{
this.SoapExporter.ExportMembersMapping(members, wrapped);
if (wrapped)
{
MessagePart messagePart = new MessagePart {
Name = "parameters",
Type = new XmlQualifiedName(members.TypeName, members.TypeNamespace)
};
message.Parts.Add(messagePart);
}
else
{
for (int i = 0; i < members.Count; i++)
{
XmlMemberMapping mapping = members[i];
MessagePart part2 = new MessagePart {
Name = mapping.XsdElementName,
Type = new XmlQualifiedName(mapping.TypeName, mapping.TypeNamespace)
};
message.Parts.Add(part2);
}
}
messageBinding.Extensions.Add(this.CreateSoapBodyBinding(SoapBindingUse.Encoded, members.Namespace));
}
private void CreateHeaderDescriptionTable(MessageDescription message, MessageInfo info, XmlMembersMapping headersMapping)
{
int headerNameIndex = 0;
OperationFormatter.MessageHeaderDescriptionTable headerDescriptionTable = new OperationFormatter.MessageHeaderDescriptionTable();
info.SetHeaderDescriptionTable(headerDescriptionTable);
foreach (MessageHeaderDescription header in message.Headers)
{
if (header.IsUnknownHeaderCollection)
{
info.SetUnknownHeaderDescription(header);
}
else if (headersMapping != null)
{
XmlMemberMapping memberMapping = headersMapping[headerNameIndex++];
if (GeneratedXmlSerializers.IsInitialized)
{
// If GeneratedXmlSerializers has been initialized, we would use the
// mappings generated by .Net Native tools. In that case, the mappings
// we genrated at Runtime are just fake mapping instance which have
// no valid name/namespace. Therefore we cannot do the checks in the
// else block. Those checks should have been done during NET Native
// precompilation.
headerDescriptionTable.Add(header.Name, header.Namespace, header);
}
else
{
string headerName, headerNs;
headerName = memberMapping.XsdElementName;
headerNs = memberMapping.Namespace;
if (headerName != header.Name)
{
if (message.MessageType != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxHeaderNameMismatchInMessageContract, message.MessageType, header.MemberInfo.Name, header.Name, headerName)));
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxHeaderNameMismatchInOperation, this.Operation.Name, this.Operation.DeclaringContract.Name, this.Operation.DeclaringContract.Namespace, header.Name, headerName)));
}
}
if (headerNs != header.Namespace)
{
if (message.MessageType != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxHeaderNamespaceMismatchInMessageContract, message.MessageType, header.MemberInfo.Name, header.Namespace, headerNs)));
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxHeaderNamespaceMismatchInOperation, this.Operation.Name, this.Operation.DeclaringContract.Name, this.Operation.DeclaringContract.Namespace, header.Namespace, headerNs)));
}
}
headerDescriptionTable.Add(headerName, headerNs, header);
}
}
}
}
CodeParameterDeclarationExpression GenerateParameter(XmlMemberMapping member, FieldDirection dir)
{
string type = member.GenerateTypeName(CodeGenerator);
CodeParameterDeclarationExpression par = new CodeParameterDeclarationExpression(type, member.MemberName);
par.Direction = dir;
return(par);
}
internal void Add(MessagePartDescription part, XmlMemberMapping memberMapping, XmlMembersMapping membersMapping, bool isEncoded)
{
PartInfo partInfo = new PartInfo();
partInfo.MemberMapping = memberMapping;
partInfo.MembersMapping = membersMapping;
partInfo.IsEncoded = isEncoded;
partInfoTable[part] = partInfo;
}
internal void Add(MessagePartDescription part, XmlMemberMapping memberMapping, XmlMembersMapping membersMapping, bool isEncoded)
{
PartInfo info = new PartInfo {
MemberMapping = memberMapping,
MembersMapping = membersMapping,
IsEncoded = isEncoded
};
this.partInfoTable[part] = info;
}
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"));
}
}
CodeParameterDeclarationExpression GenerateParameter(XmlMemberMapping member, FieldDirection dir)
{
#if NET_2_0
string type = member.GenerateTypeName(CodeGenerator);
#else
string type = member.TypeFullName;
#endif
CodeParameterDeclarationExpression par = new CodeParameterDeclarationExpression(type, member.MemberName);
par.Direction = dir;
return(par);
}
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);
}
}
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));
}
internal string GetTypeName(XmlMemberMapping member)
{
string str = member.GenerateTypeName(this.options.CodeProvider);
if ((this.codeNamespace != null) && !string.IsNullOrEmpty(this.codeNamespace.Name))
{
foreach (CodeTypeDeclaration declaration in this.codeNamespace.Types)
{
if (declaration.Name == str)
{
str = this.codeNamespace.Name + "." + str;
}
}
}
return(str);
}
private void CreateHeaderDescriptionTable(MessageDescription message, XmlSerializerOperationBehavior.Reflector.MessageInfo info, XmlMembersMapping headersMapping)
{
int num = 0;
OperationFormatter.MessageHeaderDescriptionTable headerDescriptionTable = new OperationFormatter.MessageHeaderDescriptionTable();
info.SetHeaderDescriptionTable(headerDescriptionTable);
foreach (MessageHeaderDescription description in message.Headers)
{
if (description.IsUnknownHeaderCollection)
{
info.SetUnknownHeaderDescription(description);
}
else if (headersMapping != null)
{
string typeName;
string typeNamespace;
XmlMemberMapping mapping = headersMapping[num++];
if (this.IsEncoded)
{
typeName = mapping.TypeName;
typeNamespace = mapping.TypeNamespace;
}
else
{
typeName = mapping.XsdElementName;
typeNamespace = mapping.Namespace;
}
if (typeName != description.Name)
{
if (message.MessageType != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxHeaderNameMismatchInMessageContract", new object[] { message.MessageType, description.MemberInfo.Name, description.Name, typeName })));
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxHeaderNameMismatchInOperation", new object[] { this.Operation.Name, this.Operation.DeclaringContract.Name, this.Operation.DeclaringContract.Namespace, description.Name, typeName })));
}
if (typeNamespace != description.Namespace)
{
if (message.MessageType != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxHeaderNamespaceMismatchInMessageContract", new object[] { message.MessageType, description.MemberInfo.Name, description.Namespace, typeNamespace })));
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxHeaderNamespaceMismatchInOperation", new object[] { this.Operation.Name, this.Operation.DeclaringContract.Name, this.Operation.DeclaringContract.Namespace, description.Namespace, typeNamespace })));
}
headerDescriptionTable.Add(typeName, typeNamespace, description);
}
}
}
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));
}
private void CreateHeaderDescriptionTable(MessageDescription message, MessageInfo info, XmlMembersMapping headersMapping)
{
int headerNameIndex = 0;
OperationFormatter.MessageHeaderDescriptionTable headerDescriptionTable = new OperationFormatter.MessageHeaderDescriptionTable();
info.SetHeaderDescriptionTable(headerDescriptionTable);
foreach (MessageHeaderDescription header in message.Headers)
{
if (header.IsUnknownHeaderCollection)
{
info.SetUnknownHeaderDescription(header);
}
else if (headersMapping != null)
{
XmlMemberMapping memberMapping = headersMapping[headerNameIndex++];
string headerName, headerNs;
headerName = memberMapping.XsdElementName;
headerNs = memberMapping.Namespace;
if (headerName != header.Name)
{
if (message.MessageType != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(SRServiceModel.SFxHeaderNameMismatchInMessageContract, message.MessageType, header.MemberInfo.Name, header.Name, headerName)));
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(SRServiceModel.SFxHeaderNameMismatchInOperation, this.Operation.Name, this.Operation.DeclaringContract.Name, this.Operation.DeclaringContract.Namespace, header.Name, headerName)));
}
}
if (headerNs != header.Namespace)
{
if (message.MessageType != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(SRServiceModel.SFxHeaderNamespaceMismatchInMessageContract, message.MessageType, header.MemberInfo.Name, header.Namespace, headerNs)));
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(string.Format(SRServiceModel.SFxHeaderNamespaceMismatchInOperation, this.Operation.Name, this.Operation.DeclaringContract.Name, this.Operation.DeclaringContract.Namespace, header.Namespace, headerNs)));
}
}
headerDescriptionTable.Add(headerName, headerNs, header);
}
}
}
internal XmlMembersMapping(TypeScope scope, ElementAccessor accessor, XmlMappingAccess access) : base(scope, accessor, access)
{
MembersMapping mapping = (MembersMapping)accessor.Mapping;
StringBuilder key = new StringBuilder();
key.Append(":");
_mappings = new XmlMemberMapping[mapping.Members.Length];
for (int i = 0; i < _mappings.Length; i++)
{
if (mapping.Members[i].TypeDesc.Type != null)
{
key.Append(GenerateKey(mapping.Members[i].TypeDesc.Type, null, null));
key.Append(":");
}
_mappings[i] = new XmlMemberMapping(mapping.Members[i]);
}
SetKeyInternal(key.ToString());
}
internal string GetTypeName(XmlMemberMapping member)
{
string typeName = member.GenerateTypeName(options.CodeProvider);
// If it is an array type, get the array element type name instead
string comparableTypeName = typeName.Replace("[]", null);
if (codeNamespace != null && !string.IsNullOrEmpty(codeNamespace.Name))
{
foreach (CodeTypeDeclaration typeDecl in codeNamespace.Types)
{
if (typeDecl.Name == comparableTypeName)
{
typeName = codeNamespace.Name + "." + typeName;
}
}
}
return(typeName);
}
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 bool RemoveByRefMapping(ArrayList responseList, XmlMemberMapping requestMapping)
{
XmlMemberMapping mapping = FindMapping(responseList, requestMapping.ElementName);
if (mapping == null)
{
return(false);
}
if (requestMapping.TypeFullName != mapping.TypeFullName)
{
return(false);
}
if (requestMapping.Namespace != mapping.Namespace)
{
return(false);
}
if (requestMapping.MemberName != mapping.MemberName)
{
return(false);
}
responseList.Remove(mapping);
return(true);
}
string GetSimpleType(XmlMemberMapping member)
{
// MS seems to always use System.String for input parameters, except for byte[]
switch (member.TypeName)
{
case "hexBinary":
case "base64Binary":
return("System.String");
default:
string ptype = member.TypeFullName;
int i = ptype.IndexOf('[');
if (i == -1)
{
return("System.String");
}
else
{
return("System.String" + ptype.Substring(i));
}
}
}
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);
}
internal static string FullTypeName(XmlMemberMapping mapping, CodeDomProvider codeProvider)
{
return(mapping.GenerateTypeName(codeProvider));
}
protected override bool ReflectMethod()
{
LogicalTypeInfo ti = TypeStubManager.GetLogicalTypeInfo(ServiceType);
HttpOperationBinding sob = new HttpOperationBinding();
sob.Location = "/" + MethodStubInfo.Name;
OperationBinding.Extensions.Add(sob);
if (!Method.IsVoid)
{
MimeXmlBinding mxb = new MimeXmlBinding();
mxb.Part = "Body";
OperationBinding.Output.Extensions.Add(mxb);
MessagePart part = new MessagePart();
part.Name = "Body";
XmlTypeMapping map = ReflectionImporter.ImportTypeMapping(Method.ReturnType, ti.GetWebServiceLiteralNamespace(ServiceDescription.TargetNamespace));
XmlQualifiedName qname = new XmlQualifiedName(map.ElementName, map.Namespace);
part.Element = qname;
OutputMessage.Parts.Add(part);
SchemaExporter.ExportTypeMapping(map);
}
XmlReflectionMember[] mems = new XmlReflectionMember [Method.Parameters.Length];
for (int n = 0; n < Method.Parameters.Length; n++)
{
ParameterInfo param = Method.Parameters [n];
XmlReflectionMember mem = new XmlReflectionMember();
mem.MemberName = param.Name;
Type ptype = param.ParameterType;
if (ptype.IsByRef)
{
ptype = ptype.GetElementType();
}
mem.MemberType = ptype;
mems [n] = mem;
}
XmlMembersMapping memap = ReflectionImporter.ImportMembersMapping("", ti.WebServiceAbstractNamespace, mems, false);
bool allPrimitives = true;
for (int n = 0; n < memap.Count; n++)
{
XmlMemberMapping mem = memap[n];
MessagePart part = new MessagePart();
XmlQualifiedName pqname;
if (mem.TypeNamespace == "")
{
pqname = new XmlQualifiedName(mem.TypeName, XmlSchema.Namespace);
}
else
{
pqname = new XmlQualifiedName(mem.TypeName, mem.TypeNamespace);
allPrimitives = false;
}
part.Type = pqname;
part.Name = mem.ElementName;
InputMessage.Parts.Add(part);
}
if (!allPrimitives)
{
SoapSchemaExporter.ExportMembersMapping(memap);
}
return(true);
}
protected override IList GetMethodReturnTypeAttributes(MethodInfo method)
{
IList attrs = base.GetMethodReturnTypeAttributes(method);
// Add the XmlElementAttribute if needed
if (operation.Messages.Output != null)
{
if (method.ReturnType != typeof(void))
{
if (outputMembersMapping.Count > 0)
{
XmlMemberMapping outMemberMapping = outputMembersMapping[0];
bool useMemberName = (outMemberMapping.MemberName != operation.Name + "Result");
bool useNamespace = outMemberMapping.Namespace != outputMembersMapping.Namespace;
bool useTypeNamespace = outMemberMapping.TypeNamespace != XmlSchema.Namespace &&
outMemberMapping.TypeNamespace != outputMembersMapping.Namespace;
if (useMemberName || useNamespace || useTypeNamespace)
{
if (outMemberMapping.TypeName.StartsWith("ArrayOf", StringComparison.Ordinal))
{
if (useMemberName || useNamespace)
{
ReflectionUtils.CustomAttributeBuilderBuilder cabb =
new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(XmlArrayAttribute));
if (useMemberName)
{
cabb.AddPropertyValue("ElementName", outMemberMapping.MemberName);
}
if (useNamespace)
{
cabb.AddPropertyValue("Namespace", outMemberMapping.Namespace);
}
attrs.Add(cabb.Build());
}
if (useTypeNamespace)
{
ReflectionUtils.CustomAttributeBuilderBuilder cabb =
new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(XmlArrayItemAttribute));
cabb.AddPropertyValue("Namespace", outMemberMapping.TypeNamespace);
attrs.Add(cabb.Build());
}
}
else
{
if (useMemberName || useNamespace)
{
ReflectionUtils.CustomAttributeBuilderBuilder cabb =
new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(XmlElementAttribute));
if (useMemberName)
{
cabb.AddPropertyValue("ElementName", outMemberMapping.MemberName);
}
if (useNamespace)
{
cabb.AddPropertyValue("Namespace", outMemberMapping.Namespace);
}
attrs.Add(cabb.Build());
}
}
}
}
}
}
return(attrs);
}
public void AddMappingMetadata(System.CodeDom.CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, string ns)
{
}
public void AddMappingMetadata(System.CodeDom.CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, bool forceUseMemberName)
{
}
public void AddMappingMetadata(System.CodeDom.CodeAttributeDeclarationCollection metadata, XmlMemberMapping member, bool forceUseMemberName)
{
}
public void AddMappingMetadata(System.CodeDom.CodeAttributeDeclarationCollection metadata, XmlMemberMapping member)
{
}
internal SoapParameters(XmlMembersMapping request, XmlMembersMapping response, string[] parameterOrder, CodeIdentifiers identifiers)
{
ArrayList mappingsList = new ArrayList();
ArrayList list2 = new ArrayList();
AddMappings(mappingsList, request);
if (response != null)
{
AddMappings(list2, response);
}
if (parameterOrder != null)
{
for (int i = 0; i < parameterOrder.Length; i++)
{
string elementName = parameterOrder[i];
XmlMemberMapping requestMapping = FindMapping(mappingsList, elementName);
SoapParameter parameter = new SoapParameter();
if (requestMapping != null)
{
if (RemoveByRefMapping(list2, requestMapping))
{
parameter.codeFlags = CodeFlags.IsByRef;
}
parameter.mapping = requestMapping;
mappingsList.Remove(requestMapping);
this.AddParameter(parameter);
}
else
{
XmlMemberMapping mapping2 = FindMapping(list2, elementName);
if (mapping2 != null)
{
parameter.codeFlags = CodeFlags.IsOut;
parameter.mapping = mapping2;
list2.Remove(mapping2);
this.AddParameter(parameter);
}
}
}
}
foreach (XmlMemberMapping mapping3 in mappingsList)
{
SoapParameter parameter2 = new SoapParameter();
if (RemoveByRefMapping(list2, mapping3))
{
parameter2.codeFlags = CodeFlags.IsByRef;
}
parameter2.mapping = mapping3;
this.AddParameter(parameter2);
}
if (list2.Count > 0)
{
if (!((XmlMemberMapping)list2[0]).CheckSpecified)
{
this.ret = (XmlMemberMapping)list2[0];
list2.RemoveAt(0);
}
foreach (XmlMemberMapping mapping4 in list2)
{
SoapParameter parameter3 = new SoapParameter {
mapping = mapping4,
codeFlags = CodeFlags.IsOut
};
this.AddParameter(parameter3);
}
}
foreach (SoapParameter parameter4 in this.parameters)
{
parameter4.name = identifiers.MakeUnique(CodeIdentifier.MakeValid(parameter4.mapping.MemberName));
}
}
