public SoapServerMethod(Type serverType, LogicalMethodInfo methodInfo)
{
this.methodInfo = methodInfo;
//
// Set up the XmlImporter, the SoapImporter, and acquire
// the ServiceAttribute on the serverType for use in
// creating a SoapReflectedMethod.
//
WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(serverType);
string serviceNamespace = serviceAttribute.Namespace;
bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(serverType);
SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded);
XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded);
//
// Add some types relating to the methodInfo into the two importers
//
SoapReflector.IncludeTypes(methodInfo, soapImporter);
WebMethodReflector.IncludeTypes(methodInfo, xmlImporter);
//
// Create a SoapReflectedMethod by reflecting on the
// LogicalMethodInfo passed to us.
//
SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, false, xmlImporter, soapImporter, serviceNamespace);
//
// Most of the fields in this class are ----ed in from the reflected information
//
ImportReflectedMethod(soapMethod);
ImportSerializers(soapMethod, GetServerTypeEvidence(serverType));
ImportHeaderSerializers(soapMethod);
}
private void ReflectInternal(ProtocolReflector[] reflectors)
{
this.description = new System.Web.Services.Description.ServiceDescription();
this.description.TargetNamespace = this.serviceAttr.Namespace;
this.ServiceDescriptions.Add(this.description);
this.service = new System.Web.Services.Description.Service();
string name = this.serviceAttr.Name;
if ((name == null) || (name.Length == 0))
{
name = this.serviceType.Name;
}
this.service.Name = XmlConvert.EncodeLocalName(name);
if ((this.serviceAttr.Description != null) && (this.serviceAttr.Description.Length > 0))
{
this.service.Documentation = this.serviceAttr.Description;
}
this.description.Services.Add(this.service);
this.reflectionContext = new Hashtable();
this.exporter = new XmlSchemaExporter(this.description.Types.Schemas);
this.importer = SoapReflector.CreateXmlImporter(this.serviceAttr.Namespace, SoapReflector.ServiceDefaultIsEncoded(this.serviceType));
WebMethodReflector.IncludeTypes(this.methods, this.importer);
for (int i = 0; i < reflectors.Length; i++)
{
reflectors[i].Reflect();
}
}
internal static void GenerateXmlMappings(Type type, ArrayList soapMethodList, string serviceNamespace, bool serviceDefaultIsEncoded, ArrayList mappings)
{
LogicalMethodInfo[] methodInfos = LogicalMethodInfo.Create(type.GetMethods(BindingFlags.Public | BindingFlags.Instance), LogicalMethodTypes.Sync);
SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded);
XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded);
WebMethodReflector.IncludeTypes(methodInfos, xmlImporter);
SoapReflector.IncludeTypes(methodInfos, soapImporter);
for (int i = 0; i < methodInfos.Length; i++)
{
LogicalMethodInfo methodInfo = methodInfos[i];
SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, true, xmlImporter, soapImporter, serviceNamespace);
if (soapMethod == null)
{
continue;
}
soapMethodList.Add(soapMethod);
mappings.Add(soapMethod.requestMappings);
if (soapMethod.responseMappings != null)
{
mappings.Add(soapMethod.responseMappings);
}
mappings.Add(soapMethod.inHeaderMappings);
if (soapMethod.outHeaderMappings != null)
{
mappings.Add(soapMethod.outHeaderMappings);
}
}
}
private void ReflectInternal(ProtocolReflector[] reflectors)
{
description = new ServiceDescription();
description.TargetNamespace = serviceAttr.Namespace;
ServiceDescriptions.Add(description);
service = new Service();
string name = serviceAttr.Name;
if (name == null || name.Length == 0)
{
name = serviceType.Name;
}
service.Name = XmlConvert.EncodeLocalName(name);
if (serviceAttr.Description != null && serviceAttr.Description.Length > 0)
{
service.Documentation = serviceAttr.Description;
}
description.Services.Add(service);
reflectionContext = new Hashtable();
exporter = new XmlSchemaExporter(description.Types.Schemas);
importer = SoapReflector.CreateXmlImporter(serviceAttr.Namespace, SoapReflector.ServiceDefaultIsEncoded(serviceType));
WebMethodReflector.IncludeTypes(methods, importer);
for (int i = 0; i < reflectors.Length; i++)
{
reflectors[i].Reflect();
}
}
protected override bool ReflectMethod()
{
soapMethod = ReflectionContext[Method] as SoapReflectedMethod;
if (soapMethod == null)
{
soapMethod = SoapReflector.ReflectMethod(Method, false, ReflectionImporter, SoapImporter, DefaultNamespace);
ReflectionContext[Method] = soapMethod;
soapMethod.portType = Binding != null ? Binding.Type : null;
}
WebMethodAttribute methodAttr = WebMethodReflector.GetAttribute(Method);
OperationBinding.Extensions.Add(CreateSoapOperationBinding(soapMethod.rpc ? SoapBindingStyle.Rpc : SoapBindingStyle.Document, soapMethod.action));
CreateMessage(soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, InputMessage, OperationBinding.Input, soapMethod.requestMappings);
if (!soapMethod.oneWay)
{
CreateMessage(soapMethod.rpc, soapMethod.use, soapMethod.paramStyle, OutputMessage, OperationBinding.Output, soapMethod.responseMappings);
}
CreateHeaderMessages(soapMethod.name, soapMethod.use, soapMethod.inHeaderMappings, soapMethod.outHeaderMappings, soapMethod.headers);
if (soapMethod.rpc && soapMethod.methodInfo.OutParameters.Length > 0)
{
Operation.ParameterOrder = GetParameterOrder(soapMethod.methodInfo);
}
AllowExtensionsToReflectMethod();
return(true);
}
/// <include file='doc\ServiceDescriptionReflector.uex' path='docs/doc[@for="ServiceDescriptionReflector.Reflect"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void Reflect(Type type, string url)
{
serviceType = type;
serviceUrl = url;
serviceAttr = WebServiceReflector.GetAttribute(type);
methods = WebMethodReflector.GetMethods(type);
CheckForDuplicateMethods(methods);
descriptionsWithPost = descriptions;
schemasWithPost = schemas;
if (reflectorsWithPost != null)
{
ReflectInternal(reflectorsWithPost);
descriptions = new ServiceDescriptionCollection();
schemas = new XmlSchemas();
}
ReflectInternal(reflectors);
if (serviceAttr.Description != null && serviceAttr.Description.Length > 0)
{
ServiceDescription.Documentation = serviceAttr.Description;
}
// need to preprocess all exported schemas to make sure that IXmlSerializable schemas are Merged and the resulting set is valid
ServiceDescription.Types.Schemas.Compile(null, false);
if (ServiceDescriptions.Count > 1)
{
// if defining interfaces, we move all schemas to the external collection
// since the types therein may be referenced from any of the sdls
Schemas.Add(ServiceDescription.Types.Schemas);
ServiceDescription.Types.Schemas.Clear();
}
else if (ServiceDescription.Types.Schemas.Count > 0)
{
XmlSchema[] descriptionSchemas = new XmlSchema[ServiceDescription.Types.Schemas.Count];
ServiceDescription.Types.Schemas.CopyTo(descriptionSchemas, 0);
foreach (XmlSchema schema in descriptionSchemas)
{
// we always move dataset schemas to the external schema's collection.
if (XmlSchemas.IsDataSet(schema))
{
ServiceDescription.Types.Schemas.Remove(schema);
Schemas.Add(schema);
}
}
}
}
static string GetDefaultAction(string defaultNs, LogicalMethodInfo methodInfo)
{
WebMethodAttribute methodAttribute = WebMethodReflector.GetAttribute(methodInfo);
string messageName = methodAttribute.MessageName;
if (messageName.Length == 0)
{
messageName = methodInfo.Name;
}
if (defaultNs.EndsWith("/"))
{
return(defaultNs + messageName);
}
return(defaultNs + "/" + messageName);
}
public SoapServerMethod(Type serverType, LogicalMethodInfo methodInfo)
{
this.methodInfo = methodInfo;
string defaultNs = WebServiceReflector.GetAttribute(serverType).Namespace;
bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(serverType);
SoapReflectionImporter importer = SoapReflector.CreateSoapImporter(defaultNs, serviceDefaultIsEncoded);
XmlReflectionImporter importer2 = SoapReflector.CreateXmlImporter(defaultNs, serviceDefaultIsEncoded);
SoapReflector.IncludeTypes(methodInfo, importer);
WebMethodReflector.IncludeTypes(methodInfo, importer2);
SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, false, importer2, importer, defaultNs);
this.ImportReflectedMethod(soapMethod);
this.ImportSerializers(soapMethod, this.GetServerTypeEvidence(serverType));
this.ImportHeaderSerializers(soapMethod);
}
void CheckForDuplicateMethods(LogicalMethodInfo[] methods)
{
Hashtable messageNames = new Hashtable();
foreach (LogicalMethodInfo method in methods)
{
WebMethodAttribute attribute = WebMethodReflector.GetAttribute(method);
string messageName = attribute.MessageName;
if (messageName.Length == 0)
{
messageName = method.Name;
}
LogicalMethodInfo existingMethod = (LogicalMethodInfo)messageNames[messageName];
if (existingMethod != null)
{
throw new InvalidOperationException(Res.GetString(Res.BothAndUseTheMessageNameUseTheMessageName3, method, existingMethod, messageName));
}
messageNames.Add(messageName, method);
}
}
public void Reflect(Type type, string url)
{
this.serviceType = type;
this.serviceUrl = url;
this.serviceAttr = WebServiceReflector.GetAttribute(type);
this.methods = WebMethodReflector.GetMethods(type);
this.CheckForDuplicateMethods(this.methods);
this.descriptionsWithPost = this.descriptions;
this.schemasWithPost = this.schemas;
if (this.reflectorsWithPost != null)
{
this.ReflectInternal(this.reflectorsWithPost);
this.descriptions = new ServiceDescriptionCollection();
this.schemas = new XmlSchemas();
}
this.ReflectInternal(this.reflectors);
if ((this.serviceAttr.Description != null) && (this.serviceAttr.Description.Length > 0))
{
this.ServiceDescription.Documentation = this.serviceAttr.Description;
}
this.ServiceDescription.Types.Schemas.Compile(null, false);
if (this.ServiceDescriptions.Count > 1)
{
this.Schemas.Add(this.ServiceDescription.Types.Schemas);
this.ServiceDescription.Types.Schemas.Clear();
}
else if (this.ServiceDescription.Types.Schemas.Count > 0)
{
XmlSchema[] array = new XmlSchema[this.ServiceDescription.Types.Schemas.Count];
this.ServiceDescription.Types.Schemas.CopyTo(array, 0);
foreach (XmlSchema schema in array)
{
if (XmlSchemas.IsDataSet(schema))
{
this.ServiceDescription.Types.Schemas.Remove(schema);
this.Schemas.Add(schema);
}
}
}
}
/// <include file='doc\ServiceDescriptionReflector.uex' path='docs/doc[@for="ServiceDescriptionReflector.Reflect"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public void Reflect(Type type, string url)
{
serviceType = type;
serviceUrl = url;
serviceAttr = WebServiceReflector.GetAttribute(type);
methods = WebMethodReflector.GetMethods(type);
CheckForDuplicateMethods(methods);
descriptionsWithPost = descriptions;
schemasWithPost = schemas;
if (reflectorsWithPost != null)
{
ReflectInternal(reflectorsWithPost);
descriptions = new ServiceDescriptionCollection();
schemas = new XmlSchemas();
}
ReflectInternal(reflectors);
XmlSchema[] descriptionSchemas = new XmlSchema[ServiceDescription.Types.Schemas.Count];
ServiceDescription.Types.Schemas.CopyTo(descriptionSchemas, 0);
// if defining interfaces, we move all schemas to the external collection
// since the types therein may be referenced from any of the sdls
bool externalizeSchemas = ServiceDescriptions.Count > 1;
foreach (XmlSchema schema in descriptionSchemas)
{
// we always move dataset schemas to the external schema's collection.
if (externalizeSchemas || XmlSchemas.IsDataSet(schema))
{
ServiceDescription.Types.Schemas.Remove(schema);
Schemas.Add(schema);
}
}
}
internal static object[] GetInitializers(LogicalMethodInfo[] methodInfos)
{
if (methodInfos.Length == 0)
{
return(new object[0]);
}
WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(methodInfos);
bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(WebServiceReflector.GetMostDerivedType(methodInfos));
XmlReflectionImporter importer = SoapReflector.CreateXmlImporter(serviceAttribute.Namespace, serviceDefaultIsEncoded);
WebMethodReflector.IncludeTypes(methodInfos, importer);
ArrayList mappings = new ArrayList();
for (int i = 0; i < methodInfos.Length; i++)
{
LogicalMethodInfo methodInfo = methodInfos[i];
Type type = methodInfo.ReturnType;
if (IsSupported(type))
{
XmlAttributes a = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
XmlTypeMapping mapping = importer.ImportTypeMapping(type, a.XmlRoot);
mappings.Add(mapping);
}
}
XmlSerializer[] serializers = XmlSerializer.FromMappings((XmlMapping[])mappings.ToArray(typeof(XmlMapping)));
object[] initializers = new object[methodInfos.Length];
int count = 0;
for (int i = 0; i < initializers.Length; i++)
{
if (IsSupported(methodInfos[i].ReturnType))
{
initializers[i] = serializers[count++];
}
}
return(initializers);
}
internal SoapServerType(Type type, ProtocolsEnum versionsSupported) : base(type)
{
this.versionsSupported = versionsSupported;
bool soap11 = (versionsSupported & ProtocolsEnum.HttpSoap) != 0;
bool soap12 = (versionsSupported & ProtocolsEnum.HttpSoap12) != 0;
LogicalMethodInfo[] methodInfos = WebMethodReflector.GetMethods(type);
ArrayList mappings = new ArrayList();
WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(type);
object soapServiceAttribute = SoapReflector.GetSoapServiceAttribute(type);
routingOnSoapAction = SoapReflector.GetSoapServiceRoutingStyle(soapServiceAttribute) == SoapServiceRoutingStyle.SoapAction;
serviceNamespace = serviceAttribute.Namespace;
serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded);
XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded);
SoapReflector.IncludeTypes(methodInfos, soapImporter);
WebMethodReflector.IncludeTypes(methodInfos, xmlImporter);
SoapReflectedMethod[] soapMethods = new SoapReflectedMethod[methodInfos.Length];
SoapExtensionType[] extensionTypes = WebServicesConfiguration.Current.SoapExtensionTypes;
ArrayList highPri = new ArrayList();
ArrayList lowPri = new ArrayList();
for (int i = 0; i < extensionTypes.Length; i++)
{
SoapReflectedExtension extension = new SoapReflectedExtension(extensionTypes[i].Type, null, extensionTypes[i].Priority);
if (extensionTypes[i].Group == SoapExtensionType.PriorityGroup.High)
{
highPri.Add(extension);
}
else
{
lowPri.Add(extension);
}
}
HighPriExtensions = (SoapReflectedExtension[])highPri.ToArray(typeof(SoapReflectedExtension));
LowPriExtensions = (SoapReflectedExtension[])lowPri.ToArray(typeof(SoapReflectedExtension));
Array.Sort(HighPriExtensions);
Array.Sort(LowPriExtensions);
HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, HighPriExtensions);
LowPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, LowPriExtensions);
for (int i = 0; i < methodInfos.Length; i++)
{
LogicalMethodInfo methodInfo = methodInfos[i];
SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, false, xmlImporter, soapImporter, serviceAttribute.Namespace);
mappings.Add(soapMethod.requestMappings);
if (soapMethod.responseMappings != null)
{
mappings.Add(soapMethod.responseMappings);
}
mappings.Add(soapMethod.inHeaderMappings);
if (soapMethod.outHeaderMappings != null)
{
mappings.Add(soapMethod.outHeaderMappings);
}
soapMethods[i] = soapMethod;
}
XmlSerializer[] serializers = XmlSerializer.FromMappings((XmlMapping[])mappings.ToArray(typeof(XmlMapping)));
int count = 0;
for (int i = 0; i < soapMethods.Length; i++)
{
SoapServerMethod serverMethod = new SoapServerMethod();
SoapReflectedMethod soapMethod = soapMethods[i];
serverMethod.parameterSerializer = serializers[count++];
if (soapMethod.responseMappings != null)
{
serverMethod.returnSerializer = serializers[count++];
}
serverMethod.inHeaderSerializer = serializers[count++];
if (soapMethod.outHeaderMappings != null)
{
serverMethod.outHeaderSerializer = serializers[count++];
}
serverMethod.methodInfo = soapMethod.methodInfo;
serverMethod.action = soapMethod.action;
serverMethod.extensions = soapMethod.extensions;
serverMethod.extensionInitializers = SoapReflectedExtension.GetInitializers(serverMethod.methodInfo, soapMethod.extensions);
serverMethod.oneWay = soapMethod.oneWay;
serverMethod.rpc = soapMethod.rpc;
serverMethod.use = soapMethod.use;
serverMethod.paramStyle = soapMethod.paramStyle;
ArrayList inHeaders = new ArrayList();
ArrayList outHeaders = new ArrayList();
for (int j = 0; j < soapMethod.headers.Length; j++)
{
SoapHeaderMapping mapping = new SoapHeaderMapping();
SoapReflectedHeader soapHeader = soapMethod.headers[j];
mapping.memberInfo = soapHeader.memberInfo;
mapping.repeats = soapHeader.repeats;
mapping.custom = soapHeader.custom;
mapping.direction = soapHeader.direction;
mapping.headerType = soapHeader.headerType;
if (mapping.direction == SoapHeaderDirection.In)
{
inHeaders.Add(mapping);
}
else if (mapping.direction == SoapHeaderDirection.Out)
{
outHeaders.Add(mapping);
}
else
{
inHeaders.Add(mapping);
outHeaders.Add(mapping);
}
}
serverMethod.inHeaderMappings = (SoapHeaderMapping[])inHeaders.ToArray(typeof(SoapHeaderMapping));
if (serverMethod.outHeaderSerializer != null)
{
serverMethod.outHeaderMappings = (SoapHeaderMapping[])outHeaders.ToArray(typeof(SoapHeaderMapping));
}
// check feasibility of routing on request element for soap 1.1
if (soap11 && !routingOnSoapAction && soapMethod.requestElementName.IsEmpty)
{
throw new SoapException(Res.GetString(Res.TheMethodDoesNotHaveARequestElementEither1, serverMethod.methodInfo.Name), new XmlQualifiedName(Soap.ClientCode, Soap.Namespace));
}
// we can lookup methods by action or request element
if (methods[soapMethod.action] == null)
{
methods[soapMethod.action] = serverMethod;
}
else
{
// duplicate soap actions not allowed in soap 1.1 if we're routing on soap action
if (soap11 && routingOnSoapAction)
{
SoapServerMethod duplicateMethod = (SoapServerMethod)methods[soapMethod.action];
throw new SoapException(Res.GetString(Res.TheMethodsAndUseTheSameSoapActionWhenTheService3, serverMethod.methodInfo.Name, duplicateMethod.methodInfo.Name, soapMethod.action), new XmlQualifiedName(Soap.ClientCode, Soap.Namespace));
}
duplicateMethods[soapMethod.action] = serverMethod;
}
if (methods[soapMethod.requestElementName] == null)
{
methods[soapMethod.requestElementName] = serverMethod;
}
else
{
// duplicate request elements not allowed in soap 1.1 if we're routing on request element
if (soap11 && !routingOnSoapAction)
{
SoapServerMethod duplicateMethod = (SoapServerMethod)methods[soapMethod.requestElementName];
throw new SoapException(Res.GetString(Res.TheMethodsAndUseTheSameRequestElementXmlns4, serverMethod.methodInfo.Name, duplicateMethod.methodInfo.Name, soapMethod.requestElementName.Name, soapMethod.requestElementName.Namespace), new XmlQualifiedName(Soap.ClientCode, Soap.Namespace));
}
duplicateMethods[soapMethod.requestElementName] = serverMethod;
}
}
}
internal HttpServerType(Type type) : base(type)
{
this.methods = new Hashtable();
WebServicesSection current = WebServicesSection.Current;
Type[] returnWriterTypes = current.ReturnWriterTypes;
Type[] parameterReaderTypes = current.ParameterReaderTypes;
LogicalMethodInfo[] methods = WebMethodReflector.GetMethods(type);
HttpServerMethod[] methodArray = new HttpServerMethod[methods.Length];
object[] objArray = new object[returnWriterTypes.Length];
for (int i = 0; i < objArray.Length; i++)
{
objArray[i] = MimeFormatter.GetInitializers(returnWriterTypes[i], methods);
}
for (int j = 0; j < methods.Length; j++)
{
LogicalMethodInfo info = methods[j];
HttpServerMethod method = null;
if (info.ReturnType == typeof(void))
{
method = new HttpServerMethod();
}
else
{
for (int num3 = 0; num3 < returnWriterTypes.Length; num3++)
{
object[] objArray2 = (object[])objArray[num3];
if (objArray2[j] != null)
{
method = new HttpServerMethod {
writerInitializer = objArray2[j],
writerType = returnWriterTypes[num3]
};
break;
}
}
}
if (method != null)
{
method.methodInfo = info;
methodArray[j] = method;
}
}
objArray = new object[parameterReaderTypes.Length];
for (int k = 0; k < objArray.Length; k++)
{
objArray[k] = MimeFormatter.GetInitializers(parameterReaderTypes[k], methods);
}
for (int m = 0; m < methods.Length; m++)
{
HttpServerMethod method2 = methodArray[m];
if (method2 != null)
{
LogicalMethodInfo info2 = methods[m];
if (info2.InParameters.Length > 0)
{
int index = 0;
for (int num7 = 0; num7 < parameterReaderTypes.Length; num7++)
{
object[] objArray3 = (object[])objArray[num7];
if (objArray3[m] != null)
{
index++;
}
}
if (index == 0)
{
methodArray[m] = null;
}
else
{
method2.readerTypes = new Type[index];
method2.readerInitializers = new object[index];
index = 0;
for (int num8 = 0; num8 < parameterReaderTypes.Length; num8++)
{
object[] objArray4 = (object[])objArray[num8];
if (objArray4[m] != null)
{
method2.readerTypes[index] = parameterReaderTypes[num8];
method2.readerInitializers[index] = objArray4[m];
index++;
}
}
}
}
}
}
for (int n = 0; n < methodArray.Length; n++)
{
HttpServerMethod method3 = methodArray[n];
if (method3 != null)
{
WebMethodAttribute methodAttribute = method3.methodInfo.MethodAttribute;
method3.name = methodAttribute.MessageName;
if (method3.name.Length == 0)
{
method3.name = method3.methodInfo.Name;
}
this.methods.Add(method3.name, method3);
}
}
}
internal static object[] GetInitializers(LogicalMethodInfo[] methodInfos)
{
if (methodInfos.Length == 0)
{
return(new object[0]);
}
WebServiceAttribute attribute = WebServiceReflector.GetAttribute(methodInfos);
bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(WebServiceReflector.GetMostDerivedType(methodInfos));
XmlReflectionImporter importer = SoapReflector.CreateXmlImporter(attribute.Namespace, serviceDefaultIsEncoded);
WebMethodReflector.IncludeTypes(methodInfos, importer);
ArrayList list = new ArrayList();
bool[] flagArray = new bool[methodInfos.Length];
for (int i = 0; i < methodInfos.Length; i++)
{
LogicalMethodInfo methodInfo = methodInfos[i];
Type returnType = methodInfo.ReturnType;
if (IsSupported(returnType) && HttpServerProtocol.AreUrlParametersSupported(methodInfo))
{
XmlAttributes attributes = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
XmlTypeMapping mapping = importer.ImportTypeMapping(returnType, attributes.XmlRoot);
mapping.SetKey(methodInfo.GetKey() + ":Return");
list.Add(mapping);
flagArray[i] = true;
}
}
if (list.Count == 0)
{
return(new object[0]);
}
XmlMapping[] mappings = (XmlMapping[])list.ToArray(typeof(XmlMapping));
Evidence evidenceForType = GetEvidenceForType(methodInfos[0].DeclaringType);
TraceMethod caller = Tracing.On ? new TraceMethod(typeof(XmlReturn), "GetInitializers", methodInfos) : null;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId("TraceCreateSerializer"), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", new object[] { mappings, evidenceForType }));
}
XmlSerializer[] serializerArray = null;
if (AppDomain.CurrentDomain.IsHomogenous)
{
serializerArray = XmlSerializer.FromMappings(mappings);
}
else
{
serializerArray = XmlSerializer.FromMappings(mappings, evidenceForType);
}
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId("TraceCreateSerializer"), caller);
}
object[] objArray = new object[methodInfos.Length];
int num2 = 0;
for (int j = 0; j < objArray.Length; j++)
{
if (flagArray[j])
{
objArray[j] = serializerArray[num2++];
}
}
return(objArray);
}
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);
}
}
public SoapServerType(Type type, WebServiceProtocols protocolsSupported) : base(type)
{
this.methods = new Hashtable();
this.duplicateMethods = new Hashtable();
this.protocolsSupported = protocolsSupported;
bool flag = (protocolsSupported & WebServiceProtocols.HttpSoap) != WebServiceProtocols.Unknown;
LogicalMethodInfo[] methods = WebMethodReflector.GetMethods(type);
ArrayList list = new ArrayList();
WebServiceAttribute attribute = WebServiceReflector.GetAttribute(type);
object soapServiceAttribute = SoapReflector.GetSoapServiceAttribute(type);
this.routingOnSoapAction = SoapReflector.GetSoapServiceRoutingStyle(soapServiceAttribute) == SoapServiceRoutingStyle.SoapAction;
this.serviceNamespace = attribute.Namespace;
this.serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
SoapReflectionImporter importer = SoapReflector.CreateSoapImporter(this.serviceNamespace, this.serviceDefaultIsEncoded);
XmlReflectionImporter importer2 = SoapReflector.CreateXmlImporter(this.serviceNamespace, this.serviceDefaultIsEncoded);
SoapReflector.IncludeTypes(methods, importer);
WebMethodReflector.IncludeTypes(methods, importer2);
SoapReflectedMethod[] methodArray = new SoapReflectedMethod[methods.Length];
SoapExtensionTypeElementCollection soapExtensionTypes = WebServicesSection.Current.SoapExtensionTypes;
ArrayList list2 = new ArrayList();
ArrayList list3 = new ArrayList();
for (int i = 0; i < soapExtensionTypes.Count; i++)
{
SoapExtensionTypeElement element = soapExtensionTypes[i];
if (element != null)
{
SoapReflectedExtension extension = new SoapReflectedExtension(element.Type, null, element.Priority);
if (element.Group == PriorityGroup.High)
{
list2.Add(extension);
}
else
{
list3.Add(extension);
}
}
}
this.HighPriExtensions = (SoapReflectedExtension[])list2.ToArray(typeof(SoapReflectedExtension));
this.LowPriExtensions = (SoapReflectedExtension[])list3.ToArray(typeof(SoapReflectedExtension));
Array.Sort <SoapReflectedExtension>(this.HighPriExtensions);
Array.Sort <SoapReflectedExtension>(this.LowPriExtensions);
this.HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, this.HighPriExtensions);
this.LowPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, this.LowPriExtensions);
for (int j = 0; j < methods.Length; j++)
{
LogicalMethodInfo methodInfo = methods[j];
SoapReflectedMethod method = SoapReflector.ReflectMethod(methodInfo, false, importer2, importer, attribute.Namespace);
list.Add(method.requestMappings);
if (method.responseMappings != null)
{
list.Add(method.responseMappings);
}
list.Add(method.inHeaderMappings);
if (method.outHeaderMappings != null)
{
list.Add(method.outHeaderMappings);
}
methodArray[j] = method;
}
XmlMapping[] mappings = (XmlMapping[])list.ToArray(typeof(XmlMapping));
TraceMethod caller = Tracing.On ? new TraceMethod(this, ".ctor", new object[] { type, protocolsSupported }) : null;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId("TraceCreateSerializer"), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", new object[] { mappings, base.Evidence }));
}
XmlSerializer[] serializerArray = null;
if (AppDomain.CurrentDomain.IsHomogenous)
{
serializerArray = XmlSerializer.FromMappings(mappings);
}
else
{
serializerArray = XmlSerializer.FromMappings(mappings, base.Evidence);
}
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId("TraceCreateSerializer"), caller);
}
int num3 = 0;
for (int k = 0; k < methodArray.Length; k++)
{
SoapServerMethod method3 = new SoapServerMethod();
SoapReflectedMethod method4 = methodArray[k];
method3.parameterSerializer = serializerArray[num3++];
if (method4.responseMappings != null)
{
method3.returnSerializer = serializerArray[num3++];
}
method3.inHeaderSerializer = serializerArray[num3++];
if (method4.outHeaderMappings != null)
{
method3.outHeaderSerializer = serializerArray[num3++];
}
method3.methodInfo = method4.methodInfo;
method3.action = method4.action;
method3.extensions = method4.extensions;
method3.extensionInitializers = SoapReflectedExtension.GetInitializers(method3.methodInfo, method4.extensions);
method3.oneWay = method4.oneWay;
method3.rpc = method4.rpc;
method3.use = method4.use;
method3.paramStyle = method4.paramStyle;
method3.wsiClaims = (method4.binding == null) ? WsiProfiles.None : method4.binding.ConformsTo;
ArrayList list4 = new ArrayList();
ArrayList list5 = new ArrayList();
for (int m = 0; m < method4.headers.Length; m++)
{
SoapHeaderMapping mapping = new SoapHeaderMapping();
SoapReflectedHeader header = method4.headers[m];
mapping.memberInfo = header.memberInfo;
mapping.repeats = header.repeats;
mapping.custom = header.custom;
mapping.direction = header.direction;
mapping.headerType = header.headerType;
if (mapping.direction == SoapHeaderDirection.In)
{
list4.Add(mapping);
}
else if (mapping.direction == SoapHeaderDirection.Out)
{
list5.Add(mapping);
}
else
{
list4.Add(mapping);
list5.Add(mapping);
}
}
method3.inHeaderMappings = (SoapHeaderMapping[])list4.ToArray(typeof(SoapHeaderMapping));
if (method3.outHeaderSerializer != null)
{
method3.outHeaderMappings = (SoapHeaderMapping[])list5.ToArray(typeof(SoapHeaderMapping));
}
if ((flag && !this.routingOnSoapAction) && method4.requestElementName.IsEmpty)
{
throw new SoapException(System.Web.Services.Res.GetString("TheMethodDoesNotHaveARequestElementEither1", new object[] { method3.methodInfo.Name }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/"));
}
if (this.methods[method4.action] == null)
{
this.methods[method4.action] = method3;
}
else
{
if (flag && this.routingOnSoapAction)
{
SoapServerMethod method5 = (SoapServerMethod)this.methods[method4.action];
throw new SoapException(System.Web.Services.Res.GetString("TheMethodsAndUseTheSameSoapActionWhenTheService3", new object[] { method3.methodInfo.Name, method5.methodInfo.Name, method4.action }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/"));
}
this.duplicateMethods[method4.action] = method3;
}
if (this.methods[method4.requestElementName] == null)
{
this.methods[method4.requestElementName] = method3;
}
else
{
if (flag && !this.routingOnSoapAction)
{
SoapServerMethod method6 = (SoapServerMethod)this.methods[method4.requestElementName];
throw new SoapException(System.Web.Services.Res.GetString("TheMethodsAndUseTheSameRequestElementXmlns4", new object[] { method3.methodInfo.Name, method6.methodInfo.Name, method4.requestElementName.Name, method4.requestElementName.Namespace }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/"));
}
this.duplicateMethods[method4.requestElementName] = method3;
}
}
}
internal HttpServerType(Type type) : base(type)
{
WebServicesSection config = WebServicesSection.Current;
Type[] returnWriterTypes = config.ReturnWriterTypes;
Type[] parameterReaderTypes = config.ParameterReaderTypes;
LogicalMethodInfo[] methodInfos = WebMethodReflector.GetMethods(type);
HttpServerMethod[] methods = new HttpServerMethod[methodInfos.Length];
object[] initializersByType = new object[returnWriterTypes.Length];
for (int i = 0; i < initializersByType.Length; i++)
{
initializersByType[i] = MimeFormatter.GetInitializers(returnWriterTypes[i], methodInfos);
}
for (int i = 0; i < methodInfos.Length; i++)
{
LogicalMethodInfo methodInfo = methodInfos[i];
HttpServerMethod method = null;
if (methodInfo.ReturnType == typeof(void))
{
method = new HttpServerMethod();
}
else
{
for (int j = 0; j < returnWriterTypes.Length; j++)
{
object[] initializers = (object[])initializersByType[j];
if (initializers[i] != null)
{
method = new HttpServerMethod();
method.writerInitializer = initializers[i];
method.writerType = returnWriterTypes[j];
break;
}
}
}
if (method != null)
{
method.methodInfo = methodInfo;
methods[i] = method;
}
}
initializersByType = new object[parameterReaderTypes.Length];
for (int i = 0; i < initializersByType.Length; i++)
{
initializersByType[i] = MimeFormatter.GetInitializers(parameterReaderTypes[i], methodInfos);
}
for (int i = 0; i < methodInfos.Length; i++)
{
HttpServerMethod method = methods[i];
if (method == null)
{
continue;
}
LogicalMethodInfo methodInfo = methodInfos[i];
if (methodInfo.InParameters.Length > 0)
{
int count = 0;
for (int j = 0; j < parameterReaderTypes.Length; j++)
{
object[] initializers = (object[])initializersByType[j];
if (initializers[i] != null)
{
count++;
}
}
if (count == 0)
{
methods[i] = null;
}
else
{
method.readerTypes = new Type[count];
method.readerInitializers = new object[count];
count = 0;
for (int j = 0; j < parameterReaderTypes.Length; j++)
{
object[] initializers = (object[])initializersByType[j];
if (initializers[i] != null)
{
method.readerTypes[count] = parameterReaderTypes[j];
method.readerInitializers[count] = initializers[i];
count++;
}
}
}
}
}
for (int i = 0; i < methods.Length; i++)
{
HttpServerMethod method = methods[i];
if (method != null)
{
WebMethodAttribute methodAttribute = method.methodInfo.MethodAttribute;
method.name = methodAttribute.MessageName;
if (method.name.Length == 0)
{
method.name = method.methodInfo.Name;
}
this.methods.Add(method.name, method);
}
}
}
internal static object[] GetInitializers(LogicalMethodInfo[] methodInfos)
{
if (methodInfos.Length == 0)
{
return(new object[0]);
}
WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(methodInfos);
bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(WebServiceReflector.GetMostDerivedType(methodInfos));
XmlReflectionImporter importer = SoapReflector.CreateXmlImporter(serviceAttribute.Namespace, serviceDefaultIsEncoded);
WebMethodReflector.IncludeTypes(methodInfos, importer);
ArrayList mappings = new ArrayList();
bool[] supported = new bool[methodInfos.Length];
for (int i = 0; i < methodInfos.Length; i++)
{
LogicalMethodInfo methodInfo = methodInfos[i];
Type type = methodInfo.ReturnType;
if (IsSupported(type) && HttpServerProtocol.AreUrlParametersSupported(methodInfo))
{
XmlAttributes a = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider);
XmlTypeMapping mapping = importer.ImportTypeMapping(type, a.XmlRoot);
mapping.SetKey(methodInfo.GetKey() + ":Return");
mappings.Add(mapping);
supported[i] = true;
}
}
if (mappings.Count == 0)
{
return(new object[0]);
}
XmlMapping[] xmlMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping));
Evidence evidence = GetEvidenceForType(methodInfos[0].DeclaringType);
TraceMethod caller = Tracing.On ? new TraceMethod(typeof(XmlReturn), "GetInitializers", methodInfos) : null;
if (Tracing.On)
{
Tracing.Enter(Tracing.TraceId(Res.TraceCreateSerializer), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", xmlMappings, evidence));
}
XmlSerializer[] serializers = null;
if (AppDomain.CurrentDomain.IsHomogenous)
{
serializers = XmlSerializer.FromMappings(xmlMappings);
}
else
{
#pragma warning disable 618 // If we're in a non-homogenous domain, legacy CAS mode is enabled, so passing through evidence will not fail
serializers = XmlSerializer.FromMappings(xmlMappings, evidence);
#pragma warning restore 618
}
if (Tracing.On)
{
Tracing.Exit(Tracing.TraceId(Res.TraceCreateSerializer), caller);
}
object[] initializers = new object[methodInfos.Length];
int count = 0;
for (int i = 0; i < initializers.Length; i++)
{
if (supported[i])
{
initializers[i] = serializers[count++];
}
}
return(initializers);
}
internal SoapClientType(Type type)
{
LogicalMethodInfo[] methodInfos = LogicalMethodInfo.Create(type.GetMethods(BindingFlags.Public | BindingFlags.Instance), LogicalMethodTypes.Sync);
ArrayList mappings = new ArrayList();
ArrayList soapMethodList = new ArrayList();
this.binding = WebServiceBindingReflector.GetAttribute(type);
if (this.binding == null)
{
throw new InvalidOperationException(Res.GetString(Res.WebClientBindingAttributeRequired));
}
// Note: Service namespace is taken from WebserviceBindingAttribute and not WebserviceAttribute because
// the generated proxy does not have a WebServiceAttribute; however all have a WebServiceBindingAttribute.
serviceNamespace = binding.Namespace;
serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
SoapReflectionImporter soapImporter = SoapReflector.CreateSoapImporter(serviceNamespace, serviceDefaultIsEncoded);
XmlReflectionImporter xmlImporter = SoapReflector.CreateXmlImporter(serviceNamespace, serviceDefaultIsEncoded);
WebMethodReflector.IncludeTypes(methodInfos, xmlImporter);
SoapReflector.IncludeTypes(methodInfos, soapImporter);
SoapExtensionType[] extensionTypes = WebServicesConfiguration.Current.SoapExtensionTypes;
ArrayList highPri = new ArrayList();
ArrayList lowPri = new ArrayList();
for (int i = 0; i < extensionTypes.Length; i++)
{
SoapReflectedExtension extension = new SoapReflectedExtension(extensionTypes[i].Type, null, extensionTypes[i].Priority);
if (extensionTypes[i].Group == SoapExtensionType.PriorityGroup.High)
{
highPri.Add(extension);
}
else
{
lowPri.Add(extension);
}
}
HighPriExtensions = (SoapReflectedExtension[])highPri.ToArray(typeof(SoapReflectedExtension));
LowPriExtensions = (SoapReflectedExtension[])lowPri.ToArray(typeof(SoapReflectedExtension));
Array.Sort(HighPriExtensions);
Array.Sort(LowPriExtensions);
HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, HighPriExtensions);
LowPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, LowPriExtensions);
for (int i = 0; i < methodInfos.Length; i++)
{
LogicalMethodInfo methodInfo = methodInfos[i];
SoapReflectedMethod soapMethod = SoapReflector.ReflectMethod(methodInfo, true, xmlImporter, soapImporter, serviceNamespace);
if (soapMethod == null)
{
continue;
}
soapMethodList.Add(soapMethod);
mappings.Add(soapMethod.requestMappings);
if (soapMethod.responseMappings != null)
{
mappings.Add(soapMethod.responseMappings);
}
mappings.Add(soapMethod.inHeaderMappings);
if (soapMethod.outHeaderMappings != null)
{
mappings.Add(soapMethod.outHeaderMappings);
}
}
XmlSerializer[] serializers = XmlSerializer.FromMappings((XmlMapping[])mappings.ToArray(typeof(XmlMapping)));
int count = 0;
for (int i = 0; i < soapMethodList.Count; i++)
{
SoapReflectedMethod soapMethod = (SoapReflectedMethod)soapMethodList[i];
SoapClientMethod clientMethod = new SoapClientMethod();
clientMethod.parameterSerializer = serializers[count++];
if (soapMethod.responseMappings != null)
{
clientMethod.returnSerializer = serializers[count++];
}
clientMethod.inHeaderSerializer = serializers[count++];
if (soapMethod.outHeaderMappings != null)
{
clientMethod.outHeaderSerializer = serializers[count++];
}
clientMethod.action = soapMethod.action;
clientMethod.oneWay = soapMethod.oneWay;
clientMethod.rpc = soapMethod.rpc;
clientMethod.use = soapMethod.use;
clientMethod.paramStyle = soapMethod.paramStyle;
clientMethod.methodInfo = soapMethod.methodInfo;
clientMethod.extensions = soapMethod.extensions;
clientMethod.extensionInitializers = SoapReflectedExtension.GetInitializers(clientMethod.methodInfo, soapMethod.extensions);
ArrayList inHeaders = new ArrayList();
ArrayList outHeaders = new ArrayList();
for (int j = 0; j < soapMethod.headers.Length; j++)
{
SoapHeaderMapping mapping = new SoapHeaderMapping();
SoapReflectedHeader soapHeader = soapMethod.headers[j];
mapping.memberInfo = soapHeader.memberInfo;
mapping.repeats = soapHeader.repeats;
mapping.custom = soapHeader.custom;
mapping.direction = soapHeader.direction;
mapping.headerType = soapHeader.headerType;
if ((mapping.direction & SoapHeaderDirection.In) != 0)
{
inHeaders.Add(mapping);
}
if ((mapping.direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
{
outHeaders.Add(mapping);
}
}
clientMethod.inHeaderMappings = (SoapHeaderMapping[])inHeaders.ToArray(typeof(SoapHeaderMapping));
if (clientMethod.outHeaderSerializer != null)
{
clientMethod.outHeaderMappings = (SoapHeaderMapping[])outHeaders.ToArray(typeof(SoapHeaderMapping));
}
methods.Add(soapMethod.name, clientMethod);
}
}
void MoveToMethod(LogicalMethodInfo method)
{
this.method = method;
this.methodAttr = WebMethodReflector.GetAttribute(method);
}
