mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
350 lines
16 KiB
C#
350 lines
16 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="WebMethodAttribute.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.Services {
|
|
|
|
using System;
|
|
using System.Reflection;
|
|
using System.Collections;
|
|
using System.Web.Util;
|
|
using System.Web.Services.Protocols;
|
|
using System.Xml.Serialization;
|
|
using System.EnterpriseServices;
|
|
using System.Text;
|
|
using System.Runtime.InteropServices;
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute"]/*' />
|
|
/// <devdoc>
|
|
/// <para> The WebMethod attribute must be placed on a method in a Web Service class to mark it as available
|
|
/// to be called via the Web. The method and class must be marked public and must run inside of
|
|
/// an ASP.NET Web application.</para>
|
|
/// </devdoc>
|
|
[AttributeUsage(AttributeTargets.Method)]
|
|
public sealed class WebMethodAttribute : Attribute {
|
|
private int transactionOption; // this is an int to prevent system.enterpriseservices.dll from getting loaded
|
|
private bool enableSession;
|
|
private int cacheDuration;
|
|
private bool bufferResponse;
|
|
private string description;
|
|
private string messageName;
|
|
|
|
private bool transactionOptionSpecified;
|
|
private bool enableSessionSpecified;
|
|
private bool cacheDurationSpecified;
|
|
private bool bufferResponseSpecified;
|
|
private bool descriptionSpecified;
|
|
private bool messageNameSpecified;
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute.WebMethodAttribute"]/*' />
|
|
/// <devdoc>
|
|
/// <para>Initializes a new instance of the <see cref='System.Web.Services.WebMethodAttribute'/>
|
|
/// class.</para>
|
|
/// </devdoc>
|
|
public WebMethodAttribute() {
|
|
enableSession = false;
|
|
transactionOption = 0; // TransactionOption.Disabled
|
|
cacheDuration = 0;
|
|
bufferResponse = true;
|
|
}
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute.WebMethodAttribute1"]/*' />
|
|
/// <devdoc>
|
|
/// <para>Initializes a new instance of the <see cref='System.Web.Services.WebMethodAttribute'/>
|
|
/// class.</para>
|
|
/// </devdoc>
|
|
public WebMethodAttribute(bool enableSession)
|
|
: this() {
|
|
EnableSession = enableSession;
|
|
}
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute.WebMethodAttribute2"]/*' />
|
|
/// <devdoc>
|
|
/// <para>Initializes a new instance of the <see cref='System.Web.Services.WebMethodAttribute'/>
|
|
/// class.</para>
|
|
/// </devdoc>
|
|
public WebMethodAttribute(bool enableSession, TransactionOption transactionOption)
|
|
: this() {
|
|
EnableSession = enableSession;
|
|
this.transactionOption = (int)transactionOption;
|
|
transactionOptionSpecified = true;
|
|
}
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute.WebMethodAttribute3"]/*' />
|
|
/// <devdoc>
|
|
/// <para>Initializes a new instance of the <see cref='System.Web.Services.WebMethodAttribute'/>
|
|
/// class.</para>
|
|
/// </devdoc>
|
|
public WebMethodAttribute(bool enableSession, TransactionOption transactionOption, int cacheDuration) {
|
|
EnableSession = enableSession;
|
|
this.transactionOption = (int)transactionOption;
|
|
transactionOptionSpecified = true;
|
|
CacheDuration = cacheDuration;
|
|
BufferResponse = true;
|
|
}
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute.WebMethodAttribute4"]/*' />
|
|
/// <devdoc>
|
|
/// <para>Initializes a new instance of the <see cref='System.Web.Services.WebMethodAttribute'/>
|
|
/// class.</para>
|
|
/// </devdoc>
|
|
public WebMethodAttribute(bool enableSession, TransactionOption transactionOption, int cacheDuration, bool bufferResponse) {
|
|
EnableSession = enableSession;
|
|
this.transactionOption = (int)transactionOption;
|
|
transactionOptionSpecified = true;
|
|
CacheDuration = cacheDuration;
|
|
BufferResponse = bufferResponse;
|
|
}
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute.Description"]/*' />
|
|
/// <devdoc>
|
|
/// <para> A message that describes the Web service method.
|
|
/// The message is used in description files generated for a Web Service, such as the Service Contract and the Service Description page.</para>
|
|
/// </devdoc>
|
|
public string Description {
|
|
get {
|
|
return (description == null) ? string.Empty : description;
|
|
}
|
|
|
|
set {
|
|
description = value;
|
|
descriptionSpecified = true;
|
|
}
|
|
}
|
|
internal bool DescriptionSpecified { get { return descriptionSpecified; } }
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute.EnableSession"]/*' />
|
|
/// <devdoc>
|
|
/// <para>Indicates wheter session state is enabled for a Web service Method. The default is false.</para>
|
|
/// </devdoc>
|
|
public bool EnableSession {
|
|
get {
|
|
return enableSession;
|
|
}
|
|
|
|
set {
|
|
enableSession = value;
|
|
enableSessionSpecified = true;
|
|
}
|
|
}
|
|
internal bool EnableSessionSpecified { get { return enableSessionSpecified; } }
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute.CacheDuration"]/*' />
|
|
/// <devdoc>
|
|
/// <para>Indicates the number of seconds the response should be cached. Defaults to 0 (no caching).
|
|
/// Should be used with caution when requests are likely to be very large.</para>
|
|
/// </devdoc>
|
|
public int CacheDuration {
|
|
get {
|
|
return cacheDuration;
|
|
}
|
|
|
|
set {
|
|
cacheDuration = value;
|
|
cacheDurationSpecified = true;
|
|
}
|
|
}
|
|
internal bool CacheDurationSpecified { get { return cacheDurationSpecified; } }
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute.BufferResponse"]/*' />
|
|
/// <devdoc>
|
|
/// <para>Indicates whether the response for this request should be buffered. Defaults to false.</para>
|
|
/// </devdoc>
|
|
public bool BufferResponse {
|
|
get {
|
|
return bufferResponse;
|
|
}
|
|
|
|
set {
|
|
bufferResponse = value;
|
|
bufferResponseSpecified = true;
|
|
}
|
|
}
|
|
internal bool BufferResponseSpecified { get { return bufferResponseSpecified; } }
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute.TransactionOption"]/*' />
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Indicates the transaction participation mode of a Web Service Method. </para>
|
|
/// </devdoc>
|
|
public TransactionOption TransactionOption {
|
|
get {
|
|
return (TransactionOption)transactionOption;
|
|
}
|
|
set {
|
|
transactionOption = (int)value;
|
|
transactionOptionSpecified = true;
|
|
}
|
|
}
|
|
internal bool TransactionOptionSpecified { get { return transactionOptionSpecified; } }
|
|
|
|
internal bool TransactionEnabled {
|
|
get {
|
|
return transactionOption != 0;
|
|
}
|
|
}
|
|
|
|
/// <include file='doc\WebMethodAttribute.uex' path='docs/doc[@for="WebMethodAttribute.MessageName"]/*' />
|
|
/// <devdoc>
|
|
/// <para>The name used for the request and response message containing the
|
|
/// data passed to and returned from this method.</para>
|
|
/// </devdoc>
|
|
public string MessageName {
|
|
get {
|
|
return messageName == null ? string.Empty : messageName;
|
|
}
|
|
|
|
set {
|
|
messageName = value;
|
|
messageNameSpecified = true;
|
|
}
|
|
}
|
|
internal bool MessageNameSpecified { get { return messageNameSpecified; } }
|
|
}
|
|
|
|
internal class WebMethodReflector {
|
|
private WebMethodReflector() { }
|
|
/*
|
|
internal static WebMethodAttribute GetAttribute(MethodInfo implementation) {
|
|
return GetAttribute(implementation, null);
|
|
}
|
|
*/
|
|
|
|
internal static WebMethodAttribute GetAttribute(MethodInfo implementation, MethodInfo declaration) {
|
|
WebMethodAttribute declAttribute = null;
|
|
WebMethodAttribute implAttribute = null;
|
|
object[] attrs;
|
|
|
|
if (declaration != null) {
|
|
attrs = declaration.GetCustomAttributes(typeof(WebMethodAttribute), false);
|
|
if (attrs.Length > 0) {
|
|
declAttribute = (WebMethodAttribute)attrs[0];
|
|
}
|
|
}
|
|
attrs = implementation.GetCustomAttributes(typeof(WebMethodAttribute), false);
|
|
if (attrs.Length > 0) {
|
|
implAttribute = (WebMethodAttribute)attrs[0];
|
|
}
|
|
if (declAttribute == null) {
|
|
return implAttribute;
|
|
}
|
|
if (implAttribute == null) {
|
|
return declAttribute;
|
|
}
|
|
if (implAttribute.MessageNameSpecified) {
|
|
throw new InvalidOperationException(Res.GetString(Res.ContractOverride, implementation.Name, implementation.DeclaringType.FullName, declaration.DeclaringType.FullName, declaration.ToString(), "WebMethod.MessageName"));
|
|
}
|
|
// merge two attributes
|
|
WebMethodAttribute attribute = new WebMethodAttribute(implAttribute.EnableSessionSpecified ? implAttribute.EnableSession : declAttribute.EnableSession);
|
|
attribute.TransactionOption = implAttribute.TransactionOptionSpecified ? implAttribute.TransactionOption : declAttribute.TransactionOption;
|
|
attribute.CacheDuration = implAttribute.CacheDurationSpecified ? implAttribute.CacheDuration : declAttribute.CacheDuration;
|
|
attribute.BufferResponse = implAttribute.BufferResponseSpecified ? implAttribute.BufferResponse : declAttribute.BufferResponse;
|
|
attribute.Description = implAttribute.DescriptionSpecified ? implAttribute.Description : declAttribute.Description;
|
|
return attribute;
|
|
}
|
|
|
|
// Find the MethodInfo of the interface method from the implemented method
|
|
internal static MethodInfo FindInterfaceMethodInfo(Type type, string signature)
|
|
{
|
|
Type[] interfaces = type.GetInterfaces();
|
|
// Foreach type get the interface map and then search each TargetMethod
|
|
// till we find the right one. Once found return the corresponding interface method
|
|
foreach (Type i in interfaces) {
|
|
InterfaceMapping map = type.GetInterfaceMap(i);
|
|
MethodInfo[] targetMethods = map.TargetMethods;
|
|
for (int j = 0; j < targetMethods.Length; j++) {
|
|
if (targetMethods[j].ToString() == signature) {
|
|
return map.InterfaceMethods[j];
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal static LogicalMethodInfo[] GetMethods(Type type) {
|
|
if (type.IsInterface) {
|
|
throw new InvalidOperationException(Res.GetString(Res.NeedConcreteType, type.FullName));
|
|
}
|
|
ArrayList list = new ArrayList();
|
|
MethodInfo[] methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic);
|
|
Hashtable unique = new Hashtable();
|
|
Hashtable methodInfos = new Hashtable();
|
|
for (int i = 0; i < methods.Length; i++) {
|
|
Type declaringType = methods[i].DeclaringType;
|
|
if (declaringType == typeof(object))
|
|
continue;
|
|
if (declaringType == typeof(WebService))
|
|
continue;
|
|
string signature = methods[i].ToString();
|
|
MethodInfo declaration = FindInterfaceMethodInfo(declaringType, signature);
|
|
WebServiceBindingAttribute binding = null;
|
|
|
|
if (declaration != null) {
|
|
object[] attrs = declaration.DeclaringType.GetCustomAttributes(typeof(WebServiceBindingAttribute), false);
|
|
if (attrs.Length > 0) {
|
|
if (attrs.Length > 1)
|
|
throw new ArgumentException(Res.GetString(Res.OnlyOneWebServiceBindingAttributeMayBeSpecified1, declaration.DeclaringType.FullName), "type");
|
|
binding = (WebServiceBindingAttribute)attrs[0];
|
|
if (binding.Name == null || binding.Name.Length == 0) {
|
|
binding.Name = declaration.DeclaringType.Name;
|
|
}
|
|
}
|
|
else {
|
|
declaration = null;
|
|
}
|
|
}
|
|
else if (!methods[i].IsPublic) {
|
|
continue;
|
|
}
|
|
WebMethodAttribute attribute = WebMethodReflector.GetAttribute(methods[i], declaration);
|
|
if (attribute == null)
|
|
continue;
|
|
|
|
WebMethod webMethod = new WebMethod(declaration, binding, attribute);
|
|
methodInfos.Add(methods[i], webMethod);
|
|
MethodInfo method = (MethodInfo)unique[signature];
|
|
if (method == null) {
|
|
unique.Add(signature, methods[i]);
|
|
list.Add(methods[i]);
|
|
}
|
|
else {
|
|
if (method.DeclaringType.IsAssignableFrom(methods[i].DeclaringType)) {
|
|
unique[signature] = methods[i];
|
|
list[list.IndexOf(method)] = methods[i];
|
|
}
|
|
}
|
|
}
|
|
return LogicalMethodInfo.Create((MethodInfo[])list.ToArray(typeof(MethodInfo)), LogicalMethodTypes.Async | LogicalMethodTypes.Sync, methodInfos);
|
|
}
|
|
|
|
internal static void IncludeTypes(LogicalMethodInfo[] methods, XmlReflectionImporter importer) {
|
|
for (int i = 0; i < methods.Length; i++) {
|
|
LogicalMethodInfo method = methods[i];
|
|
IncludeTypes(method, importer);
|
|
}
|
|
}
|
|
|
|
internal static void IncludeTypes(LogicalMethodInfo method, XmlReflectionImporter importer) {
|
|
if (method.Declaration != null) {
|
|
importer.IncludeTypes(method.Declaration.DeclaringType);
|
|
importer.IncludeTypes(method.Declaration);
|
|
}
|
|
importer.IncludeTypes(method.DeclaringType);
|
|
importer.IncludeTypes(method.CustomAttributeProvider);
|
|
}
|
|
}
|
|
|
|
internal class WebMethod {
|
|
internal MethodInfo declaration;
|
|
internal WebServiceBindingAttribute binding;
|
|
internal WebMethodAttribute attribute;
|
|
internal WebMethod(MethodInfo declaration, WebServiceBindingAttribute binding, WebMethodAttribute attribute) {
|
|
this.declaration = declaration;
|
|
this.binding = binding;
|
|
this.attribute = attribute;
|
|
}
|
|
}
|
|
}
|