We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Runtime.Serialization.Formatters.Soap \ AssemblyInfo

SSCLI
  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. // Class: SoapWriter
  18. // Purpose: Emits XML for SOAP Formatter
  19. //
  20. // Date: June 10, 1999
  21. //
  22. //============================================================
  23. namespace System.Runtime.Serialization.Formatters.Soap
  24. {
  25.     using System;
  26.     using System.Runtime.Serialization.Formatters;
  27.     using System.Collections;
  28.     using System.Collections.Generic;
  29.     using System.Reflection;
  30.     using System.IO;
  31.     using System.Globalization;
  32.     using System.Text;
  33.     using System.Diagnostics;
  34.     using System.Runtime.Remoting;
  35.     using System.Runtime.Remoting.Metadata.W3cXsd2001;
  36.    
  37.     // This class provides persistence of a COM+ object graph to a stream using
  38.     // the SOAP XML-based format.
  39.    
  40.     internal sealed class SoapWriter
  41.     {
  42.         // the start of a soap message always looks like one of these
  43.        
  44.         // Encoding style not used because of difficulty in interop
  45.         // "SOAP-ENV:encodingStyle=\"http://schemas.microsoft.com/soap/encoding/clr/1.0 http://schemas.xmlsoap.org/soap/encoding/\"";
  46.        
  47.         private static string _soapStartStr = "<SOAP-ENV:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" " + "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" " + "xmlns:SOAP-ENC=\"http://schemas.xmlsoap.org/soap/encoding/\" " + "xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\" " + "xmlns:clr=\"http://schemas.microsoft.com/soap/encoding/clr/1.0\" " + "SOAP-ENV:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"";
  48.        
  49.         private static string _soapStart1999Str = "<SOAP-ENV:Envelope xmlns:xsi=\"http://www.w3.org/1999/XMLSchema-instance\" " + "xmlns:xsd=\"http://www.w3.org/1999/XMLSchema\" " + "xmlns:SOAP-ENC=\"http://schemas.xmlsoap.org/soap/encoding/\" " + "xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\" " + "SOAP-ENV:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"";
  50.        
  51.         private static string _soapStart2000Str = "<SOAP-ENV:Envelope xmlns:xsi=\"http://www.w3.org/2000/10/XMLSchema-instance\" " + "xmlns:xsd=\"http://www.w3.org/2000/10/XMLSchema\" " + "xmlns:SOAP-ENC=\"http://schemas.xmlsoap.org/soap/encoding/\" " + "xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\" " + "SOAP-ENV:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"";
  52.        
  53.         private static byte[] _soapStart = Encoding.UTF8.GetBytes(_soapStartStr);
  54.         private static byte[] _soapStart1999 = Encoding.UTF8.GetBytes(_soapStart1999Str);
  55.         private static byte[] _soapStart2000 = Encoding.UTF8.GetBytes(_soapStart2000Str);
  56.         public static Dictionary<char, string> encodingTable = new Dictionary<char, string>();
  57.        
  58.         static SoapWriter()
  59.         {
  60.             // special and
  61.             // RestrictedChar ::= [#x1-#x8] | [#xB-#xC] | [#xE-#x1F] | [#x7F-#x84] | [#x86-#x9F]
  62.             //
  63.             encodingTable.Add('&', "&#38;");
  64.             encodingTable.Add('"', "&#34;");
  65.             encodingTable.Add('\'', "&#39;");
  66.             encodingTable.Add('<', "&#60;");
  67.             encodingTable.Add('>', "&#62;");
  68.             encodingTable.Add(Char.MinValue, "&#0;");
  69.             encodingTable.Add('\v', "&#xB;");
  70.             encodingTable.Add('\f', "&#xC;");
  71.            
  72.             for (int i = 1; i < 9; i++)
  73.                 encodingTable.Add(((IConvertible)i).ToChar(NumberFormatInfo.InvariantInfo), "&#x" + i.ToString("X", CultureInfo.InvariantCulture) + ";");
  74.             for (int i = 14; i < 32; i++)
  75.                 encodingTable.Add(((IConvertible)i).ToChar(NumberFormatInfo.InvariantInfo), "&#x" + i.ToString("X", CultureInfo.InvariantCulture) + ";");
  76.             for (int i = 127; i < 133; i++)
  77.                 encodingTable.Add(((IConvertible)i).ToChar(NumberFormatInfo.InvariantInfo), "&#x" + i.ToString("X", CultureInfo.InvariantCulture) + ";");
  78.             for (int i = 134; i < 160; i++)
  79.                 encodingTable.Add(((IConvertible)i).ToChar(NumberFormatInfo.InvariantInfo), "&#x" + i.ToString("X", CultureInfo.InvariantCulture) + ";");
  80.            
  81.         }
  82.        
  83.         private AttributeList attrList = new AttributeList();
  84.         private AttributeList attrValueList = new AttributeList();
  85.        
  86.         const int StringBuilderSize = 1024;
  87.        
  88.        
  89.         // used for emitting into the text stream
  90.         private int lineIndent = 4;
  91.         private int instanceIndent = 1;
  92.        
  93.         // used to escape strings. cache it as a member variable because its used frequently.
  94.         private StringBuilder stringBuffer = new StringBuilder(120);
  95.         private StringBuilder sb = new StringBuilder(120);
  96.        
  97.         private int topId;
  98.         private int headerId;
  99.        
  100.         //Assembly information
  101.         Hashtable assemblyInfos = new Hashtable(10);
  102.         StreamWriter writer;
  103.         Stream stream;
  104.        
  105.         // Support for combining assembly names with namespaces
  106.         Hashtable typeNameToDottedInfoTable = null;
  107.         Hashtable dottedAssemToAssemIdTable = null;
  108.         Hashtable assemblyInfoUsed = new Hashtable(10);
  109.         // for each xml element keeps track of unique types used
  110.         int dottedAssemId = 1;
  111.        
  112.         internal bool isUsedEnc = false;
  113.         XsdVersion xsdVersion = XsdVersion.V2001;
  114.        
  115.         internal struct DottedInfo
  116.         {
  117.             internal string dottedAssemblyName;
  118.             internal string name;
  119.             internal string nameSpace;
  120.             internal int assemId;
  121.         }
  122.        
  123.        
  124.         internal SoapWriter(Stream stream)
  125.         {
  126.             this.stream = stream;
  127.             UTF8Encoding enc = new UTF8Encoding(false, true);
  128.             this.writer = new StreamWriter(stream, enc, StringBuilderSize);
  129.             // Need to combine the type namespace with the assembly name for an element
  130.             typeNameToDottedInfoTable = new Hashtable(20);
  131.             dottedAssemToAssemIdTable = new Hashtable(20);
  132.         }
  133.        
  134.        
  135.         // Emit spaces for indentation
  136.        
  137.         [Conditional("_DEBUG")]
  138.         private void EmitIndent(int count)
  139.         {
  140.             while (--count >= 0) {
  141.                 for (int i = 0; i < lineIndent; i++) {
  142.                     TraceSoap(" ");
  143.                     writer.Write(' ');
  144.                 }
  145.             }
  146.         }
  147.        
  148.         // Emit a line
  149.         [Conditional("_DEBUG")]
  150.         private void EmitLine(int indent, string value)
  151.         {
  152.             InternalST.Soap(this, "EmitLine: ", value);
  153.             EmitIndent(indent);
  154.             writer.Write(value);
  155.             EmitLine();
  156.         }
  157.        
  158.         // Emit a blank line
  159.         private void EmitLine()
  160.         {
  161.             WriteTraceSoap();
  162.             writer.Write("\r\n");
  163.         }
  164.        
  165.         // Add xml escape characters to the string value, if necessary.
  166.        
  167.         private string Escape(string value)
  168.         {
  169.             stringBuffer.Length = 0;
  170.             foreach (char c in value) {
  171.                 if (encodingTable.ContainsKey(c))
  172.                     stringBuffer.Append(encodingTable[c]);
  173.                 else
  174.                     stringBuffer.Append(c);
  175.             }
  176.            
  177.             string returnValue = null;
  178.            
  179.             if (stringBuffer.Length > 0)
  180.                 returnValue = stringBuffer.ToString();
  181.             else
  182.                 returnValue = value;
  183.            
  184.             return returnValue;
  185.         }
  186.        
  187.        
  188.         // Add escape character for a $ and . in an element name
  189.        
  190.        
  191.         NameCache nameCache = new NameCache();
  192.         private string NameEscape(string name)
  193.         {
  194.             string value = (string)nameCache.GetCachedValue(name);
  195.             if (value == null) {
  196.                 value = System.Xml.XmlConvert.EncodeName(name);
  197.                 nameCache.SetCachedValue(value);
  198.             }
  199.             return value;
  200.         }
  201.        
  202.        
  203.         // Initial writer
  204.         internal void Reset()
  205.         {
  206.             writer = null;
  207.             stringBuffer = null;
  208.         }
  209.        
  210.         internal void InternalWrite(string s)
  211.         {
  212.             TraceSoap(s);
  213.             writer.Write(s);
  214.         }
  215.        
  216.         StringBuilder traceBuffer = null;
  217.         [Conditional("_LOGGING")]
  218.         internal void TraceSoap(string s)
  219.         {
  220.             if (traceBuffer == null)
  221.                 traceBuffer = new StringBuilder();
  222.             traceBuffer.Append(s);
  223.         }
  224.        
  225.         [Conditional("_LOGGING")]
  226.         internal void WriteTraceSoap()
  227.         {
  228.             InternalST.InfoSoap(traceBuffer.ToString());
  229.             traceBuffer.Length = 0;
  230.         }
  231.        
  232.         // Write an XML element
  233.         internal void Write(InternalElementTypeE use, string name, AttributeList attrList, string value, bool isNameEscape, bool isValueEscape)
  234.         {
  235.             InternalST.Soap(this, "Write ", ((Enum)use).ToString(), ", name " + name + ", value ", value, " isNameEscape ", isNameEscape, " isValueEscape ", isValueEscape);
  236.            
  237.             string elementName = name;
  238.             if (isNameEscape)
  239.                 elementName = NameEscape(name);
  240.            
  241.             if (use == InternalElementTypeE.ObjectEnd)
  242.                 instanceIndent--;
  243.            
  244.             EmitIndent(instanceIndent);
  245.            
  246.             InternalWrite("<");
  247.             if (use == InternalElementTypeE.ObjectEnd)
  248.                 InternalWrite("/");
  249.             InternalWrite(elementName);
  250.            
  251.             WriteAttributeList(attrList);
  252.            
  253.             switch (use) {
  254.                 case InternalElementTypeE.ObjectBegin:
  255.                     InternalWrite(">");
  256.                     instanceIndent++;
  257.                     break;
  258.                 case InternalElementTypeE.ObjectEnd:
  259.                     InternalWrite(">");
  260.                     break;
  261.                 case InternalElementTypeE.Member:
  262.                     if (value == null)
  263.                         InternalWrite("/>");
  264.                     else {
  265.                         InternalWrite(">");
  266.                         if (isValueEscape)
  267.                             InternalWrite(Escape(value));
  268.                         else
  269.                             InternalWrite(value);
  270.                         InternalWrite("</");
  271.                         InternalWrite(elementName);
  272.                         InternalWrite(">");
  273.                     }
  275.                     break;
  276.                 default:
  277.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_UseCode"), ((Enum)use).ToString()));
  278.                     break;
  279.             }
  280.             EmitLine();
  281.         }
  282.        
  283.        
  284.         void WriteAttributeList(AttributeList attrList)
  285.         {
  286.             for (int i = 0; i < attrList.Count; i++) {
  287.                 string aName;
  288.                 string aValue;
  289.                 attrList.Get(i, out aName, out aValue);
  290.                 InternalWrite(" ");
  291.                 InternalWrite(aName);
  292.                 InternalWrite("=");
  293.                 InternalWrite("\"");
  294.                 //InternalWrite(Escape(aValue));
  295.                 InternalWrite(aValue);
  296.                 InternalWrite("\"");
  297.             }
  298.         }
  299.         // WriteAttributeList
  300.        
  301.         // Begin a new XML stream
  302.         internal void WriteBegin()
  303.         {
  304.             InternalST.InfoSoap("******************** Start Serialized Stream *****************");
  305.         }
  306.        
  307.         // Finish an XML stream
  308.         internal void WriteEnd()
  309.         {
  310.             writer.Flush();
  311.             InternalST.InfoSoap("******************** End Serialized Stream *******************");
  312.             Reset();
  313.         }
  314.        
  315.         internal void WriteXsdVersion(XsdVersion xsdVersion)
  316.         {
  317.             this.xsdVersion = xsdVersion;
  318.         }
  319.        
  320.         // Methods to write XML Serialization Record onto the stream,
  321.         internal void WriteObjectEnd(NameInfo memberNameInfo, NameInfo typeNameInfo)
  322.         {
  323.             //nameInfo.Dump("WriteObjectEnd nameInfo");
  324.            
  325.             attrList.Clear();
  326.             Write(InternalElementTypeE.ObjectEnd, MemberElementName(memberNameInfo, typeNameInfo), attrList, null, true, false);
  327.             assemblyInfoUsed.Clear();
  328.         }
  329.        
  330.         internal void WriteSerializationHeaderEnd()
  331.         {
  332.             attrList.Clear();
  333.             Write(InternalElementTypeE.ObjectEnd, "SOAP-ENV:Body", attrList, null, false, false);
  334.             Write(InternalElementTypeE.ObjectEnd, "SOAP-ENV:Envelope", attrList, null, false, false);
  335.             writer.Flush();
  336.         }
  337.        
  338.         internal void WriteHeaderArrayEnd()
  339.         {
  340.             //attrList.Clear();
  341.             //Write(InternalElementTypeE.ObjectEnd, "SOAP:HeaderRoots",attrList, null);
  342.         }
  343.        
  344.         internal void WriteHeaderSectionEnd()
  345.         {
  346.             attrList.Clear();
  347.             Write(InternalElementTypeE.ObjectEnd, "SOAP-ENV:Header", attrList, null, false, false);
  348.         }
  349.        
  350.        
  351.         internal void WriteSerializationHeader(int topId, int headerId, int minorVersion, int majorVersion)
  352.         {
  353.             InternalST.Soap(this, "WriteSerializationHeader");
  354.             this.topId = topId;
  355.             this.headerId = headerId;
  356.            
  357.             // write start of header directly to stream
  358.             switch (xsdVersion) {
  359.                 case XsdVersion.V1999:
  360.                     InternalST.InfoSoap(_soapStart1999Str, ">");
  361.                     stream.Write(_soapStart1999, 0, _soapStart1999.Length);
  362.                     break;
  363.                 case XsdVersion.V2000:
  364.                     InternalST.InfoSoap(_soapStart2000Str, ">");
  365.                     stream.Write(_soapStart1999, 0, _soapStart2000.Length);
  366.                     break;
  367.                 case XsdVersion.V2001:
  368.                     InternalST.InfoSoap(_soapStartStr, ">");
  369.                     stream.Write(_soapStart, 0, _soapStart.Length);
  370.                     break;
  371.             }
  372.             writer.Write(">\r\n");
  373.         }
  374.         // InternalWriteSerializationHeader
  375.        
  376.         internal void WriteObject(NameInfo nameInfo, NameInfo typeNameInfo, int numMembers, string[] memberNames, Type[] memberTypes, WriteObjectInfo[] objectInfos)
  377.         {
  378.             nameInfo.Dump("WriteObject nameInfo");
  379.             typeNameInfo.Dump("WriteObject typeNameInfo");
  380.            
  381.             int objectId = (int)nameInfo.NIobjectId;
  382.             attrList.Clear();
  383.             if (objectId == topId)
  384.                 Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Body", attrList, null, false, false);
  385.            
  386.             // Only write the objectId in the top record if the header has been written or
  387.             if (objectId > 0)
  388.                 attrList.Put("id", IdToString((int)nameInfo.NIobjectId));
  389.             // Types when Object is embedded member and types needed
  390.             if (((nameInfo.NItransmitTypeOnObject || nameInfo.NItransmitTypeOnMember) && (nameInfo.NIisNestedObject || nameInfo.NIisArrayItem)))
  391.                 attrList.Put("xsi:type", TypeNameTagResolver(typeNameInfo, true));
  392.             if (nameInfo.NIisMustUnderstand) {
  393.                 attrList.Put("SOAP-ENV:mustUnderstand", "1");
  394.                 isUsedEnc = true;
  395.             }
  396.             if (nameInfo.NIisHeader) {
  397.                 attrList.Put("xmlns:" + nameInfo.NIheaderPrefix, nameInfo.NInamespace);
  398.                 attrList.Put("SOAP-ENC:root", "1");
  399.             }
  400.            
  401.             if (attrValueList.Count > 0) {
  402.                 // Combine the values from the XmlAttributes with the object attributes
  403.                 for (int i = 0; i < attrValueList.Count; i++) {
  404.                     string aName;
  405.                     string aValue;
  406.                     attrValueList.Get(i, out aName, out aValue);
  407.                     attrList.Put(aName, aValue);
  408.                 }
  409.                 attrValueList.Clear();
  410.             }
  411.            
  412.             string memberName = MemberElementName(nameInfo, typeNameInfo);
  413.             NamespaceAttribute();
  414.             Write(InternalElementTypeE.ObjectBegin, memberName, attrList, null, true, false);
  415.         }
  416.        
  417.         internal void WriteAttributeValue(NameInfo memberNameInfo, NameInfo typeNameInfo, object value)
  418.         {
  419.             // Called when the XmlAttribute is specified on a member
  420.             InternalST.Soap(this, "WriteAttributeValues ", value);
  421.             string stringValue = null;
  422.             if (value is string)
  423.                 stringValue = (string)value;
  424.             else
  425.                 stringValue = Converter.SoapToString(value, typeNameInfo.NIprimitiveTypeEnum);
  426.             attrValueList.Put(MemberElementName(memberNameInfo, typeNameInfo), stringValue);
  427.         }
  428.        
  429.         internal void WriteObjectString(NameInfo nameInfo, string value)
  430.         {
  431.             InternalST.Soap(this, "WriteObjectString value ", value);
  432.             nameInfo.Dump("WriteObjectString nameInfo");
  433.             attrList.Clear();
  434.             if (nameInfo.NIobjectId == topId)
  435.                 Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Body", attrList, null, false, false);
  436.            
  437.            
  438.             if (nameInfo.NIobjectId > 0) {
  439.                 attrList.Put("id", IdToString((int)nameInfo.NIobjectId));
  440.             }
  441.            
  442.             string stringType = null;
  443.             if (nameInfo.NIobjectId > 0) {
  444.                 stringType = "SOAP-ENC:string";
  445.                 isUsedEnc = true;
  446.             }
  447.             else
  448.                 stringType = "xsd:string";
  449.            
  450.             Write(InternalElementTypeE.Member, stringType, attrList, value, false, Converter.IsEscaped(nameInfo.NIprimitiveTypeEnum));
  451.         }
  452.        
  453.         internal void WriteTopPrimitive(NameInfo nameInfo, object value)
  454.         {
  455.             nameInfo.Dump("WriteMember memberNameInfo");
  456.            
  457.             attrList.Clear();
  458.            
  459.             Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Body", attrList, null, false, false);
  460.            
  461.             if (nameInfo.NIobjectId > 0) {
  462.                 attrList.Put("id", IdToString((int)nameInfo.NIobjectId));
  463.             }
  464.            
  465.             string stringValue = null;
  466.             if (value is string)
  467.                 stringValue = (string)value;
  468.             else
  469.                 stringValue = Converter.SoapToString(value, nameInfo.NIprimitiveTypeEnum);
  470.            
  471.             Write(InternalElementTypeE.Member, "xsd:" + (Converter.ToXmlDataType(nameInfo.NIprimitiveTypeEnum)), attrList, stringValue, true, false);
  472.         }
  473.        
  474.        
  475.        
  476.         internal void WriteObjectByteArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int length, int lowerBound, byte[] byteA)
  477.         {
  478.             memberNameInfo.Dump("WriteObjectByteArray memberNameInfo");
  479.             arrayNameInfo.Dump("WriteObjectByteArray arrayNameInfo");
  480.             arrayElemTypeNameInfo.Dump("WriteObjectByteArray arrayElemTypeNameInfo");
  481.            
  482.             string byteString = Convert.ToBase64String(byteA);
  483.             attrList.Clear();
  484.             if (memberNameInfo.NIobjectId == topId)
  485.                 Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Body", attrList, null, false, false);
  486.             if (arrayNameInfo.NIobjectId > 1)
  487.                 attrList.Put("id", IdToString((int)arrayNameInfo.NIobjectId));
  488.             attrList.Put("xsi:type", "SOAP-ENC:base64");
  489.             isUsedEnc = true;
  490.             string memberName = MemberElementName(memberNameInfo, null);
  491.             NamespaceAttribute();
  492.             Write(InternalElementTypeE.Member, memberName, attrList, byteString, true, false);
  493.         }
  494.        
  495.        
  496.         internal void WriteMember(NameInfo memberNameInfo, NameInfo typeNameInfo, object value)
  497.         {
  498.             memberNameInfo.Dump("WriteMember memberNameInfo");
  499.             typeNameInfo.Dump("WriteMember typeNameInfo");
  500.            
  501.             attrList.Clear();
  502.             if ((typeNameInfo.NItype != null) && (memberNameInfo.NItransmitTypeOnMember || (memberNameInfo.NItransmitTypeOnObject && !memberNameInfo.NIisArrayItem))) {
  503.                 attrList.Put("xsi:type", TypeNameTagResolver(typeNameInfo, true));
  504.             }
  505.            
  506.             string stringValue = null;
  507.             if (value != null) {
  508.                 if (typeNameInfo.NIprimitiveTypeEnum == InternalPrimitiveTypeE.QName) {
  509.                     SoapQName soapQName = (SoapQName)value;
  510.                     if (soapQName.Key == null || soapQName.Key.Length == 0)
  511.                         attrList.Put("xmlns", "");
  512.                     else
  513.                         attrList.Put("xmlns:" + soapQName.Key, soapQName.Namespace);
  514.                    
  515.                     stringValue = soapQName.ToString();
  516.                 }
  517.                 else {
  518.                    
  519.                     if (value is string)
  520.                         stringValue = (string)value;
  521.                     else
  522.                         stringValue = Converter.SoapToString(value, typeNameInfo.NIprimitiveTypeEnum);
  523.                 }
  524.             }
  525.            
  526.             NameInfo tempNameInfo = null;
  527.            
  528.             // If XmlElement attribute was defined on member, then an alternate member name has been specifed
  529.             if (typeNameInfo.NInameSpaceEnum == InternalNameSpaceE.Interop)
  530.                 tempNameInfo = typeNameInfo;
  531.            
  532.             string memberName = MemberElementName(memberNameInfo, tempNameInfo);
  533.             NamespaceAttribute();
  534.             Write(InternalElementTypeE.Member, memberName, attrList, stringValue, true, Converter.IsEscaped(typeNameInfo.NIprimitiveTypeEnum));
  535.         }
  536.        
  537.        
  538.         //internal void WriteNullMember(String memberName, Type memberType, Boolean isTyped, Type objType)
  539.         internal void WriteNullMember(NameInfo memberNameInfo, NameInfo typeNameInfo)
  540.         {
  541.             memberNameInfo.Dump("WriteNullMember memberNameInfo");
  542.             typeNameInfo.Dump("WriteNullMember typeNameInfo");
  543.            
  544.             attrList.Clear();
  545.             if ((typeNameInfo.NItype != null) && (memberNameInfo.NItransmitTypeOnMember || (memberNameInfo.NItransmitTypeOnObject && !memberNameInfo.NIisArrayItem))) {
  546.                 attrList.Put("xsi:type", TypeNameTagResolver(typeNameInfo, true));
  547.             }
  548.             attrList.Put("xsi:null", "1");
  549.            
  550.             /*
  551. NameInfo tempNameInfo = null;
  553. // If XmlElement attribute was defined on member, then an alternate member name has been specifed
  554. if (typeNameInfo.NInameSpaceEnum == InternalNameSpaceE.Interop)
  555. tempNameInfo = typeNameInfo;
  556.                 */           
  557.            
  558. string memberName = MemberElementName(memberNameInfo, null);
  559.             NamespaceAttribute();
  560.             Write(InternalElementTypeE.Member, memberName, attrList, null, true, false);
  561.         }
  562.        
  563.        
  564.         internal void WriteMemberObjectRef(NameInfo memberNameInfo, NameInfo typeNameInfo, int idRef)
  565.         {
  566.             memberNameInfo.Dump("WriteMemberObjectRef memberNameInfo");
  567.             attrList.Clear();
  568.             attrList.Put("href", RefToString(idRef));
  569.             NameInfo tempNameInfo = null;
  570.            
  571.             // If XmlElement attribute was defined on member, then an alternate member name has been specifed
  572.             if (typeNameInfo.NInameSpaceEnum == InternalNameSpaceE.Interop)
  573.                 tempNameInfo = typeNameInfo;
  574.             string memberName = MemberElementName(memberNameInfo, tempNameInfo);
  575.             NamespaceAttribute();
  576.             Write(InternalElementTypeE.Member, memberName, attrList, null, true, false);
  577.         }
  578.        
  579.         internal void WriteMemberNested(NameInfo memberNameInfo)
  580.         {
  581.            
  582.         }
  583.        
  584.         //internal void WriteMemberString(String memberName, int objectId, String value, Boolean isTyped, Type objType)
  585.         internal void WriteMemberString(NameInfo memberNameInfo, NameInfo typeNameInfo, string value)
  586.         {
  587.             memberNameInfo.Dump("WriteMemberString memberNameInfo");
  588.             typeNameInfo.Dump("WriteMemberString typeNameInfo");
  589.            
  590.             InternalST.Soap(this, "WriteMemberString memberName ", memberNameInfo.NIname, " objectId ", typeNameInfo.NIobjectId, " value ", value);
  591.             int objectId = (int)typeNameInfo.NIobjectId;
  592.             attrList.Clear();
  593.             if (objectId > 0)
  594.                 attrList.Put("id", IdToString((int)typeNameInfo.NIobjectId));
  595.             if ((typeNameInfo.NItype != null) && (memberNameInfo.NItransmitTypeOnMember || (memberNameInfo.NItransmitTypeOnObject && !memberNameInfo.NIisArrayItem))) {
  596.                 if (typeNameInfo.NIobjectId > 0) {
  597.                     attrList.Put("xsi:type", "SOAP-ENC:string");
  598.                     isUsedEnc = true;
  599.                 }
  600.                 else
  601.                     attrList.Put("xsi:type", "xsd:string");
  602.             }
  603.            
  604.             NameInfo tempNameInfo = null;
  605.            
  606.             // If XmlElement attribute was defined on member, then an alternate member name has been specifed
  607.             if (typeNameInfo.NInameSpaceEnum == InternalNameSpaceE.Interop)
  608.                 tempNameInfo = typeNameInfo;
  609.            
  610.             string memberName = MemberElementName(memberNameInfo, tempNameInfo);
  611.             NamespaceAttribute();
  612.             Write(InternalElementTypeE.Member, memberName, attrList, value, true, Converter.IsEscaped(typeNameInfo.NIprimitiveTypeEnum));
  613.         }
  614.        
  615.         internal void WriteSingleArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int length, int lowerBound, Array array)
  616.         {
  617.             memberNameInfo.Dump("WriteSingleArray memberNameInfo");
  618.             arrayNameInfo.Dump("WriteSingleArray arrayNameInfo");
  619.             arrayElemTypeNameInfo.Dump("WriteSingleArray arrayElemTypeNameInfo");
  620.            
  621.             attrList.Clear();
  622.             if (memberNameInfo.NIobjectId == topId)
  623.                 Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Body", attrList, null, false, false);
  624.             if (arrayNameInfo.NIobjectId > 1)
  625.                 attrList.Put("id", IdToString((int)arrayNameInfo.NIobjectId));
  626.             arrayElemTypeNameInfo.NIitemName = NameTagResolver(arrayElemTypeNameInfo, true);
  627.             attrList.Put("SOAP-ENC:arrayType", NameTagResolver(arrayNameInfo, true, memberNameInfo.NIname));
  628.             isUsedEnc = true;
  629.             if (lowerBound != 0)
  630.                 attrList.Put("SOAP-ENC:offset", "[" + lowerBound + "]");
  631.             string memberName = MemberElementName(memberNameInfo, null);
  632.             NamespaceAttribute();
  633.             Write(InternalElementTypeE.ObjectBegin, memberName, attrList, null, false, false);
  634.         }
  635.        
  636.         internal void WriteJaggedArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int length, int lowerBound)
  637.         {
  638.             memberNameInfo.Dump("WriteJaggedArray memberNameInfo");
  639.             arrayNameInfo.Dump("WriteJaggedArray arrayNameInfo");
  640.             arrayElemTypeNameInfo.Dump("WriteJaggedArray arrayElemTypeNameInfo");
  641.            
  642.             attrList.Clear();
  643.             if (memberNameInfo.NIobjectId == topId)
  644.                 Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Body", attrList, null, false, false);
  645.             if (arrayNameInfo.NIobjectId > 1)
  646.                 attrList.Put("id", IdToString((int)arrayNameInfo.NIobjectId));
  647.             arrayElemTypeNameInfo.NIitemName = "SOAP-ENC:Array";
  648.             isUsedEnc = true;
  649.             attrList.Put("SOAP-ENC:arrayType", TypeArrayNameTagResolver(memberNameInfo, arrayNameInfo, true));
  650.             if (lowerBound != 0)
  651.                 attrList.Put("SOAP-ENC:offset", "[" + lowerBound + "]");
  652.             string memberName = MemberElementName(memberNameInfo, null);
  653.             NamespaceAttribute();
  654.             Write(InternalElementTypeE.ObjectBegin, memberName, attrList, null, false, false);
  655.         }
  656.        
  657.        
  658.         private StringBuilder sbOffset = new StringBuilder(10);
  659.        
  660.         internal void WriteRectangleArray(NameInfo memberNameInfo, NameInfo arrayNameInfo, WriteObjectInfo objectInfo, NameInfo arrayElemTypeNameInfo, int rank, int[] lengthA, int[] lowerBoundA)
  661.         {
  662.             memberNameInfo.Dump("WriteRectangleArray memberNameInfo");
  663.             arrayNameInfo.Dump("WriteRectangleArray arrayNameInfo");
  664.             arrayElemTypeNameInfo.Dump("WriteRectangleArray arrayElemTypeNameInfo");
  665.            
  666.             sbOffset.Length = 0;
  667.             sbOffset.Append("[");
  668.             bool isZero = true;
  669.             for (int i = 0; i < rank; i++) {
  670.                 if (lowerBoundA[i] != 0)
  671.                     isZero = false;
  672.                 if (i > 0)
  673.                     sbOffset.Append(",");
  674.                 sbOffset.Append(lowerBoundA[i]);
  675.             }
  676.             sbOffset.Append("]");
  677.            
  678.             attrList.Clear();
  679.             if (memberNameInfo.NIobjectId == topId)
  680.                 Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Body", attrList, null, false, false);
  681.             if (arrayNameInfo.NIobjectId > 1)
  682.                 attrList.Put("id", IdToString((int)arrayNameInfo.NIobjectId));
  683.             arrayElemTypeNameInfo.NIitemName = NameTagResolver(arrayElemTypeNameInfo, true);
  684.             attrList.Put("SOAP-ENC:arrayType", TypeArrayNameTagResolver(memberNameInfo, arrayNameInfo, true));
  685.             isUsedEnc = true;
  686.             if (!isZero)
  687.                 attrList.Put("SOAP-ENC:offset", sbOffset.ToString());
  688.             string memberName = MemberElementName(memberNameInfo, null);
  689.             NamespaceAttribute();
  690.             Write(InternalElementTypeE.ObjectBegin, memberName, attrList, null, false, false);
  691.         }
  692.        
  693.         //internal void WriteItem(Variant value, InternalPrimitiveTypeE code, Boolean isTyped, Type objType)
  694.         internal void WriteItem(NameInfo itemNameInfo, NameInfo typeNameInfo, object value)
  695.         {
  696.             itemNameInfo.Dump("WriteItem itemNameInfo");
  697.             typeNameInfo.Dump("WriteItem typeNameInfo");
  698.            
  699.             attrList.Clear();
  700.             if (itemNameInfo.NItransmitTypeOnMember) {
  701.                 attrList.Put("xsi:type", TypeNameTagResolver(typeNameInfo, true));
  702.             }
  703.            
  704.             string stringValue = null;
  705.            
  706.             if (typeNameInfo.NIprimitiveTypeEnum == InternalPrimitiveTypeE.QName) {
  707.                 if (value != null) {
  708.                     SoapQName soapQName = (SoapQName)value;
  709.                     if (soapQName.Key == null || soapQName.Key.Length == 0)
  710.                         attrList.Put("xmlns", "");
  711.                     else
  712.                         attrList.Put("xmlns:" + soapQName.Key, soapQName.Namespace);
  713.                    
  714.                     stringValue = soapQName.ToString();
  715.                 }
  716.             }
  717.             else
  718.                 stringValue = Converter.SoapToString(value, typeNameInfo.NIprimitiveTypeEnum);
  719.            
  720.            
  721.             NamespaceAttribute();
  722.             Write(InternalElementTypeE.Member, "item", attrList, stringValue, false, (typeNameInfo.NIprimitiveTypeEnum == InternalPrimitiveTypeE.Invalid));
  723.         }
  724.        
  725.         internal void WriteNullItem(NameInfo memberNameInfo, NameInfo typeNameInfo)
  726.         {
  727.             memberNameInfo.Dump("WriteNullItem memberNameInfo");
  728.             typeNameInfo.Dump("WriteNullItem typeNameInfo");
  729.            
  730.             string typeName = typeNameInfo.NIname;
  731.             attrList.Clear();
  732.             if (typeNameInfo.NItransmitTypeOnMember && !((typeName.Equals("System.Object")) || (typeName.Equals("Object")) || (typeName.Equals("System.Empty") || (typeName.Equals("ur-type")) || (typeName.Equals("anyType")))))
  733.                 attrList.Put("xsi:type", TypeNameTagResolver(typeNameInfo, true));
  734.            
  735.             attrList.Put("xsi:null", "1");
  736.             NamespaceAttribute();
  737.             Write(InternalElementTypeE.Member, "item", attrList, null, false, false);
  738.         }
  739.        
  740.        
  741.         //internal void WriteItemObjectRef(int idRef)
  742.         internal void WriteItemObjectRef(NameInfo itemNameInfo, int arrayId)
  743.         {
  744.             itemNameInfo.Dump("WriteItemObjectRef itemNameInfo");
  745.             attrList.Clear();
  746.             attrList.Put("href", RefToString(arrayId));
  747.             Write(InternalElementTypeE.Member, "item", attrList, null, false, false);
  748.         }
  749.        
  750.         // Type of string or primitive type which has already been converted to string
  751.         internal void WriteItemString(NameInfo itemNameInfo, NameInfo typeNameInfo, string value)
  752.         {
  753.             itemNameInfo.Dump("WriteItemString itemNameInfo");
  754.             typeNameInfo.Dump("WriteItemString typeNameInfo");
  755.            
  756.             attrList.Clear();
  757.            
  758.             if (typeNameInfo.NIobjectId > 0) {
  759.                 attrList.Put("id", IdToString((int)typeNameInfo.NIobjectId));
  760.             }
  761.             if (itemNameInfo.NItransmitTypeOnMember) {
  762.                 if (typeNameInfo.NItype == SoapUtil.typeofString) {
  763.                     if (typeNameInfo.NIobjectId > 0) {
  764.                         attrList.Put("xsi:type", "SOAP-ENC:string");
  765.                         isUsedEnc = true;
  766.                     }
  767.                     else
  768.                         attrList.Put("xsi:type", "xsd:string");
  769.                 }
  770.                 else
  771.                     attrList.Put("xsi:type", TypeNameTagResolver(typeNameInfo, true));
  772.             }
  773.            
  774.             NamespaceAttribute();
  775.             Write(InternalElementTypeE.Member, "item", attrList, value, false, Converter.IsEscaped(typeNameInfo.NIprimitiveTypeEnum));
  776.         }
  777.        
  778.         internal void WriteHeader(int objectId, int numMembers)
  779.         {
  780.             attrList.Clear();
  781.             Write(InternalElementTypeE.ObjectBegin, "SOAP-ENV:Header", attrList, null, false, false);
  782.             //Write(InternalElementTypeE.ObjectBegin, "SOAP:HeaderRoots",attrList, null);
  783.         }
  784.        
  785.        
  786.         //internal void WriteHeaderEntry(String name, Boolean isMustUnderstand, InternalPrimitiveTypeE code, Variant value)
  787.         internal void WriteHeaderEntry(NameInfo nameInfo, NameInfo typeNameInfo, object value)
  788.         {
  789.             nameInfo.Dump("WriteHeaderEntry nameInfo");
  790.             if (typeNameInfo != null) {
  791.                 typeNameInfo.Dump("WriteHeaderEntry typeNameInfo");
  792.             }
  793.            
  794.             attrList.Clear();
  795.             if (value == null)
  796.                 attrList.Put("xsi:null", "1");
  797.             else
  798.                 attrList.Put("xsi:type", TypeNameTagResolver(typeNameInfo, true));
  799.             if (nameInfo.NIisMustUnderstand) {
  800.                 attrList.Put("SOAP-ENV:mustUnderstand", "1");
  801.                 isUsedEnc = true;
  802.             }
  803.            
  804.             attrList.Put("xmlns:" + nameInfo.NIheaderPrefix, nameInfo.NInamespace);
  805.             attrList.Put("SOAP-ENC:root", "1");
  806.             string stringValue = null;
  807.            
  808.             if (value != null) {
  809.                 if (typeNameInfo != null && typeNameInfo.NIprimitiveTypeEnum == InternalPrimitiveTypeE.QName) {
  810.                     SoapQName soapQName = (SoapQName)value;
  811.                     if (soapQName.Key == null || soapQName.Key.Length == 0)
  812.                         attrList.Put("xmlns", "");
  813.                     else
  814.                         attrList.Put("xmlns:" + soapQName.Key, soapQName.Namespace);
  815.                    
  816.                     stringValue = soapQName.ToString();
  817.                 }
  818.                 else
  819.                     stringValue = Converter.SoapToString(value, typeNameInfo.NIprimitiveTypeEnum);
  820.             }
  821.            
  822.             NamespaceAttribute();
  823.             Write(InternalElementTypeE.Member, nameInfo.NIheaderPrefix + ":" + nameInfo.NIname, attrList, stringValue, true, true);
  824.         }
  825.        
  826.         //internal void WriteHeaderObjectRef(String name, Boolean isMustUnderstand, int idRef)
  827.         internal void WriteHeaderObjectRef(NameInfo nameInfo)
  828.         {
  829.             nameInfo.Dump("WriteHeaderObjectRef nameInfo");
  830.            
  831.             attrList.Clear();
  832.             attrList.Put("href", RefToString((int)nameInfo.NIobjectId));
  833.             if (nameInfo.NIisMustUnderstand) {
  834.                 attrList.Put("SOAP-ENV:mustUnderstand", "1");
  835.                 isUsedEnc = true;
  836.             }
  837.             attrList.Put("xmlns:" + nameInfo.NIheaderPrefix, nameInfo.NInamespace);
  838.             attrList.Put("SOAP-ENC:root", "1");
  839.             Write(InternalElementTypeE.Member, nameInfo.NIheaderPrefix + ":" + nameInfo.NIname, attrList, null, true, true);
  840.         }
  841.        
  842.         //internal void WriteHeaderString(String name, Boolean isMustUnderstand, int objectId, String value)
  843.         internal void WriteHeaderString(