internal static SoapReflectedMethod ReflectMethod(LogicalMethodInfo methodInfo, bool client, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, string defaultNs)
{
SoapReflectedMethod method2;
try
{
string str2;
string str4;
string key = methodInfo.GetKey();
SoapReflectedMethod method = new SoapReflectedMethod();
MethodAttribute attribute = new MethodAttribute();
object soapServiceAttribute = GetSoapServiceAttribute(methodInfo.DeclaringType);
bool serviceDefaultIsEncoded = ServiceDefaultIsEncoded(soapServiceAttribute);
object soapMethodAttribute = GetSoapMethodAttribute(methodInfo);
if (soapMethodAttribute == null)
{
if (client)
{
return(null);
}
if (soapServiceAttribute is SoapRpcServiceAttribute)
{
SoapRpcMethodAttribute attribute2 = new SoapRpcMethodAttribute {
Use = ((SoapRpcServiceAttribute)soapServiceAttribute).Use
};
soapMethodAttribute = attribute2;
}
else if (soapServiceAttribute is SoapDocumentServiceAttribute)
{
SoapDocumentMethodAttribute attribute3 = new SoapDocumentMethodAttribute {
Use = ((SoapDocumentServiceAttribute)soapServiceAttribute).Use
};
soapMethodAttribute = attribute3;
}
else
{
soapMethodAttribute = new SoapDocumentMethodAttribute();
}
}
if (soapMethodAttribute is SoapRpcMethodAttribute)
{
SoapRpcMethodAttribute attribute4 = (SoapRpcMethodAttribute)soapMethodAttribute;
method.rpc = true;
method.use = attribute4.Use;
method.oneWay = attribute4.OneWay;
attribute.action = attribute4.Action;
attribute.binding = attribute4.Binding;
attribute.requestName = attribute4.RequestElementName;
attribute.requestNs = attribute4.RequestNamespace;
attribute.responseName = attribute4.ResponseElementName;
attribute.responseNs = attribute4.ResponseNamespace;
}
else
{
SoapDocumentMethodAttribute attribute5 = (SoapDocumentMethodAttribute)soapMethodAttribute;
method.rpc = false;
method.use = attribute5.Use;
method.paramStyle = attribute5.ParameterStyle;
method.oneWay = attribute5.OneWay;
attribute.action = attribute5.Action;
attribute.binding = attribute5.Binding;
attribute.requestName = attribute5.RequestElementName;
attribute.requestNs = attribute5.RequestNamespace;
attribute.responseName = attribute5.ResponseElementName;
attribute.responseNs = attribute5.ResponseNamespace;
if (method.use == SoapBindingUse.Default)
{
if (soapServiceAttribute is SoapDocumentServiceAttribute)
{
method.use = ((SoapDocumentServiceAttribute)soapServiceAttribute).Use;
}
if (method.use == SoapBindingUse.Default)
{
method.use = SoapBindingUse.Literal;
}
}
if (method.paramStyle == SoapParameterStyle.Default)
{
if (soapServiceAttribute is SoapDocumentServiceAttribute)
{
method.paramStyle = ((SoapDocumentServiceAttribute)soapServiceAttribute).ParameterStyle;
}
if (method.paramStyle == SoapParameterStyle.Default)
{
method.paramStyle = SoapParameterStyle.Wrapped;
}
}
}
if (attribute.binding.Length > 0)
{
if (client)
{
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebInvalidBindingPlacement", new object[] { soapMethodAttribute.GetType().Name }));
}
method.binding = WebServiceBindingReflector.GetAttribute(methodInfo, attribute.binding);
}
WebMethodAttribute methodAttribute = methodInfo.MethodAttribute;
method.name = methodAttribute.MessageName;
if (method.name.Length == 0)
{
method.name = methodInfo.Name;
}
if (method.rpc)
{
str2 = ((attribute.requestName.Length == 0) || !client) ? methodInfo.Name : attribute.requestName;
}
else
{
str2 = (attribute.requestName.Length == 0) ? method.name : attribute.requestName;
}
string requestNs = attribute.requestNs;
if (requestNs == null)
{
if (((method.binding != null) && (method.binding.Namespace != null)) && (method.binding.Namespace.Length != 0))
{
requestNs = method.binding.Namespace;
}
else
{
requestNs = defaultNs;
}
}
if (method.rpc && (method.use != SoapBindingUse.Encoded))
{
str4 = methodInfo.Name + "Response";
}
else
{
str4 = (attribute.responseName.Length == 0) ? (method.name + "Response") : attribute.responseName;
}
string responseNs = attribute.responseNs;
if (responseNs == null)
{
if (((method.binding != null) && (method.binding.Namespace != null)) && (method.binding.Namespace.Length != 0))
{
responseNs = method.binding.Namespace;
}
else
{
responseNs = defaultNs;
}
}
SoapParameterInfo[] infoArray = ReflectParameters(methodInfo.InParameters, requestNs);
SoapParameterInfo[] infoArray2 = ReflectParameters(methodInfo.OutParameters, responseNs);
method.action = attribute.action;
if (method.action == null)
{
method.action = GetDefaultAction(defaultNs, methodInfo);
}
method.methodInfo = methodInfo;
if (method.oneWay)
{
if (infoArray2.Length > 0)
{
throw new ArgumentException(System.Web.Services.Res.GetString("WebOneWayOutParameters"), "methodInfo");
}
if (methodInfo.ReturnType != typeof(void))
{
throw new ArgumentException(System.Web.Services.Res.GetString("WebOneWayReturnValue"), "methodInfo");
}
}
XmlReflectionMember[] members = new XmlReflectionMember[infoArray.Length];
for (int i = 0; i < members.Length; i++)
{
SoapParameterInfo info = infoArray[i];
XmlReflectionMember member = new XmlReflectionMember {
MemberName = info.parameterInfo.Name,
MemberType = info.parameterInfo.ParameterType
};
if (member.MemberType.IsByRef)
{
member.MemberType = member.MemberType.GetElementType();
}
member.XmlAttributes = info.xmlAttributes;
member.SoapAttributes = info.soapAttributes;
members[i] = member;
}
method.requestMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, method.rpc, method.use, method.paramStyle, str2, requestNs, attribute.requestNs == null, members, true, false, key, client);
if (((GetSoapServiceRoutingStyle(soapServiceAttribute) == SoapServiceRoutingStyle.RequestElement) && (method.paramStyle == SoapParameterStyle.Bare)) && (method.requestMappings.Count != 1))
{
throw new ArgumentException(System.Web.Services.Res.GetString("WhenUsingAMessageStyleOfParametersAsDocument0"), "methodInfo");
}
string name = "";
string ns = "";
if (method.paramStyle == SoapParameterStyle.Bare)
{
if (method.requestMappings.Count == 1)
{
name = method.requestMappings[0].XsdElementName;
ns = method.requestMappings[0].Namespace;
}
}
else
{
name = method.requestMappings.XsdElementName;
ns = method.requestMappings.Namespace;
}
method.requestElementName = new XmlQualifiedName(name, ns);
if (!method.oneWay)
{
int num2 = infoArray2.Length;
int num3 = 0;
CodeIdentifiers identifiers = null;
if (methodInfo.ReturnType != typeof(void))
{
num2++;
num3 = 1;
identifiers = new CodeIdentifiers();
}
members = new XmlReflectionMember[num2];
for (int m = 0; m < infoArray2.Length; m++)
{
SoapParameterInfo info2 = infoArray2[m];
XmlReflectionMember member2 = new XmlReflectionMember {
MemberName = info2.parameterInfo.Name,
MemberType = info2.parameterInfo.ParameterType
};
if (member2.MemberType.IsByRef)
{
member2.MemberType = member2.MemberType.GetElementType();
}
member2.XmlAttributes = info2.xmlAttributes;
member2.SoapAttributes = info2.soapAttributes;
members[num3++] = member2;
if (identifiers != null)
{
identifiers.Add(member2.MemberName, null);
}
}
if (methodInfo.ReturnType != typeof(void))
{
XmlReflectionMember member3 = new XmlReflectionMember {
MemberName = identifiers.MakeUnique(method.name + "Result"),
MemberType = methodInfo.ReturnType,
IsReturnValue = true,
XmlAttributes = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider)
};
member3.XmlAttributes.XmlRoot = null;
member3.SoapAttributes = new SoapAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
members[0] = member3;
}
method.responseMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, method.rpc, method.use, method.paramStyle, str4, responseNs, attribute.responseNs == null, members, false, false, key + ":Response", !client);
}
SoapExtensionAttribute[] customAttributes = (SoapExtensionAttribute[])methodInfo.GetCustomAttributes(typeof(SoapExtensionAttribute));
method.extensions = new SoapReflectedExtension[customAttributes.Length];
for (int j = 0; j < customAttributes.Length; j++)
{
method.extensions[j] = new SoapReflectedExtension(customAttributes[j].ExtensionType, customAttributes[j]);
}
Array.Sort <SoapReflectedExtension>(method.extensions);
SoapHeaderAttribute[] array = (SoapHeaderAttribute[])methodInfo.GetCustomAttributes(typeof(SoapHeaderAttribute));
Array.Sort(array, new SoapHeaderAttributeComparer());
Hashtable hashtable = new Hashtable();
method.headers = new SoapReflectedHeader[array.Length];
int num6 = 0;
int length = method.headers.Length;
ArrayList list = new ArrayList();
ArrayList list2 = new ArrayList();
for (int k = 0; k < method.headers.Length; k++)
{
SoapHeaderAttribute attribute7 = array[k];
SoapReflectedHeader header = new SoapReflectedHeader();
Type declaringType = methodInfo.DeclaringType;
header.memberInfo = declaringType.GetField(attribute7.MemberName);
if (header.memberInfo != null)
{
header.headerType = ((FieldInfo)header.memberInfo).FieldType;
}
else
{
header.memberInfo = declaringType.GetProperty(attribute7.MemberName);
if (header.memberInfo == null)
{
throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderMissing");
}
header.headerType = ((PropertyInfo)header.memberInfo).PropertyType;
}
if (header.headerType.IsArray)
{
header.headerType = header.headerType.GetElementType();
header.repeats = true;
if ((header.headerType != typeof(SoapUnknownHeader)) && (header.headerType != typeof(SoapHeader)))
{
throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderType");
}
}
if (MemberHelper.IsStatic(header.memberInfo))
{
throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderStatic");
}
if (!MemberHelper.CanRead(header.memberInfo))
{
throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderRead");
}
if (!MemberHelper.CanWrite(header.memberInfo))
{
throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderWrite");
}
if (!typeof(SoapHeader).IsAssignableFrom(header.headerType))
{
throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderType");
}
SoapHeaderDirection direction = attribute7.Direction;
if (method.oneWay && ((direction & (SoapHeaderDirection.Fault | SoapHeaderDirection.Out)) != 0))
{
throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebHeaderOneWayOut");
}
if (hashtable.Contains(header.headerType))
{
SoapHeaderDirection direction2 = (SoapHeaderDirection)hashtable[header.headerType];
if ((direction2 & direction) != 0)
{
throw HeaderException(attribute7.MemberName, methodInfo.DeclaringType, "WebMultiplyDeclaredHeaderTypes");
}
hashtable[header.headerType] = direction | direction2;
}
else
{
hashtable[header.headerType] = direction;
}
if ((header.headerType != typeof(SoapHeader)) && (header.headerType != typeof(SoapUnknownHeader)))
{
XmlReflectionMember member4 = new XmlReflectionMember {
MemberName = header.headerType.Name,
MemberType = header.headerType
};
XmlAttributes attributes = new XmlAttributes(header.headerType);
if (attributes.XmlRoot != null)
{
member4.XmlAttributes = new XmlAttributes();
XmlElementAttribute attribute8 = new XmlElementAttribute {
ElementName = attributes.XmlRoot.ElementName,
Namespace = attributes.XmlRoot.Namespace
};
member4.XmlAttributes.XmlElements.Add(attribute8);
}
member4.OverrideIsNullable = true;
if ((direction & SoapHeaderDirection.In) != 0)
{
list.Add(member4);
}
if ((direction & (SoapHeaderDirection.Fault | SoapHeaderDirection.Out)) != 0)
{
list2.Add(member4);
}
header.custom = true;
}
header.direction = direction;
if (!header.custom)
{
method.headers[--length] = header;
}
else
{
method.headers[num6++] = header;
}
}
method.inHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, method.use, SoapParameterStyle.Bare, str2 + "InHeaders", defaultNs, true, (XmlReflectionMember[])list.ToArray(typeof(XmlReflectionMember)), false, true, key + ":InHeaders", client);
if (!method.oneWay)
{
method.outHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, method.use, SoapParameterStyle.Bare, str4 + "OutHeaders", defaultNs, true, (XmlReflectionMember[])list2.ToArray(typeof(XmlReflectionMember)), false, true, key + ":OutHeaders", !client);
}
method2 = method;
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebReflectionErrorMethod", new object[] { methodInfo.DeclaringType.Name, methodInfo.Name }), exception);
}
return(method2);
}
internal static SoapReflectedMethod ReflectMethod(LogicalMethodInfo methodInfo, bool client, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, string defaultNs)
{
try {
SoapReflectedMethod soapMethod = new SoapReflectedMethod();
MethodAttribute methodAttribute = new MethodAttribute();
object serviceAttr = GetSoapServiceAttribute(methodInfo.DeclaringType);
bool serviceDefaultIsEncoded = ServiceDefaultIsEncoded(serviceAttr);
object methodAttr = GetSoapMethodAttribute(methodInfo);
if (methodAttr == null)
{
if (client)
{
return(null); // method attribute required on the client
}
if (serviceAttr is SoapRpcServiceAttribute)
{
methodAttr = new SoapRpcMethodAttribute();
}
else
{
methodAttr = new SoapDocumentMethodAttribute();
}
}
if (methodAttr is SoapRpcMethodAttribute)
{
SoapRpcMethodAttribute attr = (SoapRpcMethodAttribute)methodAttr;
soapMethod.rpc = true;
soapMethod.use = SoapBindingUse.Encoded;
soapMethod.oneWay = attr.OneWay;
methodAttribute.action = attr.Action;
methodAttribute.binding = attr.Binding;
methodAttribute.requestName = attr.RequestElementName;
methodAttribute.requestNs = attr.RequestNamespace;
methodAttribute.responseName = attr.ResponseElementName;
methodAttribute.responseNs = attr.ResponseNamespace;
}
else
{
SoapDocumentMethodAttribute attr = (SoapDocumentMethodAttribute)methodAttr;
soapMethod.rpc = false;
soapMethod.use = attr.Use;
soapMethod.paramStyle = attr.ParameterStyle;
soapMethod.oneWay = attr.OneWay;
methodAttribute.action = attr.Action;
methodAttribute.binding = attr.Binding;
methodAttribute.requestName = attr.RequestElementName;
methodAttribute.requestNs = attr.RequestNamespace;
methodAttribute.responseName = attr.ResponseElementName;
methodAttribute.responseNs = attr.ResponseNamespace;
if (soapMethod.use == SoapBindingUse.Default)
{
if (serviceAttr is SoapDocumentServiceAttribute)
{
soapMethod.use = ((SoapDocumentServiceAttribute)serviceAttr).Use;
}
if (soapMethod.use == SoapBindingUse.Default)
{
soapMethod.use = SoapBindingUse.Literal;
}
}
if (soapMethod.paramStyle == SoapParameterStyle.Default)
{
if (serviceAttr is SoapDocumentServiceAttribute)
{
soapMethod.paramStyle = ((SoapDocumentServiceAttribute)serviceAttr).ParameterStyle;
}
if (soapMethod.paramStyle == SoapParameterStyle.Default)
{
soapMethod.paramStyle = SoapParameterStyle.Wrapped;
}
}
}
if (methodAttribute.binding.Length > 0)
{
if (client)
{
throw new InvalidOperationException(Res.GetString(Res.WebInvalidBindingPlacement, methodAttr.GetType().Name));
}
soapMethod.binding = WebServiceBindingReflector.GetAttribute(methodInfo, methodAttribute.binding);
}
WebMethodAttribute webMethodAttribute = WebMethodReflector.GetAttribute(methodInfo);
soapMethod.name = webMethodAttribute.MessageName;
if (soapMethod.name.Length == 0)
{
soapMethod.name = methodInfo.Name;
}
string requestElementName;
if (soapMethod.rpc)
{
requestElementName = methodInfo.Name;
}
else
{
requestElementName = methodAttribute.requestName.Length == 0 ? soapMethod.name : methodAttribute.requestName;
}
string requestNamespace = methodAttribute.requestNs;
if (requestNamespace == null)
{
if (soapMethod.binding != null && soapMethod.binding.Namespace != null && soapMethod.binding.Namespace.Length != 0)
{
requestNamespace = soapMethod.binding.Namespace;
}
else
{
requestNamespace = defaultNs;
}
}
string responseElementName = methodAttribute.responseName.Length == 0 ? soapMethod.name + "Response": methodAttribute.responseName;
string responseNamespace = methodAttribute.responseNs;
if (responseNamespace == null)
{
if (soapMethod.binding != null && soapMethod.binding.Namespace != null && soapMethod.binding.Namespace.Length != 0)
{
responseNamespace = soapMethod.binding.Namespace;
}
else
{
responseNamespace = defaultNs;
}
}
SoapParameterInfo[] inParameters = ReflectParameters(methodInfo.InParameters, requestNamespace);
SoapParameterInfo[] outParameters = ReflectParameters(methodInfo.OutParameters, responseNamespace);
soapMethod.action = methodAttribute.action;
if (soapMethod.action == null)
{
soapMethod.action = GetDefaultAction(defaultNs, methodInfo);
}
soapMethod.methodInfo = methodInfo;
if (soapMethod.oneWay)
{
if (outParameters.Length > 0)
{
throw new ArgumentException(Res.GetString(Res.WebOneWayOutParameters), "methodInfo");
}
if (methodInfo.ReturnType != typeof(void))
{
throw new ArgumentException(Res.GetString(Res.WebOneWayReturnValue), "methodInfo");
}
}
XmlReflectionMember[] members = new XmlReflectionMember[inParameters.Length];
for (int i = 0; i < members.Length; i++)
{
SoapParameterInfo soapParamInfo = inParameters[i];
XmlReflectionMember member = new XmlReflectionMember();
member.MemberName = soapParamInfo.parameterInfo.Name;
member.MemberType = soapParamInfo.parameterInfo.ParameterType;
if (member.MemberType.IsByRef)
{
member.MemberType = member.MemberType.GetElementType();
}
member.XmlAttributes = soapParamInfo.xmlAttributes;
member.SoapAttributes = soapParamInfo.soapAttributes;
members[i] = member;
}
soapMethod.requestMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, requestElementName, requestNamespace, methodAttribute.requestNs == null, members, true);
if (GetSoapServiceRoutingStyle(serviceAttr) == SoapServiceRoutingStyle.RequestElement &&
soapMethod.paramStyle == SoapParameterStyle.Bare &&
soapMethod.requestMappings.Count != 1)
{
throw new ArgumentException(Res.GetString(Res.WhenUsingAMessageStyleOfParametersAsDocument0), "methodInfo");
}
string elementName = "";
string elementNamespace = "";
if (soapMethod.paramStyle == SoapParameterStyle.Bare)
{
if (soapMethod.requestMappings.Count == 1)
{
elementName = soapMethod.requestMappings[0].ElementName;
elementNamespace = soapMethod.requestMappings[0].Namespace;
}
// else: can't route on request element -- we match on an empty qname,
// normal rules apply for duplicates
}
else
{
elementName = soapMethod.requestMappings.ElementName;
elementNamespace = soapMethod.requestMappings.Namespace;
}
soapMethod.requestElementName = new XmlQualifiedName(elementName, elementNamespace);
if (!soapMethod.oneWay)
{
int numOutParams = outParameters.Length;
int count = 0;
CodeIdentifiers identifiers = null;
if (methodInfo.ReturnType != typeof(void))
{
numOutParams++;
count = 1;
identifiers = new CodeIdentifiers();
}
members = new XmlReflectionMember[numOutParams];
for (int i = 0; i < outParameters.Length; i++)
{
SoapParameterInfo soapParamInfo = outParameters[i];
XmlReflectionMember member = new XmlReflectionMember();
member.MemberName = soapParamInfo.parameterInfo.Name;
member.MemberType = soapParamInfo.parameterInfo.ParameterType;
if (member.MemberType.IsByRef)
{
member.MemberType = member.MemberType.GetElementType();
}
member.XmlAttributes = soapParamInfo.xmlAttributes;
member.SoapAttributes = soapParamInfo.soapAttributes;
members[count++] = member;
if (identifiers != null)
{
identifiers.Add(member.MemberName, null);
}
}
if (methodInfo.ReturnType != typeof(void))
{
XmlReflectionMember member = new XmlReflectionMember();
member.MemberName = identifiers.MakeUnique(soapMethod.name + "Result");
member.MemberType = methodInfo.ReturnType;
member.IsReturnValue = true;
member.XmlAttributes = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
member.XmlAttributes.XmlRoot = null; // Ignore XmlRoot attribute used by get/post
member.SoapAttributes = new SoapAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
members[0] = member;
}
soapMethod.responseMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, responseElementName, responseNamespace, methodAttribute.responseNs == null, members, false);
}
SoapExtensionAttribute[] extensionAttributes = (SoapExtensionAttribute[])methodInfo.GetCustomAttributes(typeof(SoapExtensionAttribute));
soapMethod.extensions = new SoapReflectedExtension[extensionAttributes.Length];
for (int i = 0; i < extensionAttributes.Length; i++)
{
soapMethod.extensions[i] = new SoapReflectedExtension(extensionAttributes[i].ExtensionType, extensionAttributes[i]);
}
Array.Sort(soapMethod.extensions);
SoapHeaderAttribute[] headerAttributes = (SoapHeaderAttribute[])methodInfo.GetCustomAttributes(typeof(SoapHeaderAttribute));
Array.Sort(headerAttributes, new SoapHeaderAttributeComparer());
Hashtable headerTypes = new Hashtable();
soapMethod.headers = new SoapReflectedHeader[headerAttributes.Length];
int front = 0;
int back = soapMethod.headers.Length;
ArrayList inHeaders = new ArrayList();
ArrayList outHeaders = new ArrayList();
for (int i = 0; i < soapMethod.headers.Length; i++)
{
SoapHeaderAttribute headerAttribute = headerAttributes[i];
SoapReflectedHeader soapHeader = new SoapReflectedHeader();
Type declaringType = methodInfo.DeclaringType;
if ((soapHeader.memberInfo = declaringType.GetField(headerAttribute.MemberName)) != null)
{
soapHeader.headerType = ((FieldInfo)soapHeader.memberInfo).FieldType;
}
else if ((soapHeader.memberInfo = declaringType.GetProperty(headerAttribute.MemberName)) != null)
{
soapHeader.headerType = ((PropertyInfo)soapHeader.memberInfo).PropertyType;
}
else
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderMissing);
}
if (soapHeader.headerType.IsArray)
{
soapHeader.headerType = soapHeader.headerType.GetElementType();
soapHeader.repeats = true;
if (soapHeader.headerType != typeof(SoapUnknownHeader) && soapHeader.headerType != typeof(SoapHeader))
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderType);
}
}
if (MemberHelper.IsStatic(soapHeader.memberInfo))
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderStatic);
}
if (!MemberHelper.CanRead(soapHeader.memberInfo))
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderRead);
}
if (!MemberHelper.CanWrite(soapHeader.memberInfo))
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderWrite);
}
if (!typeof(SoapHeader).IsAssignableFrom(soapHeader.headerType))
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderType);
}
SoapHeaderDirection direction = headerAttribute.Direction;
if (soapMethod.oneWay && (direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebHeaderOneWayOut);
}
if (headerTypes.Contains(soapHeader.headerType))
{
SoapHeaderDirection prevDirection = (SoapHeaderDirection)headerTypes[soapHeader.headerType];
if ((prevDirection & direction) != 0)
{
throw HeaderException(headerAttribute.MemberName, methodInfo.DeclaringType, Res.WebMultiplyDeclaredHeaderTypes);
}
headerTypes[soapHeader.headerType] = direction | prevDirection;
}
else
{
headerTypes[soapHeader.headerType] = direction;
}
if (soapHeader.headerType != typeof(SoapHeader) && soapHeader.headerType != typeof(SoapUnknownHeader))
{
XmlReflectionMember member = new XmlReflectionMember();
member.MemberName = soapHeader.headerType.Name;
member.MemberType = soapHeader.headerType;
member.OverrideIsNullable = true;
if ((direction & SoapHeaderDirection.In) != 0)
{
inHeaders.Add(member);
}
if ((direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
{
outHeaders.Add(member);
}
soapHeader.custom = true;
}
soapHeader.direction = direction;
// Put generic header mappings at the end of the list so they are found last during header processing
if (!soapHeader.custom)
{
soapMethod.headers[--back] = soapHeader;
}
else
{
soapMethod.headers[front++] = soapHeader;
}
}
soapMethod.inHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, "InHeaders", defaultNs, true, (XmlReflectionMember[])inHeaders.ToArray(typeof(XmlReflectionMember)), false);
if (!soapMethod.oneWay)
{
soapMethod.outHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, "OutHeaders", defaultNs, true, (XmlReflectionMember[])outHeaders.ToArray(typeof(XmlReflectionMember)), false);
}
return(soapMethod);
}
catch (Exception e) {
throw new InvalidOperationException(Res.GetString(Res.WebReflectionErrorMethod, methodInfo.DeclaringType.Name, methodInfo.Name), e);
}
}