The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting \ SoapServices

  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:    Soap.cs
  18. **
  19. ** Purpose: Classes used for SOAP configuration.
  20. **
  21. **
  22. ===========================================================*/
  23. namespace System.Runtime.Remoting
  24. {
  25.     using System;
  26.     using System.Collections;
  27.     using System.IO;
  28.     using System.Text;
  29.     using System.Reflection;
  30.     using System.Runtime.InteropServices;
  31.     using System.Runtime.Remoting.Activation;
  32.     using System.Runtime.Remoting.Messaging;
  33.     using System.Runtime.Remoting.Metadata;
  34.     using System.Runtime.Serialization;
  35.     using System.Runtime.Serialization.Formatters.Binary;
  36.     using System.Security.Permissions;
  37.     using System.Threading;
  38.    
  39.     using CultureInfo = System.Globalization.CultureInfo;
  40.    
  41.    
  42.     [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure)]
  43.     [System.Runtime.InteropServices.ComVisible(true)]
  44.     public class SoapServices
  45.     {
  46.         // hide the default constructor
  47.         private SoapServices()
  48.         {
  49.         }
  50.        
  51.         // tables for interop type maps (both map "name namespace" to a Type object)
  52.         private static Hashtable _interopXmlElementToType = Hashtable.Synchronized(new Hashtable());
  53.         private static Hashtable _interopTypeToXmlElement = Hashtable.Synchronized(new Hashtable());
  54.        
  55.         private static Hashtable _interopXmlTypeToType = Hashtable.Synchronized(new Hashtable());
  56.         private static Hashtable _interopTypeToXmlType = Hashtable.Synchronized(new Hashtable());
  57.        
  58.         private static Hashtable _xmlToFieldTypeMap = Hashtable.Synchronized(new Hashtable());
  59.        
  60.         private static Hashtable _methodBaseToSoapAction = Hashtable.Synchronized(new Hashtable());
  61.         private static Hashtable _soapActionToMethodBase = Hashtable.Synchronized(new Hashtable());
  62.        
  63.        
  64.         private static string CreateKey(string elementName, string elementNamespace)
  65.         {
  66.             if (elementNamespace == null)
  67.                 return elementName;
  68.             else
  69.                 return elementName + " " + elementNamespace;
  70.         }
  71.        
  72.         // Used for storing interop type mappings
  73.         private class XmlEntry
  74.         {
  75.             public string Name;
  76.             public string Namespace;
  77.            
  78.             public XmlEntry(string name, string xmlNamespace)
  79.             {
  80.                 Name = name;
  81.                 Namespace = xmlNamespace;
  82.             }
  83.         }
  84.         // class XmlEntry
  85.        
  86.         // contains mappings for xml element and attribute names to actual field names.
  87.         private class XmlToFieldTypeMap
  88.         {
  89.             private class FieldEntry
  90.             {
  91.                 public Type Type;
  92.                 public string Name;
  93.                
  94.                 public FieldEntry(Type type, string name)
  95.                 {
  96.                     Type = type;
  97.                     Name = name;
  98.                 }
  99.             }
  100.            
  101.             private Hashtable _attributes = new Hashtable();
  102.             private Hashtable _elements = new Hashtable();
  103.            
  104.             public XmlToFieldTypeMap()
  105.             {
  106.             }
  107.            
  108.             public void AddXmlElement(Type fieldType, string fieldName, string xmlElement, string xmlNamespace)
  109.             {
  110.                 _elements[CreateKey(xmlElement, xmlNamespace)] = new FieldEntry(fieldType, fieldName);
  111.             }
  112.            
  113.             public void AddXmlAttribute(Type fieldType, string fieldName, string xmlAttribute, string xmlNamespace)
  114.             {
  115.                 _attributes[CreateKey(xmlAttribute, xmlNamespace)] = new FieldEntry(fieldType, fieldName);
  116.             }
  117.            
  118.             public void GetFieldTypeAndNameFromXmlElement(string xmlElement, string xmlNamespace, out Type type, out string name)
  119.             {
  120.                 FieldEntry field = (FieldEntry)_elements[CreateKey(xmlElement, xmlNamespace)];
  121.                 if (field != null) {
  122.                     type = field.Type;
  123.                     name = field.Name;
  124.                 }
  125.                 else {
  126.                     type = null;
  127.                     name = null;
  128.                 }
  129.             }
  130.             // GetTypeFromXmlElement
  131.             public void GetFieldTypeAndNameFromXmlAttribute(string xmlAttribute, string xmlNamespace, out Type type, out string name)
  132.             {
  133.                 FieldEntry field = (FieldEntry)_attributes[CreateKey(xmlAttribute, xmlNamespace)];
  134.                 if (field != null) {
  135.                     type = field.Type;
  136.                     name = field.Name;
  137.                 }
  138.                 else {
  139.                     type = null;
  140.                     name = null;
  141.                 }
  142.             }
  143.             // GetTypeFromXmlAttribute
  144.         }
  145.         // class XmlToFieldTypeMap
  146.        
  147.         public static void RegisterInteropXmlElement(string xmlElement, string xmlNamespace, Type type)
  148.         {
  149.             _interopXmlElementToType[CreateKey(xmlElement, xmlNamespace)] = type;
  150.             _interopTypeToXmlElement[type] = new XmlEntry(xmlElement, xmlNamespace);
  151.         }
  152.         // RegisterInteropXmlElement
  153.        
  154.         public static void RegisterInteropXmlType(string xmlType, string xmlTypeNamespace, Type type)
  155.         {
  156.             _interopXmlTypeToType[CreateKey(xmlType, xmlTypeNamespace)] = type;
  157.             _interopTypeToXmlType[type] = new XmlEntry(xmlType, xmlTypeNamespace);
  158.         }
  159.         // RegisterInteropXmlType
  160.        
  161.         public static void PreLoad(Type type)
  162.         {
  163.             // register soap action values
  164.             MethodInfo[] methods = type.GetMethods();
  165.             foreach (MethodInfo mi in methods) {
  166.                 // This will only add an entry to the table if SoapAction was explicitly set
  167.                 // on the SoapMethodAttribute.
  168.                 RegisterSoapActionForMethodBase(mi);
  169.             }
  170.            
  171.             // register interop xml elements and types if specified
  172.             SoapTypeAttribute attr = (SoapTypeAttribute)InternalRemotingServices.GetCachedSoapAttribute(type);
  173.            
  174.             if (attr.IsInteropXmlElement())
  175.                 RegisterInteropXmlElement(attr.XmlElementName, attr.XmlNamespace, type);
  176.             if (attr.IsInteropXmlType())
  177.                 RegisterInteropXmlType(attr.XmlTypeName, attr.XmlTypeNamespace, type);
  178.            
  179.             // construct field maps for mapping xml elements and attributes back to
  180.             // the correct type
  181.             int mapCount = 0;
  182.             XmlToFieldTypeMap map = new XmlToFieldTypeMap();
  183.            
  184.             foreach (FieldInfo field in type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)) {
  185.                 SoapFieldAttribute fieldAttr = (SoapFieldAttribute)InternalRemotingServices.GetCachedSoapAttribute(field);
  186.                
  187.                 if (fieldAttr.IsInteropXmlElement()) {
  188.                     string xmlName = fieldAttr.XmlElementName;
  189.                     string xmlNamespace = fieldAttr.XmlNamespace;
  190.                     if (fieldAttr.UseAttribute)
  191.                         map.AddXmlAttribute(field.FieldType, field.Name, xmlName, xmlNamespace);
  192.                     else
  193.                         map.AddXmlElement(field.FieldType, field.Name, xmlName, xmlNamespace);
  194.                    
  195.                     mapCount++;
  196.                 }
  197.             }
  198.             // foreach field
  199.             // add field map if there is more than one entry
  200.             if (mapCount > 0)
  201.                 _xmlToFieldTypeMap[type] = map;
  202.            
  203.         }
  204.         // PreLoad
  205.        
  206.         public static void PreLoad(Assembly assembly)
  207.         {
  208.             Type[] types = assembly.GetTypes();
  209.             foreach (Type type in types) {
  210.                 PreLoad(type);
  211.             }
  212.         }
  213.         // PreLoad
  214.         public static Type GetInteropTypeFromXmlElement(string xmlElement, string xmlNamespace)
  215.         {
  216.             return (Type)_interopXmlElementToType[CreateKey(xmlElement, xmlNamespace)];
  217.         }
  218.         // GetInteropTypeFromXmlElement
  219.        
  220.         public static Type GetInteropTypeFromXmlType(string xmlType, string xmlTypeNamespace)
  221.         {
  222.             return (Type)_interopXmlTypeToType[CreateKey(xmlType, xmlTypeNamespace)];
  223.         }
  224.         // GetInteropTypeFromXmlElement
  225.        
  226.         public static void GetInteropFieldTypeAndNameFromXmlElement(Type containingType, string xmlElement, string xmlNamespace, out Type type, out string name)
  227.         {
  228.             if (containingType == null) {
  229.                 type = null;
  230.                 name = null;
  231.                 return;
  232.             }
  233.            
  234.             XmlToFieldTypeMap map = (XmlToFieldTypeMap)_xmlToFieldTypeMap[containingType];
  235.             if (map != null) {
  236.                 map.GetFieldTypeAndNameFromXmlElement(xmlElement, xmlNamespace, out type, out name);
  237.             }
  238.             else {
  239.                 type = null;
  240.                 name = null;
  241.             }
  242.         }
  243.         // GetInteropFieldTypeFromXmlElement
  244.        
  245.         public static void GetInteropFieldTypeAndNameFromXmlAttribute(Type containingType, string xmlAttribute, string xmlNamespace, out Type type, out string name)
  246.         {
  247.             if (containingType == null) {
  248.                 type = null;
  249.                 name = null;
  250.                 return;
  251.             }
  252.            
  253.             XmlToFieldTypeMap map = (XmlToFieldTypeMap)_xmlToFieldTypeMap[containingType];
  254.             if (map != null) {
  255.                 map.GetFieldTypeAndNameFromXmlAttribute(xmlAttribute, xmlNamespace, out type, out name);
  256.             }
  257.             else {
  258.                 type = null;
  259.                 name = null;
  260.             }
  261.         }
  262.         // GetInteropFieldTypeFromXmlAttribute
  263.        
  264.         public static bool GetXmlElementForInteropType(Type type, out string xmlElement, out string xmlNamespace)
  265.         {
  266.             // check table first
  267.             XmlEntry entry = (XmlEntry)_interopTypeToXmlElement[type];
  268.             if (entry != null) {
  269.                 xmlElement = entry.Name;
  270.                 xmlNamespace = entry.Namespace;
  271.                 return true;
  272.             }
  273.            
  274.             // check soap attribute
  275.             SoapTypeAttribute attr = (SoapTypeAttribute)InternalRemotingServices.GetCachedSoapAttribute(type);
  276.            
  277.             if (attr.IsInteropXmlElement()) {
  278.                 xmlElement = attr.XmlElementName;
  279.                 xmlNamespace = attr.XmlNamespace;
  280.                 return true;
  281.             }
  282.             else {
  283.                 xmlElement = null;
  284.                 xmlNamespace = null;
  285.                 return false;
  286.             }
  287.         }
  288.         // GetXmlElementForInteropType
  289.        
  290.         public static bool GetXmlTypeForInteropType(Type type, out string xmlType, out string xmlTypeNamespace)
  291.         {
  292.             // check table first
  293.             XmlEntry entry = (XmlEntry)_interopTypeToXmlType[type];
  294.             if (entry != null) {
  295.                 xmlType = entry.Name;
  296.                 xmlTypeNamespace = entry.Namespace;
  297.                 return true;
  298.             }
  299.            
  300.             // check soap attribute
  301.             SoapTypeAttribute attr = (SoapTypeAttribute)InternalRemotingServices.GetCachedSoapAttribute(type);
  302.            
  303.             if (attr.IsInteropXmlType()) {
  304.                 xmlType = attr.XmlTypeName;
  305.                 xmlTypeNamespace = attr.XmlTypeNamespace;
  306.                 return true;
  307.             }
  308.             else {
  309.                 xmlType = null;
  310.                 xmlTypeNamespace = null;
  311.                 return false;
  312.             }
  313.         }
  314.         // GetXmlTypeForInteropType
  315.        
  316.         public static string GetXmlNamespaceForMethodCall(MethodBase mb)
  317.         {
  318.             SoapMethodAttribute attr = (SoapMethodAttribute)InternalRemotingServices.GetCachedSoapAttribute(mb);
  319.             return attr.XmlNamespace;
  320.         }
  321.         // GetXmlNamespaceForMethodCall
  322.        
  323.         public static string GetXmlNamespaceForMethodResponse(MethodBase mb)
  324.         {
  325.             SoapMethodAttribute attr = (SoapMethodAttribute)InternalRemotingServices.GetCachedSoapAttribute(mb);
  326.             return attr.ResponseXmlNamespace;
  327.         }
  328.         // GetXmlNamespaceForMethodResponse
  329.        
  330.         public static void RegisterSoapActionForMethodBase(MethodBase mb)
  331.         {
  332.             SoapMethodAttribute attr = (SoapMethodAttribute)InternalRemotingServices.GetCachedSoapAttribute(mb);
  333.             if (attr.SoapActionExplicitySet)
  334.                 RegisterSoapActionForMethodBase(mb, attr.SoapAction);
  335.         }
  336.         // RegisterSoapActionForMethodBase
  337.        
  338.         public static void RegisterSoapActionForMethodBase(MethodBase mb, string soapAction)
  339.         {
  340.             if (soapAction != null) {
  341.                 _methodBaseToSoapAction[mb] = soapAction;
  342.                
  343.                 // get table of method bases
  344.                 ArrayList mbTable = (ArrayList)_soapActionToMethodBase[soapAction];
  345.                 if (mbTable == null) {
  346.                     lock (_soapActionToMethodBase) {
  347.                         mbTable = ArrayList.Synchronized(new ArrayList());
  348.                         _soapActionToMethodBase[soapAction] = mbTable;
  349.                     }
  350.                 }
  351.                 mbTable.Add(mb);
  352.             }
  353.         }
  354.         // RegisterSoapActionForMethodBase
  355.        
  356.        
  357.         public static string GetSoapActionFromMethodBase(MethodBase mb)
  358.         {
  359.             string soapAction = (string)_methodBaseToSoapAction[mb];
  360.            
  361.             if (soapAction == null) {
  362.                 SoapMethodAttribute attr = (SoapMethodAttribute)InternalRemotingServices.GetCachedSoapAttribute(mb);
  363.                 soapAction = attr.SoapAction;
  364.             }
  365.            
  366.             return soapAction;
  367.         }
  368.         // GetSoapActionFromMethodBase
  369.        
  370.         public static bool IsSoapActionValidForMethodBase(string soapAction, MethodBase mb)
  371.         {
  372.             // remove quotation marks if present
  373.             if ((soapAction[0] == '"') && (soapAction[soapAction.Length - 1] == '"'))
  374.                 soapAction = soapAction.Substring(1, soapAction.Length - 2);
  375.            
  376.             // compare this to the soapAction on the method base
  377.             SoapMethodAttribute attr = (SoapMethodAttribute)InternalRemotingServices.GetCachedSoapAttribute(mb);
  378.             if (String.CompareOrdinal(attr.SoapAction, soapAction) == 0)
  379.                 return true;
  380.            
  381.             // check to see if a soap action value is registered for this
  382.             string registeredSoapAction = (string)_methodBaseToSoapAction[mb];
  383.             if (registeredSoapAction != null) {
  384.                 if (String.CompareOrdinal(registeredSoapAction, soapAction) == 0)
  385.                     return true;
  386.             }
  387.            
  388.             // otherwise, parse SOAPAction and verify
  389.             string typeName;
  390.             string methodName;
  391.            
  392.             string[] parts = soapAction.Split(new char[1] {'#'});
  393.             if (parts.Length == 2) {
  394.                 bool assemblyIncluded;
  395.                 typeName = XmlNamespaceEncoder.GetTypeNameForSoapActionNamespace(parts[0], out assemblyIncluded);
  396.                 if (typeName == null)
  397.                     return false;
  398.                
  399.                 methodName = parts[1];
  400.                
  401.                 // compare to values of method base (FUTURE: Use more direct method for this)
  402.                 Type type = mb.DeclaringType;
  403.                 string actualTypeName = type.FullName;
  404.                 if (assemblyIncluded)
  405.                     actualTypeName += ", " + type.Module.Assembly.nGetSimpleName();
  406.                
  407.                 // return true if type and method name are the same
  408.                 return actualTypeName.Equals(typeName) && mb.Name.Equals(methodName);
  409.             }
  410.             else
  411.                 return false;
  412.         }
  413.         // IsSoapActionValidForMethodBase
  414.        
  415.         public static bool GetTypeAndMethodNameFromSoapAction(string soapAction, out string typeName, out string methodName)
  416.         {
  417.             // remove quotation marks if present
  418.             if ((soapAction[0] == '"') && (soapAction[soapAction.Length - 1] == '"'))
  419.                 soapAction = soapAction.Substring(1, soapAction.Length - 2);
  420.            
  421.             ArrayList mbTable = (ArrayList)_soapActionToMethodBase[soapAction];
  422.             if (mbTable != null) {
  423.                 // indicate that we can't resolve soap action to type and method name
  424.                 if (mbTable.Count > 1) {
  425.                     typeName = null;
  426.                     methodName = null;
  427.                     return false;
  428.                 }
  429.                
  430.                 MethodBase mb = (MethodBase)mbTable[0];
  431.                 if (mb != null) {
  432.                     Type type = mb.DeclaringType;
  433.                     typeName = type.FullName + ", " + type.Module.Assembly.nGetSimpleName();
  434.                     methodName = mb.Name;
  435.                     return true;
  436.                 }
  437.             }
  438.            
  439.            
  440.             string[] parts = soapAction.Split(new char[1] {'#'});
  441.             if (parts.Length == 2) {
  442.                 bool assemblyIncluded;
  443.                 typeName = XmlNamespaceEncoder.GetTypeNameForSoapActionNamespace(parts[0], out assemblyIncluded);
  444.                 if (typeName == null) {
  445.                     methodName = null;
  446.                     return false;
  447.                 }
  448.                
  449.                 methodName = parts[1];
  450.                 return true;
  451.             }
  452.             else {
  453.                 typeName = null;
  454.                 methodName = null;
  455.                 return false;
  456.             }
  457.            
  458.         }
  459.         // GetTypeAndMethodNameFromSoapAction
  460.        
  461.         //Future namespaces might be
  462.         // urn:a.clr.ms.com/assembly
  463.         // urn:n.clr.ms.com/typeNamespace
  464.         // urn:f.clr.ms.com/typeNamespace/assembly
  465.        
  466.         //namespaces are
  467.         // http://schemas.microsoft.com/clr/assem/assembly
  468.         // http://schemas.microsoft.com/clr/ns/typeNamespace
  469.         // http://schemas.microsoft.com/clr/nsassem/typeNamespace/assembly
  470.        
  471.         static internal string startNS = "http://schemas.microsoft.com/clr/";
  472.         static internal string assemblyNS = "http://schemas.microsoft.com/clr/assem/";
  473.         static internal string namespaceNS = "http://schemas.microsoft.com/clr/ns/";
  474.         static internal string fullNS = "http://schemas.microsoft.com/clr/nsassem/";
  475.        
  476.         public static string XmlNsForClrType {
  477.             get { return startNS; }
  478.         }
  479.        
  480.         public static string XmlNsForClrTypeWithAssembly {
  481.             get { return assemblyNS; }
  482.         }
  483.        
  484.         public static string XmlNsForClrTypeWithNs {
  485.             get { return namespaceNS; }
  486.         }
  487.        
  488.         public static string XmlNsForClrTypeWithNsAndAssembly {
  489.             get { return fullNS; }
  490.         }
  491.        
  492.         public static bool IsClrTypeNamespace(string namespaceString)
  493.         {
  494.             if (namespaceString.StartsWith(startNS, StringComparison.Ordinal))
  495.                 return true;
  496.             else
  497.                 return false;
  498.         }
  499.        
  500.         public static string CodeXmlNamespaceForClrTypeNamespace(string typeNamespace, string assemblyName)
  501.         {
  502.             StringBuilder sb = new StringBuilder(256);
  503.             if (IsNameNull(typeNamespace)) {
  504.                 if (IsNameNull(assemblyName))
  505.                     throw new ArgumentNullException("typeNamespace" + ",assemblyName");
  506.                 else {
  507.                     sb.Append(assemblyNS);
  508.                     UriEncode(assemblyName, sb);
  509.                 }
  510.             }
  511.             else if (IsNameNull(assemblyName)) {
  512.                 sb.Append(namespaceNS);
  513.                 sb.Append(typeNamespace);
  514.             }
  515.             else {
  516.                 sb.Append(fullNS);
  517.                 if (typeNamespace[0] == '.')
  518.                     sb.Append(typeNamespace.Substring(1));
  519.                 else
  520.                     sb.Append(typeNamespace);
  521.                 sb.Append('/');
  522.                 UriEncode(assemblyName, sb);
  523.             }
  524.             return sb.ToString();
  525.         }
  526.        
  527.         public static bool DecodeXmlNamespaceForClrTypeNamespace(string inNamespace, out string typeNamespace, out string assemblyName)
  528.         {
  529.             if (IsNameNull(inNamespace))
  530.                 throw new ArgumentNullException("inNamespace");
  531.            
  532.             assemblyName = null;
  533.             typeNamespace = "";
  534.            
  535.             if (inNamespace.StartsWith(assemblyNS, StringComparison.Ordinal))
  536.                 assemblyName = UriDecode(inNamespace.Substring(assemblyNS.Length));
  537.             else if (inNamespace.StartsWith(namespaceNS, StringComparison.Ordinal))
  538.                 typeNamespace = inNamespace.Substring(namespaceNS.Length);
  539.             else if (inNamespace.StartsWith(fullNS, StringComparison.Ordinal)) {
  540.                 int index = inNamespace.IndexOf("/", fullNS.Length);
  541.                 typeNamespace = inNamespace.Substring(fullNS.Length, index - fullNS.Length);
  542.                 assemblyName = UriDecode(inNamespace.Substring(index + 1));
  543.             }
  544.             else
  545.                 return false;
  546.            
  547.             return true;
  548.         }
  549.        
  550.         static internal void UriEncode(string value, StringBuilder sb)
  551.         {
  552.             if (value == null || value.Length == 0)
  553.                 return;
  554.            
  555.             for (int i = 0; i < value.Length; i++) {
  556.                 if (value[i] == ' ')
  557.                     sb.Append("%20");
  558.                 else if (value[i] == '=')
  559.                     sb.Append("%3D");
  560.                 else if (value[i] == ',')
  561.                     sb.Append("%2C");
  562.                 else
  563.                    
  564.                     sb.Append(value[i]);
  565.             }
  566.         }
  567.        
  568.         static internal string UriDecode(string value)
  569.         {
  570.             if (value == null || value.Length == 0)
  571.                 return value;
  572.            
  573.             StringBuilder sb = new StringBuilder();
  574.            
  575.             for (int i = 0; i < value.Length; i++) {
  576.                 if (value[i] == '%' && (value.Length - i >= 3)) {
  577.                     if (value[i + 1] == '2' && value[i + 2] == '0') {
  578.                         sb.Append(' ');
  579.                         i += 2;
  580.                     }
  581.                     else if (value[i + 1] == '3' && value[i + 2] == 'D') {
  582.                         sb.Append('=');
  583.                         i += 2;
  584.                     }
  585.                     else if (value[i + 1] == '2' && value[i + 2] == 'C') {
  586.                         sb.Append(',');
  587.                         i += 2;
  588.                     }
  589.                     else
  590.                        
  591.                         sb.Append(value[i]);
  592.                 }
  593.                 else
  594.                     sb.Append(value[i]);
  595.             }
  596.             return sb.ToString();
  597.         }
  598.        
  599.        
  600.        
  601.         private static bool IsNameNull(string name)
  602.         {
  603.             if (name == null || name.Length == 0)
  604.                 return true;
  605.             else
  606.                 return false;
  607.         }
  608.        
  609.     }
  610.     // class SoapServices
  611.     static internal class XmlNamespaceEncoder
  612.     {
  613.         // encode a type as an xml namespace (dynamic url is for types which have
  614.         // dynamically changing uri's, such as .SOAP files)
  615.         static internal string GetXmlNamespaceForType(Type type, string dynamicUrl)
  616.         {
  617.             string typeName = type.FullName;
  618.             Assembly assem = type.Module.Assembly;
  619.             StringBuilder sb = new StringBuilder(256);
  620.             Assembly systemAssembly = typeof(string).Module.Assembly;
  621.            
  622.             if (assem == systemAssembly) {
  623.                 sb.Append(SoapServices.namespaceNS);
  624.                 sb.Append(typeName);
  625.             }
  626.             else {
  627.                 sb.Append(SoapServices.fullNS);
  628.                 sb.Append(typeName);
  629.                 sb.Append('/');
  630.                 sb.Append(assem.nGetSimpleName());
  631.             }
  632.            
  633.             return sb.ToString();
  634.         }
  635.         // GetXmlNamespaceForType
  636.        
  637.         // encode a type namespace as an xml namespace (dynamic url is for types which have
  638.         // dynamically changing uri's, such as .SOAP files)
  639.         static internal string GetXmlNamespaceForTypeNamespace(Type type, string dynamicUrl)
  640.         {
  641.             string typeNamespace = type.Namespace;
  642.             Assembly assem = type.Module.Assembly;
  643.             StringBuilder sb = new StringBuilder(256);
  644.             Assembly systemAssembly = typeof(string).Module.Assembly;
  645.            
  646.             if (assem == systemAssembly) {
  647.                 sb.Append(SoapServices.namespaceNS);
  648.                 sb.Append(typeNamespace);
  649.             }
  650.             else {
  651.                 sb.Append(SoapServices.fullNS);
  652.                 sb.Append(typeNamespace);
  653.                 sb.Append('/');
  654.                 sb.Append(assem.nGetSimpleName());
  655.             }
  656.            
  657.             return sb.ToString();
  658.         }
  659.         // GetXmlNamespaceForTypeNamespace
  660.         // retrieve xml namespace that matches this type
  661.         static internal string GetTypeNameForSoapActionNamespace(string uri, out bool assemblyIncluded)
  662.         {
  663.             assemblyIncluded = false;
  664.             string urtNSprefix = SoapServices.fullNS;
  665.             string systemNSprefix = SoapServices.namespaceNS;
  666.            
  667.             if (uri.StartsWith(urtNSprefix, StringComparison.Ordinal)) {
  668.                 uri = uri.Substring(urtNSprefix.Length);
  669.                 // now contains type/assembly
  670.                 char[] sep = new char[] {'/'};
  671.                 string[] parts = uri.Split(sep);
  672.                 if (parts.Length != 2)
  673.                     return null;
  674.                 else {
  675.                     assemblyIncluded = true;
  676.                     return parts[0] + ", " + parts[1];
  677.                 }
  678.             }
  679.             if (uri.StartsWith(systemNSprefix, StringComparison.Ordinal)) {
  680.                 string assemName = typeof(string).Module.Assembly.nGetSimpleName();
  681.                 assemblyIncluded = true;
  682.                 return uri.Substring(systemNSprefix.Length) + ", " + assemName;
  683.                 // now contains type
  684.             }
  685.            
  686.             return null;
  687.         }
  688.         // GetTypeForXmlNamespace
  689.     }
  690.     // XmlNamespaceEncoder
  691. }
  692. // namespace

Developer Fusion