public string GetMethodName(Type type)
{
if (MethodNames.TryGetValue(type, out var method))
{
return(method);
}
// Custom method
var attribute = MethodAttribute.From(type);
var handler = KnownHandlers.SelectMany(z => z)
.FirstOrDefault(z => z.InterfaceType == type || z.HandlerType == type || z.ParamsType == type);
if (handler != null)
{
return(handler.Method);
}
// TODO: Log unknown method name
if (attribute is null)
{
return(null);
}
MethodNames.TryAdd(type, attribute.Method);
return(attribute.Method);
}
public TypeHandlerExtensionData()
{
var handlerTypeDescriptorProvider = new HandlerTypeDescriptorProvider(
new[] {
typeof(HandlerTypeDescriptorProvider).Assembly,
typeof(DebugAdapterRpcOptionsBase <>).Assembly,
typeof(DebugAdapterClient).Assembly,
typeof(DebugAdapterServer).Assembly,
typeof(DapReceiver).Assembly,
typeof(DebugAdapterProtocolTestBase).Assembly
}
);
foreach (var type in typeof(CompletionsArguments).Assembly.ExportedTypes
.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z)))
{
if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
{
continue;
}
if (type == typeof(IProgressStartHandler) || type == typeof(IProgressUpdateHandler) || type == typeof(IProgressEndHandler))
{
continue;
}
var descriptor = handlerTypeDescriptorProvider.GetHandlerTypeDescriptor(type) !;
Add(
descriptor,
GetOnMethodName(descriptor),
GetSendMethodName(descriptor),
GetExtensionClass(descriptor),
GetExtensionClassName(descriptor).Substring(GetExtensionClassName(descriptor).LastIndexOf('.') + 1)
);
}
}
public void Decorate <T>(T instance)
{
PropertyInfo[] properties = instance.GetType().GetProperties();
foreach (PropertyInfo property in properties)
{
Object[] attributes = (Object[])property.GetCustomAttributes(typeof(Attribute), true);
foreach (Object obj in attributes)
{
PropertyAttribute propertyAttribute = _instantiator.GetInstanceByType <PropertyAttribute>(obj.GetType(), new Object[0]);
propertyAttribute.Decorator = this;
propertyAttribute.DecorateProperty(instance, property);
}
}
MethodInfo[] methods = instance.GetType().GetMethods();
foreach (MethodInfo method in methods)
{
Object[] attributes = (Object[])method.GetCustomAttributes(typeof(MethodAttribute), true);
for (int j = attributes.Length - 1; j >= 0; j--)
{
Object obj = attributes[j];
MethodAttribute methodAttribute = _instantiator.GetInstanceByType <MethodAttribute>(obj.GetType(), new Object[0]);
methodAttribute.Decorator = this;
methodAttribute.DecorateMethod(instance, method);
}
}
}
public TypeHandlerData()
{
var handlerTypeDescriptorProvider = new HandlerTypeDescriptorProvider(
new[] {
typeof(HandlerTypeDescriptorProvider).Assembly,
typeof(DebugAdapterRpcOptionsBase <>).Assembly,
typeof(DebugAdapterClient).Assembly,
typeof(DebugAdapterServer).Assembly,
typeof(DapReceiver).Assembly,
typeof(DebugAdapterProtocolTestBase).Assembly
}
);
foreach (var type in typeof(CompletionsArguments).Assembly.ExportedTypes.Where(
z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z)
))
{
if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
{
continue;
}
if (type == typeof(IProgressStartHandler) || type == typeof(IProgressUpdateHandler) || type == typeof(IProgressEndHandler))
{
continue;
}
Add(handlerTypeDescriptorProvider.GetHandlerTypeDescriptor(type) !);
}
}
public TypeHandlerData()
{
var handlerTypeDescriptorProvider =
new LspHandlerTypeDescriptorProvider(
new[]
{
typeof(AssemblyScanningHandlerTypeDescriptorProvider).Assembly,
typeof(LspHandlerTypeDescriptorProvider).Assembly,
typeof(LanguageServer).Assembly,
typeof(LanguageClient).Assembly,
typeof(ISupports).Assembly,
typeof(HandlerResolverTests).Assembly
}
);
foreach (var type in typeof(CompletionParams).Assembly.ExportedTypes.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z))
.Where(z => !z.Name.EndsWith("Manager"))
.Except(new[] { typeof(ITextDocumentSyncHandler), typeof(IExecuteCommandHandler <>) })
)
{
if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
{
continue;
}
Add(handlerTypeDescriptorProvider.GetHandlerTypeDescriptor(type) !);
}
}
public TypeHandlerExtensionData()
{
var handlerTypeDescriptorProvider =
new LspHandlerTypeDescriptorProvider(
new[]
{
typeof(AssemblyScanningHandlerTypeDescriptorProvider).Assembly,
typeof(LspHandlerTypeDescriptorProvider).Assembly,
typeof(LanguageServer).Assembly,
typeof(LanguageClient).Assembly,
typeof(ISupports).Assembly,
typeof(HandlerResolverTests).Assembly
}
);
foreach (var type in typeof(CompletionParams).Assembly.ExportedTypes
.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z))
.Where(z => !z.Name.EndsWith("Manager"))
.Except(new[] { typeof(ITextDocumentSyncHandler) })
)
{
if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
{
continue;
}
if (type.Name.EndsWith("Manager"))
{
continue;
}
if (type == typeof(IExecuteCommandHandler <>))
{
continue;
}
if (type == typeof(ICompletionResolveHandler) || type == typeof(ICodeLensResolveHandler) || type == typeof(IDocumentLinkResolveHandler) ||
type == typeof(ICodeActionResolveHandler))
{
continue;
}
if (type == typeof(ISemanticTokensFullHandler) || type == typeof(ISemanticTokensDeltaHandler) ||
type == typeof(ISemanticTokensRangeHandler))
{
continue;
}
var descriptor = handlerTypeDescriptorProvider.GetHandlerTypeDescriptor(type);
if (descriptor == null)
{
throw new Exception("");
}
Add(
descriptor,
GetOnMethodName(descriptor),
GetSendMethodName(descriptor),
GetExtensionClass(descriptor),
GetExtensionClassName(descriptor).Substring(GetExtensionClassName(descriptor).LastIndexOf('.') + 1)
);
}
}
/// <summary>
/// 添加Service
/// </summary>
/// <param name="type"></param>
public static void AddService(Type type)
{
MethodAttribute attr = (MethodAttribute)type.GetCustomAttribute(typeof(MethodAttribute));
if (attr != null && typeof(ITigerMethod).IsAssignableFrom(type))
{
Global.Service.Add(attr.Name, type);
}
}
public void HandlersShouldMatchParamsMethodAttribute(Type type)
{
var paramsType = HandlerTypeDescriptorHelper.GetHandlerInterface(type).GetGenericArguments()[0];
var lhs = MethodAttribute.From(type) !;
var rhs = MethodAttribute.From(paramsType) !;
lhs.Method.Should().Be(rhs.Method, $"{type.FullName} method does not match {paramsType.FullName}");
lhs.Direction.Should().Be(rhs.Direction, $"{type.FullName} direction does not match {paramsType.FullName}");
}
public HandlersShouldAbstractClassData()
{
foreach (var type in typeof(IDataBreakpointInfoHandler).Assembly.ExportedTypes
.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z)))
{
if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
{
continue;
}
Add(type);
}
}
public void ShouldDecorateMethodsOnInstantiatedObjects()
{
inst.obj = new MockMethod();
MockObject2 obj = new MockObject2();
decorator.Decorate(obj);
MethodAttribute pa = obj.AttributeMethod;
Assert.IsNotNull(((MockMethod)pa).Obj);
Assert.IsNotNull(((MockMethod)pa).MethodInformation);
Assert.AreEqual("DecoratedMethod", ((MockMethod)pa).MethodInformation.Name);
}
public HandlersShouldHaveMethodAttributeData()
{
foreach (var type in typeof(CompletionParams).Assembly.ExportedTypes.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z))
.Where(z => !z.Name.EndsWith("Manager"))
.Except(new[] { typeof(ITextDocumentSyncHandler) })
)
{
if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
{
continue;
}
Add(type);
}
}
public TypeHandlerData()
{
foreach (var type in typeof(CompletionsArguments).Assembly.ExportedTypes.Where(
z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z)
))
{
if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
{
continue;
}
if (type == typeof(IProgressStartHandler) || type == typeof(IProgressUpdateHandler) || type == typeof(IProgressEndHandler))
{
continue;
}
Add(HandlerTypeDescriptorHelper.GetHandlerTypeDescriptor(type));
}
}
public static void RemoveService(string itemFullPath)
{
FileInfo fileInfo = new FileInfo(itemFullPath);
if (Global.PackageItem.ContainsKey(fileInfo.DirectoryName))
{
PackageItem packageItem = Global.PackageItem[itemFullPath];
foreach (Type type in packageItem.Assembly.GetExportedTypes())
{
MethodAttribute attr = (MethodAttribute)type.GetCustomAttribute(typeof(MethodAttribute));
if (attr != null && typeof(ITigerMethod).IsAssignableFrom(type))
{
if (Global.Service.ContainsKey(attr.Name))
{
Global.Service.Remove(attr.Name);
}
}
}
Global.PackageItem.Remove(fileInfo.DirectoryName);
}
}
public static void RemoveService(string filePath)
{
string[] keys = Global.PackageItem.Keys.ToArray();
for (int i = 0; i < keys.Length; i++)
{
PackageItem packageItem = Global.PackageItem[keys[i]];
if (packageItem.FileFullPath.Equals(filePath))
{
foreach (Type type in packageItem.Assembly.GetExportedTypes())
{
MethodAttribute attr = (MethodAttribute)type.GetCustomAttribute(typeof(MethodAttribute));
if (attr != null && typeof(ITigerMethod).IsAssignableFrom(type))
{
Global.Service.Remove(attr.Name);
}
}
Global.PackageItem.Remove(packageItem.AssemblyName);
break;
}
}
}
public TypeHandlerExtensionData()
{
foreach (var type in typeof(CompletionsArguments).Assembly.ExportedTypes
.Where(z => z.IsInterface && typeof(IJsonRpcHandler).IsAssignableFrom(z)))
{
if (type.IsGenericTypeDefinition && !MethodAttribute.AllFrom(type).Any())
{
continue;
}
if (type == typeof(IProgressStartHandler) || type == typeof(IProgressUpdateHandler) || type == typeof(IProgressEndHandler))
{
continue;
}
var descriptor = HandlerTypeDescriptorHelper.GetHandlerTypeDescriptor(type);
Add(
descriptor,
GetOnMethodName(descriptor),
GetSendMethodName(descriptor),
GetExtensionClass(descriptor),
GetExtensionClassName(descriptor).Substring(GetExtensionClassName(descriptor).LastIndexOf('.') + 1)
);
}
}
static async Task AcceptInfo(HttpContext hc, Func <Task> n)
{
List <PackageInfo> packageInfos = new List <PackageInfo>();
foreach (var item in Global.PackageItem)
{
PackageInfo packageInfo = new PackageInfo
{
Item = item.Value
};
foreach (Type type in item.Value.Assembly.GetExportedTypes())
{
MethodAttribute attr = (MethodAttribute)type.GetCustomAttribute(typeof(MethodAttribute));
if (attr != null && typeof(ITigerMethod).IsAssignableFrom(type))
{
packageInfo.Service.Add(attr);
}
}
packageInfos.Add(packageInfo);
}
hc.Response.ContentType = CommonConstant.CONTENT_TYPE;
await hc.Response.WriteAsync(JsonConvert.SerializeObject(packageInfos), Encoding.UTF8);
}
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 void HandlersShouldHaveMethodAttribute(Type type)
{
MethodAttribute.AllFrom(type).Any(z => z.Direction != Direction.Unspecified).Should()
.Be(true, $"{type.Name} is missing a method attribute or the direction is not specified");
}
public void SetUp()
{
_attribute = new MethodAttribute(HttpMethod.Get, HttpMethod.Post);
_route = new Route.Routing.Route("name", Guid.NewGuid(), "relative");
_container = MockRepository.GenerateMock <IContainer>();
}
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 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);
}
/// <summary>
/// 获取 TCP 服务函数信息
/// </summary>
/// <param name="type"></param>
/// <param name="method"></param>
/// <param name="serverAttribute"></param>
/// <param name="methodAttribute"></param>
/// <returns></returns>
protected override Method <ServerAttribute, MethodAttribute, ServerSocketSender> get(Type type, MethodInfo method, ServerAttribute serverAttribute, MethodAttribute methodAttribute)
{
return(new Method <ServerAttribute, TcpServer.MethodAttribute, ServerSocketSender>(type, method, serverAttribute, methodAttribute, IsClient));
}
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;
}
