protected override MethodStubInfo CreateMethodStubInfo(TypeStubInfo parent, LogicalMethodInfo lmi, bool isClientProxy)
{
SoapMethodStubInfo res = null;
object [] ats = lmi.GetCustomAttributes(typeof(SoapDocumentMethodAttribute));
if (ats.Length == 0)
{
ats = lmi.GetCustomAttributes(typeof(SoapRpcMethodAttribute));
}
if (ats.Length == 0 && isClientProxy)
{
return(null);
}
else if (ats.Length == 0)
{
res = new SoapMethodStubInfo(parent, lmi, null, xmlImporter, soapImporter);
}
else
{
res = new SoapMethodStubInfo(parent, lmi, ats[0], xmlImporter, soapImporter);
}
methods_byaction [res.Action] = res;
return(res);
}
internal static string GetSoapMethodBinding(LogicalMethodInfo method)
{
string binding;
object[] customAttributes = method.GetCustomAttributes(typeof(SoapDocumentMethodAttribute));
if (customAttributes.Length == 0)
{
customAttributes = method.GetCustomAttributes(typeof(SoapRpcMethodAttribute));
if (customAttributes.Length == 0)
{
binding = string.Empty;
}
else
{
binding = ((SoapRpcMethodAttribute)customAttributes[0]).Binding;
}
}
else
{
binding = ((SoapDocumentMethodAttribute)customAttributes[0]).Binding;
}
if (method.Binding == null)
{
return(binding);
}
if ((binding.Length > 0) && (binding != method.Binding.Name))
{
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebInvalidBindingName", new object[] { binding, method.Binding.Name }));
}
return(method.Binding.Name);
}
internal static string GetSoapMethodBinding(LogicalMethodInfo method)
{
string binding;
object[] attrs = method.GetCustomAttributes(typeof(SoapDocumentMethodAttribute));
if (attrs.Length == 0)
{
attrs = method.GetCustomAttributes(typeof(SoapRpcMethodAttribute));
if (attrs.Length == 0)
{
binding = string.Empty;
}
else
{
binding = ((SoapRpcMethodAttribute)attrs[0]).Binding;
}
}
else
{
binding = ((SoapDocumentMethodAttribute)attrs[0]).Binding;
}
if (method.Binding != null)
{
if (binding.Length > 0 && binding != method.Binding.Name)
{
throw new InvalidOperationException(Res.GetString(Res.WebInvalidBindingName, binding, method.Binding.Name));
}
return(method.Binding.Name);
}
return(binding);
}
internal static string GetSoapMethodBinding(LogicalMethodInfo method)
{
string binding;
object[] customAttributes = method.GetCustomAttributes(typeof(SoapDocumentMethodAttribute));
if (customAttributes.Length == 0)
{
customAttributes = method.GetCustomAttributes(typeof(SoapRpcMethodAttribute));
if (customAttributes.Length == 0)
{
binding = string.Empty;
}
else
{
binding = ((SoapRpcMethodAttribute) customAttributes[0]).Binding;
}
}
else
{
binding = ((SoapDocumentMethodAttribute) customAttributes[0]).Binding;
}
if (method.Binding == null)
{
return binding;
}
if ((binding.Length > 0) && (binding != method.Binding.Name))
{
throw new InvalidOperationException(System.Web.Services.Res.GetString("WebInvalidBindingName", new object[] { binding, method.Binding.Name }));
}
return method.Binding.Name;
}
internal static string GetSoapMethodBinding(LogicalMethodInfo method)
{
object[] attrs = method.GetCustomAttributes(typeof(SoapDocumentMethodAttribute));
if (attrs.Length == 0)
{
attrs = method.GetCustomAttributes(typeof(SoapRpcMethodAttribute));
if (attrs.Length == 0)
{
return(string.Empty);
}
return(((SoapRpcMethodAttribute)attrs[0]).Binding);
}
else
{
return(((SoapDocumentMethodAttribute)attrs[0]).Binding);
}
}
internal static object GetSoapMethodAttribute(LogicalMethodInfo methodInfo)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(SoapRpcMethodAttribute));
object[] objArray2 = methodInfo.GetCustomAttributes(typeof(SoapDocumentMethodAttribute));
if (customAttributes.Length > 0)
{
if (objArray2.Length > 0)
{
throw new ArgumentException(System.Web.Services.Res.GetString("WebBothMethodAttrs"), "methodInfo");
}
return customAttributes[0];
}
if (objArray2.Length > 0)
{
return objArray2[0];
}
return null;
}
internal static object GetSoapMethodAttribute(LogicalMethodInfo methodInfo)
{
object[] customAttributes = methodInfo.GetCustomAttributes(typeof(SoapRpcMethodAttribute));
object[] objArray2 = methodInfo.GetCustomAttributes(typeof(SoapDocumentMethodAttribute));
if (customAttributes.Length > 0)
{
if (objArray2.Length > 0)
{
throw new ArgumentException(System.Web.Services.Res.GetString("WebBothMethodAttrs"), "methodInfo");
}
return(customAttributes[0]);
}
if (objArray2.Length > 0)
{
return(objArray2[0]);
}
return(null);
}
internal HttpClientType(Type type)
{
LogicalMethodInfo[] methodInfos = LogicalMethodInfo.Create(type.GetMethods(), LogicalMethodTypes.Sync);
Hashtable formatterTypes = new Hashtable();
for (int i = 0; i < methodInfos.Length; i++)
{
LogicalMethodInfo methodInfo = methodInfos[i];
try {
object[] attributes = methodInfo.GetCustomAttributes(typeof(HttpMethodAttribute));
if (attributes.Length == 0)
{
continue;
}
HttpMethodAttribute attribute = (HttpMethodAttribute)attributes[0];
HttpClientMethod method = new HttpClientMethod();
method.readerType = attribute.ReturnFormatter;
method.writerType = attribute.ParameterFormatter;
method.methodInfo = methodInfo;
AddFormatter(formatterTypes, method.readerType, method);
AddFormatter(formatterTypes, method.writerType, method);
methods.Add(methodInfo.Name, method);
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException)
{
throw;
}
throw new InvalidOperationException(Res.GetString(Res.WebReflectionError, methodInfo.DeclaringType.FullName, methodInfo.Name), e);
}
}
foreach (Type t in formatterTypes.Keys)
{
ArrayList list = (ArrayList)formatterTypes[t];
LogicalMethodInfo[] m = new LogicalMethodInfo[list.Count];
for (int j = 0; j < list.Count; j++)
{
m[j] = ((HttpClientMethod)list[j]).methodInfo;
}
object[] initializers = MimeFormatter.GetInitializers(t, m);
bool isWriter = typeof(MimeParameterWriter).IsAssignableFrom(t);
for (int j = 0; j < list.Count; j++)
{
if (isWriter)
{
((HttpClientMethod)list[j]).writerInitializer = initializers[j];
}
else
{
((HttpClientMethod)list[j]).readerInitializer = initializers[j];
}
}
}
}
internal HttpClientType(Type type)
{
LogicalMethodInfo[] infoArray = LogicalMethodInfo.Create(type.GetMethods(), LogicalMethodTypes.Sync);
Hashtable formatterTypes = new Hashtable();
for (int i = 0; i < infoArray.Length; i++)
{
LogicalMethodInfo info = infoArray[i];
try
{
object[] customAttributes = info.GetCustomAttributes(typeof(HttpMethodAttribute));
if (customAttributes.Length != 0)
{
HttpMethodAttribute attribute = (HttpMethodAttribute)customAttributes[0];
HttpClientMethod method = new HttpClientMethod {
readerType = attribute.ReturnFormatter,
writerType = attribute.ParameterFormatter,
methodInfo = info
};
AddFormatter(formatterTypes, method.readerType, method);
AddFormatter(formatterTypes, method.writerType, method);
this.methods.Add(info.Name, method);
}
}
catch (Exception exception)
{
if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
{
throw;
}
throw new InvalidOperationException(Res.GetString("WebReflectionError", new object[] { info.DeclaringType.FullName, info.Name }), exception);
}
}
foreach (Type type2 in formatterTypes.Keys)
{
ArrayList list = (ArrayList)formatterTypes[type2];
LogicalMethodInfo[] methodInfos = new LogicalMethodInfo[list.Count];
for (int j = 0; j < list.Count; j++)
{
methodInfos[j] = ((HttpClientMethod)list[j]).methodInfo;
}
object[] initializers = MimeFormatter.GetInitializers(type2, methodInfos);
bool flag = typeof(MimeParameterWriter).IsAssignableFrom(type2);
for (int k = 0; k < list.Count; k++)
{
if (flag)
{
((HttpClientMethod)list[k]).writerInitializer = initializers[k];
}
else
{
((HttpClientMethod)list[k]).readerInitializer = initializers[k];
}
}
}
}
internal static object GetSoapMethodAttribute(LogicalMethodInfo methodInfo)
{
object[] rpcMethodAttributes = methodInfo.GetCustomAttributes(typeof(SoapRpcMethodAttribute));
object[] docMethodAttributes = methodInfo.GetCustomAttributes(typeof(SoapDocumentMethodAttribute));
if (rpcMethodAttributes.Length > 0)
{
if (docMethodAttributes.Length > 0)
{
throw new ArgumentException(Res.GetString(Res.WebBothMethodAttrs), "methodInfo");
}
return(rpcMethodAttributes[0]);
}
else if (docMethodAttributes.Length > 0)
{
return(docMethodAttributes[0]);
}
else
{
return(null);
}
}
//
// Constructor
//
public MethodStubInfo (TypeStubInfo parent, LogicalMethodInfo source)
{
TypeStub = parent;
MethodInfo = source;
object [] o = source.GetCustomAttributes (typeof (WebMethodAttribute));
if (o.Length > 0)
{
MethodAttribute = (WebMethodAttribute) o [0];
Name = MethodAttribute.MessageName;
if (Name == "") Name = source.Name;
}
else
Name = source.Name;
}
internal static SoapExtensionRuntimeConfig[] GetMethodExtensions(LogicalMethodInfo method)
{
object[] ats = method.GetCustomAttributes(typeof(SoapExtensionAttribute));
SoapExtensionRuntimeConfig[] exts = new SoapExtensionRuntimeConfig [ats.Length];
int[] priorities = new int[ats.Length];
for (int n = 0; n < ats.Length; n++)
{
SoapExtensionAttribute at = (SoapExtensionAttribute)ats[n];
SoapExtensionRuntimeConfig econf = new SoapExtensionRuntimeConfig();
econf.Type = at.ExtensionType;
priorities [n] = at.Priority;
SoapExtension ext = (SoapExtension)Activator.CreateInstance(econf.Type);
econf.InitializationInfo = ext.GetInitializer(method, at);
exts [n] = econf;
}
Array.Sort(priorities, exts);
return(exts);
}
//
// Constructor
//
public MethodStubInfo(TypeStubInfo parent, LogicalMethodInfo source)
{
TypeStub = parent;
MethodInfo = source;
object [] o = source.GetCustomAttributes(typeof(WebMethodAttribute));
if (o.Length > 0)
{
MethodAttribute = (WebMethodAttribute)o [0];
Name = MethodAttribute.MessageName;
if (Name == "")
{
Name = source.Name;
}
}
else
{
Name = source.Name;
}
}
protected override MethodStubInfo CreateMethodStubInfo (TypeStubInfo parent, LogicalMethodInfo lmi, bool isClientProxy)
{
SoapMethodStubInfo res = null;
object [] ats = lmi.GetCustomAttributes (typeof (SoapDocumentMethodAttribute));
if (ats.Length == 0) ats = lmi.GetCustomAttributes (typeof (SoapRpcMethodAttribute));
if (ats.Length == 0 && isClientProxy)
return null;
else if (ats.Length == 0)
res = new SoapMethodStubInfo (parent, lmi, null, xmlImporter, soapImporter);
else
res = new SoapMethodStubInfo (parent, lmi, ats[0], xmlImporter, soapImporter);
methods_byaction [res.Action] = res;
return res;
}
//
// Constructor
//
public SoapMethodStubInfo (TypeStubInfo typeStub, LogicalMethodInfo source, object kind, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter)
: base (typeStub, source)
{
SoapTypeStubInfo parent = (SoapTypeStubInfo) typeStub;
XmlElementAttribute optional_ns = null;
if (kind == null) {
Use = parent.LogicalType.BindingUse;
RequestName = "";
RequestNamespace = "";
ResponseName = "";
ResponseNamespace = "";
ParameterStyle = parent.ParameterStyle;
SoapBindingStyle = parent.SoapBindingStyle;
OneWay = false;
// disabled (see bug #332150)
//#if NET_2_0
// if (parent.Type != source.DeclaringType)
// Binding = source.DeclaringType.Name + parent.ProtocolName;
//#endif
}
else if (kind is SoapDocumentMethodAttribute){
SoapDocumentMethodAttribute dma = (SoapDocumentMethodAttribute) kind;
Use = dma.Use;
if (Use == SoapBindingUse.Default) {
if (parent.SoapBindingStyle == SoapBindingStyle.Document)
Use = parent.LogicalType.BindingUse;
else
Use = SoapBindingUse.Literal;
}
Action = dma.Action;
Binding = dma.Binding;
RequestName = dma.RequestElementName;
RequestNamespace = dma.RequestNamespace;
ResponseName = dma.ResponseElementName;
ResponseNamespace = dma.ResponseNamespace;
ParameterStyle = dma.ParameterStyle;
if (ParameterStyle == SoapParameterStyle.Default)
ParameterStyle = parent.ParameterStyle;
OneWay = dma.OneWay;
SoapBindingStyle = SoapBindingStyle.Document;
} else {
SoapRpcMethodAttribute rma = (SoapRpcMethodAttribute) kind;
Use = SoapBindingUse.Encoded; // RPC always use encoded
Action = rma.Action;
if (Action != null && Action.Length == 0)
Action = null;
Binding = rma.Binding;
// When using RPC, MS.NET seems to ignore RequestElementName and
// MessageName, and it always uses the method name
RequestName = source.Name;
ResponseName = source.Name + "Response";
// RequestName = rma.RequestElementName;
// ResponseName = rma.ResponseElementName;
RequestNamespace = rma.RequestNamespace;
ResponseNamespace = rma.ResponseNamespace;
ParameterStyle = SoapParameterStyle.Wrapped;
OneWay = rma.OneWay;
SoapBindingStyle = SoapBindingStyle.Rpc;
// For RPC calls, make all arguments be part of the empty namespace
optional_ns = new XmlElementAttribute ();
optional_ns.Namespace = "";
}
if (OneWay){
if (source.ReturnType != typeof (void))
throw new Exception ("OneWay methods should not have a return value.");
if (source.OutParameters.Length != 0)
throw new Exception ("OneWay methods should not have out/ref parameters.");
}
BindingInfo binfo = parent.GetBinding (Binding);
if (binfo == null) throw new InvalidOperationException ("Type '" + parent.Type + "' is missing WebServiceBinding attribute that defines a binding named '" + Binding + "'.");
string serviceNamespace = binfo.Namespace;
if (RequestNamespace == "") RequestNamespace = parent.LogicalType.GetWebServiceNamespace (serviceNamespace, Use);
if (ResponseNamespace == "") ResponseNamespace = parent.LogicalType.GetWebServiceNamespace (serviceNamespace, Use);
if (RequestName == "") RequestName = Name;
if (ResponseName == "") ResponseName = Name + "Response";
if (Action == null)
Action = serviceNamespace.EndsWith("/") ? (serviceNamespace + Name) : (serviceNamespace + "/" + Name);
bool hasWrappingElem = (ParameterStyle == SoapParameterStyle.Wrapped);
bool writeAccessors = (SoapBindingStyle == SoapBindingStyle.Rpc);
XmlReflectionMember [] in_members = BuildRequestReflectionMembers (optional_ns);
XmlReflectionMember [] out_members = BuildResponseReflectionMembers (optional_ns);
if (Use == SoapBindingUse.Literal) {
xmlImporter.IncludeTypes (source.CustomAttributeProvider);
InputMembersMapping = xmlImporter.ImportMembersMapping (RequestName, RequestNamespace, in_members, hasWrappingElem);
OutputMembersMapping = xmlImporter.ImportMembersMapping (ResponseName, ResponseNamespace, out_members, hasWrappingElem);
}
else {
soapImporter.IncludeTypes (source.CustomAttributeProvider);
InputMembersMapping = soapImporter.ImportMembersMapping (RequestName, RequestNamespace, in_members, hasWrappingElem, writeAccessors);
OutputMembersMapping = soapImporter.ImportMembersMapping (ResponseName, ResponseNamespace, out_members, hasWrappingElem, writeAccessors);
}
InputMembersMapping.SetKey(RequestName);
OutputMembersMapping.SetKey(ResponseName);
requestSerializerId = parent.RegisterSerializer (InputMembersMapping);
responseSerializerId = parent.RegisterSerializer (OutputMembersMapping);
object[] o = source.GetCustomAttributes (typeof (SoapHeaderAttribute));
ArrayList allHeaderList = new ArrayList (o.Length);
ArrayList inHeaderList = new ArrayList (o.Length);
ArrayList outHeaderList = new ArrayList (o.Length);
ArrayList faultHeaderList = new ArrayList ();
SoapHeaderDirection unknownHeaderDirections = (SoapHeaderDirection)0;
for (int i = 0; i < o.Length; i++) {
SoapHeaderAttribute att = (SoapHeaderAttribute) o[i];
MemberInfo[] mems = source.DeclaringType.GetMember (att.MemberName);
if (mems.Length == 0) throw new InvalidOperationException ("Member " + att.MemberName + " not found in class " + source.DeclaringType.FullName + ".");
HeaderInfo header = new HeaderInfo (mems[0], att);
allHeaderList.Add (header);
if (!header.Custom) {
if ((header.Direction & SoapHeaderDirection.In) != 0)
inHeaderList.Add (header);
if ((header.Direction & SoapHeaderDirection.Out) != 0)
outHeaderList.Add (header);
if ((header.Direction & SoapHeaderDirection.Fault) != 0)
faultHeaderList.Add (header);
} else
unknownHeaderDirections |= header.Direction;
}
Headers = (HeaderInfo[]) allHeaderList.ToArray (typeof(HeaderInfo));
if (inHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.In) != 0) {
InHeaders = (HeaderInfo[]) inHeaderList.ToArray (typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers (InHeaders);
if (Use == SoapBindingUse.Literal)
InputHeaderMembersMapping = xmlImporter.ImportMembersMapping ("", RequestNamespace, members, false);
else
InputHeaderMembersMapping = soapImporter.ImportMembersMapping ("", RequestNamespace, members, false, false);
InputHeaderMembersMapping.SetKey(RequestName + ":InHeaders");
requestHeadersSerializerId = parent.RegisterSerializer (InputHeaderMembersMapping);
}
if (outHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Out) != 0) {
OutHeaders = (HeaderInfo[]) outHeaderList.ToArray (typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers (OutHeaders);
if (Use == SoapBindingUse.Literal)
OutputHeaderMembersMapping = xmlImporter.ImportMembersMapping ("", RequestNamespace, members, false);
else
OutputHeaderMembersMapping = soapImporter.ImportMembersMapping ("", RequestNamespace, members, false, false);
OutputHeaderMembersMapping.SetKey(ResponseName + ":OutHeaders");
responseHeadersSerializerId = parent.RegisterSerializer (OutputHeaderMembersMapping);
}
if (faultHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Fault) != 0) {
FaultHeaders = (HeaderInfo[]) faultHeaderList.ToArray (typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers (FaultHeaders);
if (Use == SoapBindingUse.Literal)
FaultHeaderMembersMapping = xmlImporter.ImportMembersMapping ("", RequestNamespace, members, false);
else
FaultHeaderMembersMapping = soapImporter.ImportMembersMapping ("", RequestNamespace, members, false, false);
faultHeadersSerializerId = parent.RegisterSerializer (FaultHeaderMembersMapping);
}
SoapExtensions = SoapExtension.GetMethodExtensions (source);
}
internal static SoapExtensionRuntimeConfig[] GetMethodExtensions (LogicalMethodInfo method)
{
object[] ats = method.GetCustomAttributes (typeof (SoapExtensionAttribute));
SoapExtensionRuntimeConfig[] exts = new SoapExtensionRuntimeConfig [ats.Length];
int[] priorities = new int[ats.Length];
for (int n=0; n<ats.Length; n++)
{
SoapExtensionAttribute at = (SoapExtensionAttribute) ats[n];
SoapExtensionRuntimeConfig econf = new SoapExtensionRuntimeConfig ();
econf.Type = at.ExtensionType;
priorities [n] = at.Priority;
SoapExtension ext = (SoapExtension) Activator.CreateInstance (econf.Type);
econf.InitializationInfo = ext.GetInitializer (method, at);
exts [n] = econf;
}
Array.Sort (priorities, exts);
return exts;
}
//
// Constructor
//
public SoapMethodStubInfo(TypeStubInfo typeStub, LogicalMethodInfo source, object kind, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter)
: base(typeStub, source)
{
SoapTypeStubInfo parent = (SoapTypeStubInfo)typeStub;
XmlElementAttribute optional_ns = null;
if (kind == null)
{
Use = parent.LogicalType.BindingUse;
RequestName = "";
RequestNamespace = "";
ResponseName = "";
ResponseNamespace = "";
ParameterStyle = parent.ParameterStyle;
SoapBindingStyle = parent.SoapBindingStyle;
OneWay = false;
// disabled (see bug #332150)
//#if NET_2_0
// if (parent.Type != source.DeclaringType)
// Binding = source.DeclaringType.Name + parent.ProtocolName;
//#endif
}
else if (kind is SoapDocumentMethodAttribute)
{
SoapDocumentMethodAttribute dma = (SoapDocumentMethodAttribute)kind;
Use = dma.Use;
if (Use == SoapBindingUse.Default)
{
if (parent.SoapBindingStyle == SoapBindingStyle.Document)
{
Use = parent.LogicalType.BindingUse;
}
else
{
Use = SoapBindingUse.Literal;
}
}
Action = dma.Action;
Binding = dma.Binding;
RequestName = dma.RequestElementName;
RequestNamespace = dma.RequestNamespace;
ResponseName = dma.ResponseElementName;
ResponseNamespace = dma.ResponseNamespace;
ParameterStyle = dma.ParameterStyle;
if (ParameterStyle == SoapParameterStyle.Default)
{
ParameterStyle = parent.ParameterStyle;
}
OneWay = dma.OneWay;
SoapBindingStyle = SoapBindingStyle.Document;
}
else
{
SoapRpcMethodAttribute rma = (SoapRpcMethodAttribute)kind;
Use = SoapBindingUse.Encoded; // RPC always use encoded
Action = rma.Action;
if (Action != null && Action.Length == 0)
{
Action = null;
}
Binding = rma.Binding;
// When using RPC, MS.NET seems to ignore RequestElementName and
// MessageName, and it always uses the method name
RequestName = source.Name;
ResponseName = source.Name + "Response";
// RequestName = rma.RequestElementName;
// ResponseName = rma.ResponseElementName;
RequestNamespace = rma.RequestNamespace;
ResponseNamespace = rma.ResponseNamespace;
ParameterStyle = SoapParameterStyle.Wrapped;
OneWay = rma.OneWay;
SoapBindingStyle = SoapBindingStyle.Rpc;
// For RPC calls, make all arguments be part of the empty namespace
optional_ns = new XmlElementAttribute();
optional_ns.Namespace = "";
}
if (OneWay)
{
if (source.ReturnType != typeof(void))
{
throw new Exception("OneWay methods should not have a return value.");
}
if (source.OutParameters.Length != 0)
{
throw new Exception("OneWay methods should not have out/ref parameters.");
}
}
BindingInfo binfo = parent.GetBinding(Binding);
if (binfo == null)
{
throw new InvalidOperationException("Type '" + parent.Type + "' is missing WebServiceBinding attribute that defines a binding named '" + Binding + "'.");
}
string serviceNamespace = binfo.Namespace;
if (RequestNamespace == "")
{
RequestNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use);
}
if (ResponseNamespace == "")
{
ResponseNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use);
}
if (RequestName == "")
{
RequestName = Name;
}
if (ResponseName == "")
{
ResponseName = Name + "Response";
}
if (Action == null)
{
Action = serviceNamespace.EndsWith("/") ? (serviceNamespace + Name) : (serviceNamespace + "/" + Name);
}
bool hasWrappingElem = (ParameterStyle == SoapParameterStyle.Wrapped);
bool writeAccessors = (SoapBindingStyle == SoapBindingStyle.Rpc);
XmlReflectionMember [] in_members = BuildRequestReflectionMembers(optional_ns);
XmlReflectionMember [] out_members = BuildResponseReflectionMembers(optional_ns);
if (Use == SoapBindingUse.Literal)
{
xmlImporter.IncludeTypes(source.CustomAttributeProvider);
InputMembersMapping = xmlImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem);
OutputMembersMapping = xmlImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem);
}
else
{
soapImporter.IncludeTypes(source.CustomAttributeProvider);
InputMembersMapping = soapImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem, writeAccessors);
OutputMembersMapping = soapImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem, writeAccessors);
}
requestSerializerId = parent.RegisterSerializer(InputMembersMapping);
responseSerializerId = parent.RegisterSerializer(OutputMembersMapping);
object[] o = source.GetCustomAttributes(typeof(SoapHeaderAttribute));
ArrayList allHeaderList = new ArrayList(o.Length);
ArrayList inHeaderList = new ArrayList(o.Length);
ArrayList outHeaderList = new ArrayList(o.Length);
ArrayList faultHeaderList = new ArrayList();
SoapHeaderDirection unknownHeaderDirections = (SoapHeaderDirection)0;
for (int i = 0; i < o.Length; i++)
{
SoapHeaderAttribute att = (SoapHeaderAttribute)o[i];
MemberInfo[] mems = source.DeclaringType.GetMember(att.MemberName);
if (mems.Length == 0)
{
throw new InvalidOperationException("Member " + att.MemberName + " not found in class " + source.DeclaringType.FullName + ".");
}
HeaderInfo header = new HeaderInfo(mems[0], att);
allHeaderList.Add(header);
if (!header.Custom)
{
if ((header.Direction & SoapHeaderDirection.In) != 0)
{
inHeaderList.Add(header);
}
if ((header.Direction & SoapHeaderDirection.Out) != 0)
{
outHeaderList.Add(header);
}
if ((header.Direction & SoapHeaderDirection.Fault) != 0)
{
faultHeaderList.Add(header);
}
}
else
{
unknownHeaderDirections |= header.Direction;
}
}
Headers = (HeaderInfo[])allHeaderList.ToArray(typeof(HeaderInfo));
if (inHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.In) != 0)
{
InHeaders = (HeaderInfo[])inHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(InHeaders);
if (Use == SoapBindingUse.Literal)
{
InputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
InputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
requestHeadersSerializerId = parent.RegisterSerializer(InputHeaderMembersMapping);
}
if (outHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Out) != 0)
{
OutHeaders = (HeaderInfo[])outHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(OutHeaders);
if (Use == SoapBindingUse.Literal)
{
OutputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
OutputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
responseHeadersSerializerId = parent.RegisterSerializer(OutputHeaderMembersMapping);
}
if (faultHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Fault) != 0)
{
FaultHeaders = (HeaderInfo[])faultHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(FaultHeaders);
if (Use == SoapBindingUse.Literal)
{
FaultHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
FaultHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
faultHeadersSerializerId = parent.RegisterSerializer(FaultHeaderMembersMapping);
}
SoapExtensions = SoapExtension.GetMethodExtensions(source);
}
internal static SoapReflectedMethod ReflectMethod(LogicalMethodInfo methodInfo, bool client, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, string defaultNs) {
try {
string methodId = methodInfo.GetKey();
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) {
SoapRpcMethodAttribute method = new SoapRpcMethodAttribute();
method.Use = ((SoapRpcServiceAttribute)serviceAttr).Use;
methodAttr = method;
}
else if (serviceAttr is SoapDocumentServiceAttribute) {
SoapDocumentMethodAttribute method = new SoapDocumentMethodAttribute();
method.Use = ((SoapDocumentServiceAttribute)serviceAttr).Use;
methodAttr = method;
}
else {
methodAttr = new SoapDocumentMethodAttribute();
}
}
if (methodAttr is SoapRpcMethodAttribute) {
SoapRpcMethodAttribute attr = (SoapRpcMethodAttribute)methodAttr;
soapMethod.rpc = true;
soapMethod.use = attr.Use;
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 = methodInfo.MethodAttribute;
//
soapMethod.name = webMethodAttribute.MessageName;
if (soapMethod.name.Length == 0) soapMethod.name = methodInfo.Name;
string requestElementName;
if (soapMethod.rpc) {
// in the case when we interop with non .net we might need to chnage the method name.
requestElementName = methodAttribute.requestName.Length == 0 || !client ? methodInfo.Name : methodAttribute.requestName;
}
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;
if (soapMethod.rpc && soapMethod.use != SoapBindingUse.Encoded)
{
// NOTE: this rule should apply equally to rpc/lit and rpc/enc, but to reduce risk, i'm only applying it to rpc/lit
responseElementName = methodInfo.Name + "Response";
}
else
{
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, false, methodId, client);
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].XsdElementName;
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.XsdElementName;
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, false, methodId + ":Response", !client);
}
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;
XmlAttributes a = new XmlAttributes(soapHeader.headerType);
if (a.XmlRoot != null) {
member.XmlAttributes = new XmlAttributes();
XmlElementAttribute attr = new XmlElementAttribute();
attr.ElementName = a.XmlRoot.ElementName;
attr.Namespace = a.XmlRoot.Namespace;
member.XmlAttributes.XmlElements.Add(attr);
}
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, requestElementName + "InHeaders", defaultNs, true, (XmlReflectionMember[]) inHeaders.ToArray(typeof(XmlReflectionMember)), false, true, methodId + ":InHeaders", client);
if (!soapMethod.oneWay)
soapMethod.outHeaderMappings = ImportMembersMapping(xmlImporter, soapImporter, serviceDefaultIsEncoded, false, soapMethod.use, SoapParameterStyle.Bare, responseElementName + "OutHeaders", defaultNs, true, (XmlReflectionMember[]) outHeaders.ToArray(typeof(XmlReflectionMember)), false, true, methodId + ":OutHeaders", !client);
return soapMethod;
}
catch (Exception e) {
if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
throw;
}
throw new InvalidOperationException(Res.GetString(Res.WebReflectionErrorMethod, methodInfo.DeclaringType.Name, methodInfo.Name), e);
}
}
internal static string GetSoapMethodBinding(LogicalMethodInfo method) {
string binding;
object[] attrs = method.GetCustomAttributes(typeof(SoapDocumentMethodAttribute));
if (attrs.Length == 0) {
attrs = method.GetCustomAttributes(typeof(SoapRpcMethodAttribute));
if (attrs.Length == 0)
binding = string.Empty;
else
binding = ((SoapRpcMethodAttribute)attrs[0]).Binding;
}
else
binding = ((SoapDocumentMethodAttribute)attrs[0]).Binding;
if (method.Binding != null) {
if (binding.Length > 0 && binding != method.Binding.Name) {
throw new InvalidOperationException(Res.GetString(Res.WebInvalidBindingName, binding, method.Binding.Name));
}
return method.Binding.Name;
}
return binding;
}
internal static object GetSoapMethodAttribute(LogicalMethodInfo methodInfo) {
object[] rpcMethodAttributes = methodInfo.GetCustomAttributes(typeof(SoapRpcMethodAttribute));
object[] docMethodAttributes = methodInfo.GetCustomAttributes(typeof(SoapDocumentMethodAttribute));
if (rpcMethodAttributes.Length > 0) {
if (docMethodAttributes.Length > 0) throw new ArgumentException(Res.GetString(Res.WebBothMethodAttrs), "methodInfo");
return rpcMethodAttributes[0];
}
else if (docMethodAttributes.Length > 0)
return docMethodAttributes[0];
else
return null;
}
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);
}
}
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)
{
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);
}
