The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting.Metadata \ LastCalledMethodClass

  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. /*============================================================
  16. **
  17. **  File:    RemotingAttributes.cs
  18. **
  19. **  Purpose: Custom attributes for modifying remoting interactions.
  20. **
  21. **
  22. ===========================================================*/
  23. namespace System.Runtime.Remoting.Metadata
  24. {
  25.     using System.Runtime.Remoting.Messaging;
  26.     using System.Runtime.Remoting.Metadata;
  27.     using System.Reflection;
  28.     using System.Threading;
  29.    
  30.     // This is the data we store in MemberInfo.CachedData, mainly to cache custom
  31.     // attributes.
  32.     internal class RemotingCachedData
  33.     {
  34.         protected object RI;
  35.         // reflection structure on which this data structure is stored
  36.         private SoapAttribute _soapAttr = null;
  37.         // Soap related attributes derive from SoapAttribute
  38.        
  39.         internal RemotingCachedData(object ri)
  40.         {
  41.             RI = ri;
  42.         }
  43.         // RemotingCachedData
  44.        
  45.         // Retrieve SOAP attribute info for _mi (or create for caching if not specified)
  46.         internal SoapAttribute GetSoapAttribute()
  47.         {
  48.             if (_soapAttr == null) {
  49.                 lock (this) {
  50.                     if (_soapAttr == null) {
  51.                         SoapAttribute tempSoapAttr = null;
  52.                        
  53.                         ICustomAttributeProvider cap = (ICustomAttributeProvider)RI;
  54.                        
  55.                         if (RI is Type) {
  56.                             object[] attrs = cap.GetCustomAttributes(typeof(SoapTypeAttribute), true);
  57.                             if ((attrs != null) && (attrs.Length != 0))
  58.                                 tempSoapAttr = (SoapAttribute)attrs[0];
  59.                             else
  60.                                 tempSoapAttr = new SoapTypeAttribute();
  61.                         }
  62.                         else if (RI is MethodBase) {
  63.                             object[] attrs = cap.GetCustomAttributes(typeof(SoapMethodAttribute), true);
  64.                             if ((attrs != null) && (attrs.Length != 0))
  65.                                 tempSoapAttr = (SoapAttribute)attrs[0];
  66.                             else
  67.                                 tempSoapAttr = new SoapMethodAttribute();
  68.                         }
  69.                         else if (RI is FieldInfo) {
  70.                             object[] attrs = cap.GetCustomAttributes(typeof(SoapFieldAttribute), false);
  71.                             if ((attrs != null) && (attrs.Length != 0))
  72.                                 tempSoapAttr = (SoapAttribute)attrs[0];
  73.                             else
  74.                                 tempSoapAttr = new SoapFieldAttribute();
  75.                         }
  76.                         else if (RI is ParameterInfo) {
  77.                             object[] attrs = cap.GetCustomAttributes(typeof(SoapParameterAttribute), true);
  78.                             if ((attrs != null) && (attrs.Length != 0))
  79.                                 tempSoapAttr = (SoapParameterAttribute)attrs[0];
  80.                             else
  81.                                 tempSoapAttr = new SoapParameterAttribute();
  82.                         }
  83.                        
  84.                         // IMPORTANT: This has to be done for certain values to be automatically
  85.                         // generated in the attribute.
  86.                         tempSoapAttr.SetReflectInfo(RI);
  87.                        
  88.                         _soapAttr = tempSoapAttr;
  89.                     }
  90.                     // if (_soapAttr == null)
  91.                 }
  92.                 // lock (this)
  93.             }
  94.            
  95.             return _soapAttr;
  96.         }
  97.         // GetSoapAttribute
  98.        
  99.     }
  100.     // class RemotingCachedData
  101.    
  102.    
  103.     internal class RemotingTypeCachedData : RemotingCachedData
  104.     {
  105.        
  106.         private class LastCalledMethodClass
  107.         {
  108.             public string methodName;
  109.             public MethodBase MB;
  110.         }
  111.        
  112.         private LastCalledMethodClass _lastMethodCalled;
  113.         // cache for last method that was called
  114.         private TypeInfo _typeInfo;
  115.         // type info to be used for ObjRef's of this type
  116.         private string _qualifiedTypeName;
  117.         private string _assemblyName;
  118.         private string _simpleAssemblyName;
  119.         // (no strong name, version, etc.)
  120.        
  121.         internal RemotingTypeCachedData(object ri) : base(ri)
  122.         {
  123.             _lastMethodCalled = null;
  124.         }
  125.        
  126.         internal MethodBase GetLastCalledMethod(string newMeth)
  127.         {
  128.             LastCalledMethodClass lastMeth = _lastMethodCalled;
  129.             if (lastMeth == null)
  130.                 return null;
  131.            
  132.             string methodName = lastMeth.methodName;
  133.             MethodBase mbToReturn = lastMeth.MB;
  134.            
  135.             if (mbToReturn == null || methodName == null)
  136.                 return null;
  137.            
  138.             if (methodName.Equals(newMeth))
  139.                 return mbToReturn;
  140.            
  141.             return null;
  142.         }
  143.         // GetLastCalledMethod
  144.         internal void SetLastCalledMethod(string newMethName, MethodBase newMB)
  145.         {
  146.             LastCalledMethodClass lastMeth = new LastCalledMethodClass();
  147.             lastMeth.methodName = newMethName;
  148.             lastMeth.MB = newMB;
  149.            
  150.             _lastMethodCalled = lastMeth;
  151.         }
  152.         // SetLastCalledMethod
  153.        
  154.         // Retrieve TypeInfo object to be used in ObjRef.
  155.         internal TypeInfo TypeInfo {
  156.             get {
  157.                 if (_typeInfo == null)
  158.                     _typeInfo = new TypeInfo((Type)RI);
  159.                
  160.                 return _typeInfo;
  161.             }
  162.         }
  163.         // TypeInfo
  164.        
  165.         internal string QualifiedTypeName {
  166.             get {
  167.                 if (_qualifiedTypeName == null)
  168.                     _qualifiedTypeName = RemotingServices.DetermineDefaultQualifiedTypeName((Type)RI);
  169.                
  170.                 return _qualifiedTypeName;
  171.             }
  172.         }
  173.         // QualifiedTypeName
  174.        
  175.         internal string AssemblyName {
  176.             get {
  177.                 if (_assemblyName == null)
  178.                     _assemblyName = ((Type)RI).Module.Assembly.FullName;
  179.                
  180.                 return _assemblyName;
  181.             }
  182.         }
  183.         // AssemblyName
  184.        
  185.         internal string SimpleAssemblyName {
  186.             get {
  187.                 if (_simpleAssemblyName == null)
  188.                     _simpleAssemblyName = ((Type)RI).Module.Assembly.nGetSimpleName();
  189.                
  190.                 return _simpleAssemblyName;
  191.             }
  192.         }
  193.         // SimpleAssemblyName
  194.        
  195.     }
  196.     // class RemotingTypeCachedData
  197.    
  198.    
  199.     internal class RemotingMethodCachedData : RemotingCachedData
  200.     {
  201.         ParameterInfo[] _parameters = null;
  202.         // list of parameters (cached because reflection always
  203.         // generates a new copy of this array)
  204.         [Flags(), Serializable()]
  205.         private enum MethodCacheFlags
  206.         {
  207.             None = 0,
  208.             CheckedOneWay = 1,
  209.             // Have we checked for OneWay attribute?
  210.             IsOneWay = 2,
  211.             // Is the OneWay attribute present?
  212.             CheckedOverloaded = 4,
  213.             // Have we checked to see if this method is overloaded
  214.             IsOverloaded = 8,
  215.             // Is the method overloaded?
  216.             CheckedForAsync = 16,
  217.             // Have we looked for async versions of this method?
  218.             CheckedForReturnType = 32
  219.             // Have we looked for the return type?
  220.         }
  221.        
  222.         MethodCacheFlags flags;
  223.        
  224.         // Names
  225.         string _typeAndAssemblyName = null;
  226.         string _methodName = null;
  227.         Type _returnType = null;
  228.         // null if return type is void or .ctor
  229.         // parameter maps
  230.         // NOTE: these fields are all initialized at the same time however access to
  231.         // the internal property of each field is locked only on that specific field
  232.         // having been initialized. - hsomu
  233.         int[] _inRefArgMap = null;
  234.         // parameter map of input and ref parameters
  235.         int[] _outRefArgMap = null;
  236.         // parameter map of out and ref parameters (exactly all byref parameters)
  237.         int[] _outOnlyArgMap = null;
  238.         // parameter map of only output parameters
  239.         int[] _nonRefOutArgMap = null;
  240.         // parameter map of non byref parameters marked with [In, Out] (or [Out])
  241.         int[] _marshalRequestMap = null;
  242.         // map of parameters that should be marshaled in
  243.         int[] _marshalResponseMap = null;
  244.         // map of parameters that should be marshaled out
  245.         internal RemotingMethodCachedData(object ri) : base(ri)
  246.         {
  247.         }
  248.        
  249.         internal string TypeAndAssemblyName {
  250.             get {
  251.                 if (_typeAndAssemblyName == null)
  252.                     UpdateNames();
  253.                 return _typeAndAssemblyName;
  254.             }
  255.         }
  256.         // TypeAndAssemblyName
  257.         internal string MethodName {
  258.             get {
  259.                 if (_methodName == null)
  260.                     UpdateNames();
  261.                 return _methodName;
  262.             }
  263.         }
  264.         // MethodName
  265.         private void UpdateNames()
  266.         {
  267.             MethodBase mb = (MethodBase)RI;
  268.             _methodName = mb.Name;
  269.             if (mb.DeclaringType != null) {
  270.                 _typeAndAssemblyName = RemotingServices.GetDefaultQualifiedTypeName(mb.DeclaringType);
  271.             }
  272.         }
  273.         // UpdateNames
  274.         internal ParameterInfo[] Parameters {
  275.             get {
  276.                 if (_parameters == null)
  277.                     _parameters = ((MethodBase)RI).GetParameters();
  278.                 return _parameters;
  279.             }
  280.         }
  281.         // Parameters
  282.        
  283.         // contains index of all byref parameters (marked as "out" or "ref")
  284.         internal int[] OutRefArgMap {
  285.             get {
  286.                 if (_outRefArgMap == null)
  287.                     GetArgMaps();
  288.                 return _outRefArgMap;
  289.             }
  290.         }
  291.         // OutRefArgMap
  292.         // contains index of parameters marked as out
  293.         internal int[] OutOnlyArgMap {
  294.             get {
  295.                 if (_outOnlyArgMap == null)
  296.                     GetArgMaps();
  297.                 return _outOnlyArgMap;
  298.             }
  299.         }
  300.         // OutOnlyArgMap
  301.         // contains index of non byref parameters marked with [In, Out]
  302.         internal int[] NonRefOutArgMap {
  303.             get {
  304.                 if (_nonRefOutArgMap == null)
  305.                     GetArgMaps();
  306.                 return _nonRefOutArgMap;
  307.             }
  308.         }
  309.         // NonRefOutArgMap
  310.         // contains index of parameters that should be marshalled for a request
  311.         internal int[] MarshalRequestArgMap {
  312.             get {
  313.                 if (_marshalRequestMap == null)
  314.                     GetArgMaps();
  315.                 return _marshalRequestMap;
  316.             }
  317.         }
  318.         // MarshalRequestMap
  319.         // contains index of parameters that should be marshalled for a response
  320.         internal int[] MarshalResponseArgMap {
  321.             get {
  322.                 if (_marshalResponseMap == null)
  323.                     GetArgMaps();
  324.                 return _marshalResponseMap;
  325.             }
  326.         }
  327.         // MarshalResponseArgMap
  328.        
  329.         private void GetArgMaps()
  330.         {
  331.             lock (this) {
  332.                 if (_inRefArgMap == null) {
  333.                     int[] inRefArgMap = null;
  334.                     int[] outRefArgMap = null;
  335.                     int[] outOnlyArgMap = null;
  336.                     int[] nonRefOutArgMap = null;
  337.                     int[] marshalRequestMap = null;
  338.                     int[] marshalResponseMap = null;
  339.                    
  340.                     ArgMapper.GetParameterMaps(Parameters, out inRefArgMap, out outRefArgMap, out outOnlyArgMap, out nonRefOutArgMap, out marshalRequestMap, out marshalResponseMap);
  341.                    
  342.                     _inRefArgMap = inRefArgMap;
  343.                     _outRefArgMap = outRefArgMap;
  344.                     _outOnlyArgMap = outOnlyArgMap;
  345.                     _nonRefOutArgMap = nonRefOutArgMap;
  346.                     _marshalRequestMap = marshalRequestMap;
  347.                     _marshalResponseMap = marshalResponseMap;
  348.                    
  349.                 }
  350.             }
  351.         }
  352.         // GetArgMaps
  353.         internal bool IsOneWayMethod()
  354.         {
  355.             // We are not protecting against a race
  356.             // If there is a race while setting flags
  357.             // we will have to compute the result again,
  358.             // but we will always return the correct result
  359.             //
  360.             if ((flags & MethodCacheFlags.CheckedOneWay) == 0) {
  361.                 MethodCacheFlags isOneWay = MethodCacheFlags.CheckedOneWay;
  362.                 object[] attrs = ((ICustomAttributeProvider)RI).GetCustomAttributes(typeof(OneWayAttribute), true);
  363.                
  364.                 if ((attrs != null) && (attrs.Length > 0))
  365.                     isOneWay |= MethodCacheFlags.IsOneWay;
  366.                
  367.                 flags |= isOneWay;
  368.                 return (isOneWay & MethodCacheFlags.IsOneWay) != 0;
  369.             }
  370.             return (flags & MethodCacheFlags.IsOneWay) != 0;
  371.         }
  372.         // IsOneWayMethod
  373.         internal bool IsOverloaded()
  374.         {
  375.             // We are not protecting against a race
  376.             // If there is a race while setting flags
  377.             // we will have to compute the result again,
  378.             // but we will always return the correct result
  379.             //
  380.             if ((flags & MethodCacheFlags.CheckedOverloaded) == 0) {
  381.                 MethodCacheFlags isOverloaded = MethodCacheFlags.CheckedOverloaded;
  382.                 MethodBase mb = (MethodBase)RI;
  383.                
  384.                 if (mb.IsOverloaded)
  385.                     isOverloaded |= MethodCacheFlags.IsOverloaded;
  386.                 flags |= isOverloaded;
  387.                 return (isOverloaded & MethodCacheFlags.IsOverloaded) != 0;
  388.             }
  389.             return (flags & MethodCacheFlags.IsOverloaded) != 0;
  390.         }
  391.         // IsOverloaded
  392.        
  393.         // This will return the return type of the method, or null
  394.         // if the return type is void or this is a .ctor.
  395.         internal Type ReturnType {
  396.             get {
  397.                 if ((flags & MethodCacheFlags.CheckedForReturnType) == 0) {
  398.                     MethodInfo mi = RI as MethodInfo;
  399.                     if (mi != null) {
  400.                         Type returnType = mi.ReturnType;
  401.                         if (returnType != typeof(void))
  402.                             _returnType = returnType;
  403.                     }
  404.                    
  405.                     flags |= MethodCacheFlags.CheckedForReturnType;
  406.                 }
  407.                
  408.                 return _returnType;
  409.             }
  410.         }
  411.         // get
  412.         // ReturnType
  413.     }
  414.     // class RemotingMethodCachedData
  415.    
  416.     //
  417.     // SOAP ATTRIBUTES
  418.     //
  419.    
  420.     // Options for use with SoapOptionAttribute (combine with OR to get any combination)
  421.     [Flags(), Serializable()]
  422.     [System.Runtime.InteropServices.ComVisible(true)]
  423.     public enum SoapOption
  424.     {
  425.         None = 0,
  426.         AlwaysIncludeTypes = 1,
  427.         // xsi:type always included on SOAP elements
  428.         XsdString = 2,
  429.         // xsi:type always included on SOAP elements
  430.         EmbedAll = 4,
  431.         // Soap will be generated without references
  432.         /// <internalonly/>
  433.         Option1 = 8,
  434.         // Option for temporary interop conditions, the use will change over time
  435.         /// <internalonly/>
  436.         Option2 = 16
  437.         // Option for temporary interop conditions, the use will change over time
  438.     }
  439.     // SoapOption
  440.     /// <internalonly/>
  441.     [Serializable()]
  442.     [System.Runtime.InteropServices.ComVisible(true)]
  443.     public enum XmlFieldOrderOption
  444.     {
  445.         All,
  446.         Sequence,
  447.         Choice
  448.     }
  449.     // XmlFieldOrderOption
  450.     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface | AttributeTargets.Enum)]
  451.     [System.Runtime.InteropServices.ComVisible(true)]
  452.     public sealed class SoapTypeAttribute : SoapAttribute
  453.     {
  454.         // Used to track which values have been explicitly set. Information needed
  455.         // by SoapServices.
  456.         [Flags(), Serializable()]
  457.         private enum ExplicitlySet
  458.         {
  459.             None = 0,
  460.             XmlElementName = 1,
  461.             XmlNamespace = 2,
  462.             XmlTypeName = 4,
  463.             XmlTypeNamespace = 8
  464.         }
  465.        
  466.         private ExplicitlySet _explicitlySet = ExplicitlySet.None;
  467.        
  468.         private SoapOption _SoapOptions = SoapOption.None;
  469.         private string _XmlElementName = null;
  470.         private string _XmlTypeName = null;
  471.         private string _XmlTypeNamespace = null;
  472.         private XmlFieldOrderOption _XmlFieldOrder = XmlFieldOrderOption.All;
  473.        
  474.        
  475.         // Returns true if this attribute specifies interop xml element values.
  476.         internal bool IsInteropXmlElement()
  477.         {
  478.             return (_explicitlySet & (ExplicitlySet.XmlElementName | ExplicitlySet.XmlNamespace)) != 0;
  479.         }
  480.         // IsInteropXmlElement
  481.         internal bool IsInteropXmlType()
  482.         {
  483.             return (_explicitlySet & (ExplicitlySet.XmlTypeName | ExplicitlySet.XmlTypeNamespace)) != 0;
  484.         }
  485.         // IsInteropXmlType
  486.        
  487.        
  488.         public SoapOption SoapOptions {
  489.             get { return _SoapOptions; }
  490.             set { _SoapOptions = value; }
  491.         }
  492.         // SoapOptions
  493.         public string XmlElementName {
  494.             get {
  495.                 // generate this if it hasn't been set yet
  496.                 if ((_XmlElementName == null) && (ReflectInfo != null))
  497.                     _XmlElementName = GetTypeName((Type)ReflectInfo);
  498.                 return _XmlElementName;
  499.             }
  500.            
  501.             set {
  502.                 _XmlElementName = value;
  503.                 _explicitlySet |= ExplicitlySet.XmlElementName;
  504.             }
  505.         }
  506.         // XmlElementName
  507.         public override string XmlNamespace {
  508.             get {
  509.                 // generate this if it hasn't been set
  510.                 if ((ProtXmlNamespace == null) && (ReflectInfo != null)) {
  511.                     ProtXmlNamespace = XmlTypeNamespace;
  512.                 }
  513.                 return ProtXmlNamespace;
  514.             }
  515.            
  516.             set {
  517.                 ProtXmlNamespace = value;
  518.                 _explicitlySet |= ExplicitlySet.XmlNamespace;
  519.             }
  520.         }
  521.         // XmlNamespace
  522.         public string XmlTypeName {
  523.             // value for xml type name (this should always be valid)
  524.             get {
  525.                 // generate this if it hasn't been set yet
  526.                 if ((_XmlTypeName == null) && (ReflectInfo != null))
  527.                     _XmlTypeName = GetTypeName((Type)ReflectInfo);
  528.                 return _XmlTypeName;
  529.             }
  530.            
  531.             set {
  532.                 _XmlTypeName = value;
  533.                 _explicitlySet |= ExplicitlySet.XmlTypeName;
  534.             }
  535.         }
  536.         // XmlTypeName
  537.         public string XmlTypeNamespace {
  538.             // value for xml type namespace (this should always be valid)
  539.             get {
  540.                 // generate this if it hasn't been set yet
  541.                 if ((_XmlTypeNamespace == null) && (ReflectInfo != null)) {
  542.                     _XmlTypeNamespace = XmlNamespaceEncoder.GetXmlNamespaceForTypeNamespace((Type)ReflectInfo, null);
  543.                 }
  544.                 return _XmlTypeNamespace;
  545.             }
  546.            
  547.             set {
  548.                 _XmlTypeNamespace = value;
  549.                 _explicitlySet |= ExplicitlySet.XmlTypeNamespace;
  550.             }
  551.         }
  552.         // XmlTypeNamespace
  553.         /// <internalonly/>
  554.         public XmlFieldOrderOption XmlFieldOrder {
  555.             get { return _XmlFieldOrder; }
  556.             set { _XmlFieldOrder = value; }
  557.         }
  558.         // XmlFieldOrder
  559.         public override bool UseAttribute {
  560.             get { return false; }
  561.             set {
  562.                 throw new RemotingException(Environment.GetResourceString("Remoting_Attribute_UseAttributeNotsettable"));
  563.             }
  564.         }
  565.         // UseAttribute
  566.         private static string GetTypeName(Type t)
  567.         {
  568.             if (t.IsNested) {
  569.                 string name = t.FullName;
  570.                 string ns = t.Namespace;
  571.                 if (ns == null || ns.Length == 0) {
  572.                     return name;
  573.                 }
  574.                 else {
  575.                     name = name.Substring(ns.Length + 1);
  576.                     return name;
  577.                 }
  578.             }
  579.             return t.Name;
  580.         }
  581.        
  582.     }
  583.     // class SoapTypeAttribute
  584.    
  585.     [AttributeUsage(AttributeTargets.Method)]
  586.     [System.Runtime.InteropServices.ComVisible(true)]
  587.     public sealed class SoapMethodAttribute : SoapAttribute
  588.     {
  589.         private string _SoapAction = null;
  590.        
  591.         private string _responseXmlElementName = null;
  592.         private string _responseXmlNamespace = null;
  593.         private string _returnXmlElementName = null;
  594.        
  595.         private bool _bSoapActionExplicitySet = false;
  596.         // Needed by SoapServices to determine if
  597.         // SoapAction was actually set (otherwise,
  598.         // accessing it will return a generated
  599.         // value)
  600.         internal bool SoapActionExplicitySet {
  601.             get { return _bSoapActionExplicitySet; }
  602.         }
  603.        
  604.         public string SoapAction {
  605.             // SoapAction value to place in protocol headers.
  606.             get {
  607.                 // generate this if it hasn't been set
  608.                 if (_SoapAction == null) {
  609.                     _SoapAction = XmlTypeNamespaceOfDeclaringType + "#" + ((MemberInfo)ReflectInfo).Name;
  610.                     // This will be the method name.
  611.                 }
  612.                 return _SoapAction;
  613.             }
  614.            
  615.             set {
  616.                 _SoapAction = value;
  617.                 _bSoapActionExplicitySet = true;
  618.             }
  619.         }
  620.        
  621.         public override bool UseAttribute {
  622.             get { return false; }
  623.             set {
  624.                 throw new RemotingException(Environment.GetResourceString("Remoting_Attribute_UseAttributeNotsettable"));
  625.             }
  626.         }
  627.        
  628.         public override string XmlNamespace {
  629.             get {
  630.                 // generate this if it hasn't been set
  631.                 if (ProtXmlNamespace == null) {
  632.                     ProtXmlNamespace = XmlTypeNamespaceOfDeclaringType;
  633.                 }
  634.                 return ProtXmlNamespace;
  635.             }
  636.            
  637.             set { ProtXmlNamespace = value; }
  638.         }
  639.         // XmlNamespace
  640.        
  641.         public string ResponseXmlElementName {
  642.             get {
  643.                 // generate this if it hasn't been set yet
  644.                 if ((_responseXmlElementName == null) && (ReflectInfo != null))
  645.                     _responseXmlElementName = ((MemberInfo)ReflectInfo).Name + "Response";
  646.                 return _responseXmlElementName;
  647.             }
  648.            
  649.             set { _responseXmlElementName = value; }
  650.         }
  651.         // ResponseXmlElementName
  652.        
  653.         public string ResponseXmlNamespace {
  654.             get {
  655.                 // generate this if it hasn't been set
  656.                 if (_responseXmlNamespace == null)
  657.                     _responseXmlNamespace = XmlNamespace;
  658.                 return _responseXmlNamespace;
  659.             }
  660.            
  661.             set { _responseXmlNamespace = value; }
  662.         }
  663.         // ResponseXmlNamespace
  664.        
  665.         public string ReturnXmlElementName {
  666.             get {
  667.                 // generate this if it hasn't been set yet
  668.                 if (_returnXmlElementName == null)
  669.                     _returnXmlElementName = "return";
  670.                 return _returnXmlElementName;
  671.             }
  672.            
  673.             set { _returnXmlElementName = value; }
  674.         }
  675.         // ReturnXmlElementName
  676.        
  677.         private string XmlTypeNamespaceOfDeclaringType {
  678.             get {
  679.                 if (ReflectInfo != null) {
  680.                     Type declaringType = ((MemberInfo)ReflectInfo).DeclaringType;
  681.                     return XmlNamespaceEncoder.GetXmlNamespaceForType(declaringType, null);
  682.                 }
  683.                 else
  684.                     return null;
  685.             }
  686.         }
  687.         // XmlTypeNamespaceOfDeclaringType
  688.     }
  689.     // class SoapMethodAttribute
  690.    
  691.     [AttributeUsage(AttributeTargets.Field)]
  692.     [System.Runtime.InteropServices.ComVisible(true)]
  693.     public sealed class SoapFieldAttribute : SoapAttribute
  694.     {
  695.         // Used to track which values have been explicitly set. Information needed
  696.         // by SoapServices.
  697.         [Flags(), Serializable()]
  698.         private enum ExplicitlySet
  699.         {
  700.             None = 0,
  701.             XmlElementName = 1
  702.         }
  703.        
  704.         private ExplicitlySet _explicitlySet = ExplicitlySet.None;
  705.        
  706.        
  707.         private string _xmlElementName = null;
  708.         private int _order;
  709.         // order in which fields should be serialized
  710.         // (if Sequence is specified on containing type's SoapTypeAttribute
  711.        
  712.         // Returns true if this attribute specifies interop xml element values.
  713.         public bool IsInteropXmlElement()
  714.         {
  715.             return (_explicitlySet & ExplicitlySet.XmlElementName) != 0;
  716.         }
  717.         // GetInteropXmlElement
  718.        
  719.         public string XmlElementName {
  720.             get {
  721.                 // generate this if it hasn't been set yet
  722.                 if ((_xmlElementName == null) && (ReflectInfo != null))
  723.                     _xmlElementName = ((FieldInfo)ReflectInfo).Name;
  724.                 return _xmlElementName;
  725.             }
  726.            
  727.             set {
  728.                 _xmlElementName = value;
  729.                 _explicitlySet |= ExplicitlySet.XmlElementName;
  730.             }
  731.         }
  732.         // XmlElementName
  733.        
  734.         /// <internalonly/>
  735.         public int Order {
  736.             get { return _order; }
  737.             set { _order = value; }
  738.         }
  739.        
  740.     }
  741.     // class SoapFieldAttribute
  742.    
  743.     [AttributeUsage(AttributeTargets.Parameter)]
  744.     [System.Runtime.InteropServices.ComVisible(true)]
  745.     public sealed class SoapParameterAttribute : SoapAttribute
  746.     {
  747.     }
  748.     // SoapParameterAttribute
  749.    
  750.    
  751.     // Not actually used as an attribute (just the base for the rest of them)
  752.     [System.Runtime.InteropServices.ComVisible(true)]
  753.     public class SoapAttribute : Attribute
  754.     {
  755.         /// <internalonly/>
  756.         protected string ProtXmlNamespace = null;
  757.         private bool _bUseAttribute = false;
  758.         private bool _bEmbedded = false;
  759.        
  760.         /// <internalonly/>
  761.         protected object ReflectInfo = null;
  762.         // Reflection structure on which this attribute was defined
  763.         // IMPORTANT: The caching mechanism is required to set this value before
  764.         // handing back a SoapAttribute, so that certain values can be automatically
  765.         // generated.
  766.         internal void SetReflectInfo(object info)
  767.         {
  768.             ReflectInfo = info;
  769.         }
  770.        
  771.         public virtual string XmlNamespace {
  772.             // If this returns null, then this shouldn't be namespace qualified.
  773.             get { return ProtXmlNamespace; }
  774.             set { ProtXmlNamespace = value; }
  775.         }
  776.        
  777.         public virtual bool UseAttribute {
  778.             get { return _bUseAttribute; }
  779.             set { _bUseAttribute = value; }
  780.         }
  781.        
  782.         public virtual bool Embedded {
  783.             // Determines if type should be nested when serializing for SOAP.
  784.             get { return _bEmbedded; }
  785.             set { _bEmbedded = value; }
  786.         }
  787.        
  788.     }
  789.     // class SoapAttribute
  790.    
  791.     //
  792.     // END OF SOAP ATTRIBUTES
  793.     //
  794.    
  795.    
  796. }
  797. // namespace System.Runtime.Remoting

Developer Fusion