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

  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: SoapCommonClasses
  18. // Purpose: utility classes
  19. //
  20. // Date: June 10, 1999
  21. //
  22. //============================================================
  23. namespace System.Runtime.Serialization.Formatters.Soap
  24. {
  25.     using System;
  26.     using System.Collections;
  27.     using System.Reflection;
  28.     using System.Text;
  29.     using System.Globalization;
  30.     using System.Runtime.Serialization.Formatters;
  31.     using System.Runtime.Remoting;
  32.     using System.Runtime.Remoting.Metadata;
  33.     using System.Runtime.Remoting.Messaging;
  34.     using System.Runtime.InteropServices;
  35.     using System.Runtime.Serialization;
  36.     using System.Resources;
  37.     using System.Diagnostics;
  38.    
  39.     // AttributeList class is used to transmit attributes from XMLObjectWriter to XMLWriter
  40.     internal sealed class AttributeList
  41.     {
  42.         private SerStack nameA = new SerStack("AttributeName");
  43.         private SerStack valueA = new SerStack("AttributeValue");
  44.        
  45.         internal int Count {
  46.             get { return nameA.Count(); }
  47.         }
  48.        
  49.         internal void Clear()
  50.         {
  51.             nameA.Clear();
  52.             valueA.Clear();
  53.         }
  54.        
  55.         internal void Put(string name, string value)
  56.         {
  57.             nameA.Push(name);
  58.             valueA.Push(value);
  59.         }
  60.        
  61.         internal void Get(int index, out string name, out string value)
  62.         {
  63.             name = (string)nameA.Next();
  64.             value = (string)valueA.Next();
  65.         }
  66.        
  67.         [Conditional("SER_LOGGING")]
  68.         internal void Dump()
  69.         {
  70.             nameA.Dump();
  71.             valueA.Dump();
  72.         }
  73.     }
  74.    
  75.     // Implements a stack used for parsing
  76.    
  77.     internal sealed class SerStack
  78.     {
  79.         //internal ArrayList stack = new ArrayList(10);
  80.         internal object[] objects = new object[10];
  81.         internal string stackId;
  82.         internal int top = -1;
  83.         internal int next = 0;
  84.        
  85.         internal SerStack(string stackId)
  86.         {
  87.             this.stackId = stackId;
  88.         }
  89.        
  90.         internal object GetItem(int index)
  91.         {
  92.             return objects[index];
  93.         }
  94.        
  95.         internal void Clear()
  96.         {
  97.             top = -1;
  98.             next = 0;
  99.         }
  100.        
  101.         // Push the object onto the stack
  102.         internal void Push(object obj)
  103.         {
  104.             InternalST.Soap(this, "Push ", stackId, " ", ((obj is ITrace) ? ((ITrace)obj).Trace() : ""));
  105.             if (top == (objects.Length - 1)) {
  106.                 IncreaseCapacity();
  107.             }
  108.             objects[++top] = obj;
  109.         }
  110.        
  111.         // Pop the object from the stack
  112.         internal object Pop()
  113.         {
  114.             if (top < 0)
  115.                 return null;
  116.            
  117.             object obj = objects[top];
  118.             objects[top--] = null;
  119.             InternalST.Soap(this, "Pop ", stackId, " ", ((obj is ITrace) ? ((ITrace)obj).Trace() : ""));
  120.             return obj;
  121.         }
  122.        
  123.         internal object Next()
  124.         {
  125.             if (next > top)
  126.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_StackRange"), stackId));
  127.             return objects[next++];
  128.         }
  129.        
  130.         internal void IncreaseCapacity()
  131.         {
  132.             int size = objects.Length * 2;
  133.             object[] newItems = new object[size];
  134.             Array.Copy(objects, 0, newItems, 0, objects.Length);
  135.             objects = newItems;
  136.         }
  137.        
  138.         // Gets the object on the top of the stack
  139.         internal object Peek()
  140.         {
  141.             if (top < 0)
  142.                 return null;
  143.             InternalST.Soap(this, "Peek ", stackId, " ", ((objects[top] is ITrace) ? ((ITrace)objects[top]).Trace() : ""));
  144.             return objects[top];
  145.         }
  146.        
  147.         // Gets the second entry in the stack.
  148.         internal object PeekPeek()
  149.         {
  150.             if (top < 1)
  151.                 return null;
  152.             InternalST.Soap(this, "PeekPeek ", stackId, " ", ((objects[top - 1] is ITrace) ? ((ITrace)objects[top - 1]).Trace() : ""));
  153.             return objects[top - 1];
  154.         }
  155.        
  156.         // The number of entries in the stack
  157.         internal int Count()
  158.         {
  159.             return top + 1;
  160.         }
  161.        
  162.         // The number of entries in the stack
  163.         internal bool IsEmpty()
  164.         {
  165.             if (top > 0)
  166.                 return false;
  167.             else
  168.                 return true;
  169.         }
  170.        
  171.         // Reverse the stack
  172.         internal void Reverse()
  173.         {
  174.             Array.Reverse(objects, 0, Count());
  175.         }
  176.        
  177.         [Conditional("SER_LOGGING")]
  178.         internal void Dump()
  179.         {
  180.             for (int i = 0; i < Count(); i++) {
  181.                 object obj = objects[i];
  182.                 InternalST.Soap(this, "Stack Dump ", stackId, " " + ((obj is ITrace) ? ((ITrace)obj).Trace() : ""));
  183.             }
  184.         }
  185.     }
  186.    
  187.    
  188.     internal sealed class NameCacheEntry
  189.     {
  190.         internal string name;
  191.         internal object value;
  192.     }
  193.    
  194.    
  195.     internal sealed class NameCache
  196.     {
  197.         private const int MAX_CACHE_ENTRIES = 353;
  198.         // Needs to be a prime number
  199.         static NameCacheEntry[] nameCache = new NameCacheEntry[MAX_CACHE_ENTRIES];
  200.        
  201.         int probe = 0;
  202.         string name = null;
  203.        
  204.         internal object GetCachedValue(string name)
  205.         {
  206.             this.name = name;
  207.             probe = Math.Abs(name.GetHashCode()) % MAX_CACHE_ENTRIES;
  208.             NameCacheEntry entry = nameCache[probe];
  209.             if (entry == null) {
  210.                 entry = new NameCacheEntry();
  211.                 entry.name = name;
  212.                 return null;
  213.             }
  214.             else if (entry.name == name) {
  215.                 return entry.value;
  216.             }
  217.             else
  218.                 return null;
  219.         }
  220.        
  221.         internal void SetCachedValue(object value)
  222.         {
  223.             NameCacheEntry entry = new NameCacheEntry();
  224.             entry.name = name;
  225.             entry.value = value;
  226.             nameCache[probe] = entry;
  227.         }
  228.     }
  229.    
  230.    
  231.    
  232.     static internal class SoapUtil
  233.     {
  234.         static internal Type typeofString = typeof(string);
  235.         static internal Type typeofBoolean = typeof(bool);
  236.         static internal Type typeofObject = typeof(object);
  237.         static internal Type typeofSoapFault = typeof(SoapFault);
  238.         static internal Assembly urtAssembly = Assembly.GetAssembly(typeofString);
  239.         static internal string urtAssemblyString = urtAssembly.FullName;
  240.        
  241.         [Conditional("SER_LOGGING")]
  242.         static internal void DumpHash(string tag, Hashtable hashTable)
  243.         {
  244.             IDictionaryEnumerator e = hashTable.GetEnumerator();
  245.             InternalST.Soap("HashTable Dump Begin ", tag);
  246.             while (e.MoveNext()) {
  247.                 InternalST.Soap("HashTable key " + e.Key + ", value " + e.Value);
  248.             }
  249.             InternalST.Soap("HashTable Dump end \n");
  250.         }
  251.        
  252.        
  253.         static internal ResourceManager SystemResMgr;
  254.        
  255.         private static ResourceManager InitResourceManager()
  256.         {
  257.             if (SystemResMgr == null)
  258.                 SystemResMgr = new ResourceManager("SoapFormatter", typeof(SoapParser).Module.Assembly);
  259.             return SystemResMgr;
  260.         }
  261.        
  262.         // Looks up the resource string value for key.
  263.         //
  264.         static internal string GetResourceString(string key)
  265.         {
  266.             if (SystemResMgr == null)
  267.                 InitResourceManager();
  268.             string s = SystemResMgr.GetString(key, null);
  269.             InternalST.SoapAssert(s != null, "Managed resource string lookup failed. Was your resource name misspelled? Did you rebuild the SoapFormatter and SoapFormatter.resource after adding a resource to SoapFormatter.txt? Debug this w/ cordbg and bug whoever owns the code that called SoapUtil.GetResourceString. Resource name was: \"" + key + "\"");
  270.             return s;
  271.         }
  272.        
  273.         static internal string GetResourceString(string key, params object[] values)
  274.         {
  275.             if (SystemResMgr == null)
  276.                 InitResourceManager();
  277.             string s = SystemResMgr.GetString(key, null);
  278.             InternalST.SoapAssert(s != null, "Managed resource string lookup failed. Was your resource name misspelled? Did you rebuild mscorlib after adding a resource to resources.txt? Debug this w/ cordbg and bug whoever owns the code that called Environment.GetResourceString. Resource name was: \"" + key + "\"");
  279.             return String.Format(CultureInfo.CurrentCulture, s, values);
  280.         }
  281.     }
  282.    
  283.     internal sealed class SoapAssemblyInfo
  284.     {
  285.         internal string assemblyString;
  286.         private Assembly assembly;
  287.        
  288.         internal SoapAssemblyInfo(string assemblyString)
  289.         {
  290.             this.assemblyString = assemblyString;
  291.         }
  292.        
  293.         internal SoapAssemblyInfo(string assemblyString, Assembly assembly)
  294.         {
  295.             this.assemblyString = assemblyString;
  296.             this.assembly = assembly;
  297.         }
  298.        
  299.         internal Assembly GetAssembly(ObjectReader objectReader)
  300.         {
  301.             if (assembly == null) {
  302.                 assembly = objectReader.LoadAssemblyFromString(assemblyString);
  303.                 if (assembly == null)
  304.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_AssemblyString"), assemblyString));
  305.             }
  306.             return assembly;
  307.         }
  308.     }
  309.    
  310.     // The ParseRecord class holds the parsed XML information. There is a
  311.     // ParsedRecord for each XML Element
  312.     internal sealed class ParseRecord : ITrace
  313.     {
  314.         static internal int parseRecordIdCount = 1;
  315.        
  316.        
  317.         internal int PRparseRecordId = 0;
  318.        
  319.         // Enums
  320.         internal InternalParseTypeE PRparseTypeEnum = InternalParseTypeE.Empty;
  321.         internal InternalObjectTypeE PRobjectTypeEnum = InternalObjectTypeE.Empty;
  322.         internal InternalArrayTypeE PRarrayTypeEnum = InternalArrayTypeE.Empty;
  323.         internal InternalMemberTypeE PRmemberTypeEnum = InternalMemberTypeE.Empty;
  324.         internal InternalMemberValueE PRmemberValueEnum = InternalMemberValueE.Empty;
  325.         internal InternalObjectPositionE PRobjectPositionEnum = InternalObjectPositionE.Empty;
  326.        
  327.         // Object
  328.         internal string PRname;
  329.         internal string PRnameXmlKey;
  330.         internal string PRxmlNameSpace;
  331.         internal bool PRisParsed = false;
  332.         internal bool PRisProcessAttributes = false;
  333.        
  334.         // Value
  335.         internal string PRvalue;
  336.         internal object PRvarValue;
  337.        
  338.         // dt attribute
  339.         internal string PRkeyDt;
  340.         internal string PRtypeXmlKey;
  341.         internal Type PRdtType;
  342.         internal string PRassemblyName;
  343.         internal InternalPrimitiveTypeE PRdtTypeCode;
  344.         internal bool PRisVariant = false;
  345.         // Used by Binary
  346.         internal bool PRisEnum = false;
  347.        
  348.         // Object ID
  349.         internal long PRobjectId;
  350.        
  351.         // Reference ID
  352.         internal long PRidRef;
  353.        
  354.         // Array
  355.        
  356.         // Array Element Type
  357.         internal string PRarrayElementTypeString;
  358.         internal Type PRarrayElementType;
  359.         internal bool PRisArrayVariant = false;
  360.         internal InternalPrimitiveTypeE PRarrayElementTypeCode;
  361.         //internal String PRarrayXmlKey;
  362.        
  363.         // Binary Byte Array
  364.         //internal Byte[] PRbyteA;
  365.        
  366.         // Array Primitive Element type
  367.         internal string PRprimitiveArrayTypeString;
  368.        
  369.         // Parsed array information
  370.         internal int PRrank;
  371.         internal int[] PRlengthA;
  372.         internal int[] PRpositionA;
  373.         internal int[] PRlowerBoundA;
  374.         internal int[] PRupperBoundA;
  375.        
  376.         // Array map for placing array elements in array
  377.         //internal int[][] indexMap;
  378.         internal int[] PRindexMap;
  379.         internal int PRmemberIndex;
  380.         internal int PRlinearlength;
  381.         internal int[] PRrectangularMap;
  382.         internal bool PRisLowerBound;
  383.        
  384.         // SerializedStreamHeader information
  385.         internal long PRtopId;
  386.         internal long PRheaderId;
  387.         internal bool PRisHeaderRoot;
  388.         internal bool PRisAttributesProcessed;
  389.        
  390.         // Parsed HeaderMember Information
  391.         internal bool PRisMustUnderstand;
  392.        
  393.        
  394.         // Parse State
  395.         internal InternalParseStateE PRparseStateEnum = InternalParseStateE.Initial;
  396.         internal bool PRisWaitingForNestedObject = false;
  397.        
  398.         // MemberInfo accumulated during parsing of members
  399.        
  400.         internal ReadObjectInfo PRobjectInfo;
  401.        
  402.         // ValueType Fixup needed
  403.         internal bool PRisValueTypeFixup = false;
  404.        
  405.         // Created object
  406.         internal object PRnewObj;
  407.         internal object[] PRobjectA;
  408.         //optimization, will contain object[]
  409.         internal PrimitiveArray PRprimitiveArray;
  410.         // for Primitive Soap arrays, optimization
  411.         internal bool PRisRegistered;
  412.         // Used when registering nested classes
  413.         internal bool PRisXmlAttribute;
  414.        
  415.         // Get a String describing the ParseRecord
  416.        
  417.         internal ParseRecord()
  418.         {
  419.             Counter();
  420.         }
  421.        
  422.         private void Counter()
  423.         {
  424.             // The counter is used to test parseRecord identity
  425.             lock (typeof(ParseRecord)) {
  426.                 PRparseRecordId = parseRecordIdCount++;
  427.             }
  428.            
  429.         }
  430.        
  431.         public string Trace()
  432.         {
  433.             //return "ParseType "+EnumInfo.ToString(InternalParseTypeE.class, parseTypeEnum)+" name "+name+" ParseState "+EnumInfo.ToString(InternalParseStateE.class, parseStateEnum);
  434.             return "ParseRecord" + PRparseRecordId + " ParseType " + ((Enum)PRparseTypeEnum).ToString() + " name " + PRname + " keyDt " + Util.PString(PRkeyDt);
  435.         }
  436.        
  437.         // Initialize ParseRecord. Called when reusing.
  438.         internal void Init()
  439.         {
  440.             // Enums
  441.             PRparseTypeEnum = InternalParseTypeE.Empty;
  442.             PRobjectTypeEnum = InternalObjectTypeE.Empty;
  443.             PRarrayTypeEnum = InternalArrayTypeE.Empty;
  444.             PRmemberTypeEnum = InternalMemberTypeE.Empty;
  445.             PRmemberValueEnum = InternalMemberValueE.Empty;
  446.             PRobjectPositionEnum = InternalObjectPositionE.Empty;
  447.            
  448.             // Object
  449.             PRname = null;
  450.             PRnameXmlKey = null;
  451.             PRxmlNameSpace = null;
  452.             PRisParsed = false;
  453.             PRisProcessAttributes = false;
  454.            
  455.             // Value
  456.             PRvalue = null;
  457.            
  458.             // dt attribute
  459.             PRkeyDt = null;
  460.             PRdtType = null;
  461.             PRassemblyName = null;
  462.             PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
  463.             PRisEnum = false;
  464.            
  465.             // Object ID
  466.             PRobjectId = 0;
  467.            
  468.             // Reference ID
  469.             PRidRef = 0;
  470.            
  471.             // Array
  472.            
  473.             // Array Element Type
  474.             PRarrayElementTypeString = null;
  475.             PRarrayElementType = null;
  476.             PRisArrayVariant = false;
  477.             PRarrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
  478.            
  479.            
  480.             // Array Primitive Element type
  481.             PRprimitiveArrayTypeString = null;
  482.            
  483.             // Parsed array information
  484.             PRrank = 0;
  485.             PRlengthA = null;
  486.             PRpositionA = null;
  487.             PRlowerBoundA = null;
  488.             PRupperBoundA = null;
  489.            
  490.             // Array map for placing array elements in array
  491.             PRindexMap = null;
  492.             PRmemberIndex = 0;
  493.             PRlinearlength = 0;
  494.             PRrectangularMap = null;
  495.             PRisLowerBound = false;
  496.            
  497.             // SerializedStreamHeader information
  498.             PRtopId = 0;
  499.             PRheaderId = 0;
  500.             PRisHeaderRoot = false;
  501.             PRisAttributesProcessed = false;
  502.            
  503.             // Parsed HeaderMember Information
  504.             PRisMustUnderstand = false;
  505.            
  506.             // Parse State
  507.             PRparseStateEnum = InternalParseStateE.Initial;
  508.             PRisWaitingForNestedObject = false;
  509.            
  510.            
  511.             // ValueType Fixup needed
  512.             PRisValueTypeFixup = false;
  513.            
  514.             PRnewObj = null;
  515.             PRobjectA = null;
  516.             PRprimitiveArray = null;
  517.             PRobjectInfo = null;
  518.             PRisRegistered = false;
  519.            
  520.             PRisXmlAttribute = false;
  521.         }
  522.        
  523.         internal ParseRecord Copy()
  524.         {
  525.            
  526.             ParseRecord newPr = new ParseRecord();
  527.             // Enums
  528.             newPr.PRparseTypeEnum = PRparseTypeEnum;
  529.             newPr.PRobjectTypeEnum = PRobjectTypeEnum;
  530.             newPr.PRarrayTypeEnum = PRarrayTypeEnum;
  531.             newPr.PRmemberTypeEnum = PRmemberTypeEnum;
  532.             newPr.PRmemberValueEnum = PRmemberValueEnum;
  533.             newPr.PRobjectPositionEnum = PRobjectPositionEnum;
  534.            
  535.             // Object
  536.             newPr.PRname = PRname;
  537.             newPr.PRisParsed = PRisParsed;
  538.             newPr.PRisProcessAttributes = PRisProcessAttributes;
  539.             newPr.PRnameXmlKey = PRnameXmlKey;
  540.             newPr.PRxmlNameSpace = PRxmlNameSpace;
  541.            
  542.             // Value
  543.             newPr.PRvalue = PRvalue;
  544.            
  545.            
  546.             // dt attribute
  547.             newPr.PRkeyDt = PRkeyDt;
  548.             newPr.PRdtType = PRdtType;
  549.             newPr.PRassemblyName = PRassemblyName;
  550.             newPr.PRdtTypeCode = PRdtTypeCode;
  551.             newPr.PRisEnum = PRisEnum;
  552.            
  553.             // Object ID
  554.             newPr.PRobjectId = PRobjectId;
  555.            
  556.             // Reference ID
  557.             newPr.PRidRef = PRidRef;
  558.            
  559.             // Array
  560.            
  561.             // Array Element Type
  562.             newPr.PRarrayElementTypeString = PRarrayElementTypeString;
  563.             newPr.PRarrayElementType = PRarrayElementType;
  564.             newPr.PRisArrayVariant = PRisArrayVariant;
  565.             newPr.PRarrayElementTypeCode = PRarrayElementTypeCode;
  566.            
  567.            
  568.             // Array Primitive Element type
  569.             newPr.PRprimitiveArrayTypeString = PRprimitiveArrayTypeString;
  570.            
  571.             // Parsed array information
  572.             newPr.PRrank = PRrank;
  573.             newPr.PRlengthA = PRlengthA;
  574.             newPr.PRpositionA = PRpositionA;
  575.             newPr.PRlowerBoundA = PRlowerBoundA;
  576.             newPr.PRupperBoundA = PRupperBoundA;
  577.            
  578.             // Array map for placing array elements in array
  579.             newPr.PRindexMap = PRindexMap;
  580.             newPr.PRmemberIndex = PRmemberIndex;
  581.             newPr.PRlinearlength = PRlinearlength;
  582.             newPr.PRrectangularMap = PRrectangularMap;
  583.             newPr.PRisLowerBound = PRisLowerBound;
  584.            
  585.             // SerializedStreamHeader information
  586.             newPr.PRtopId = PRtopId;
  587.             newPr.PRheaderId = PRheaderId;
  588.             newPr.PRisHeaderRoot = PRisHeaderRoot;
  589.             newPr.PRisAttributesProcessed = PRisAttributesProcessed;
  590.            
  591.             // Parsed HeaderMember Information
  592.             newPr.PRisMustUnderstand = PRisMustUnderstand;
  593.            
  594.             // Parse State
  595.             newPr.PRparseStateEnum = PRparseStateEnum;
  596.             newPr.PRisWaitingForNestedObject = PRisWaitingForNestedObject;
  597.            
  598.            
  599.             // ValueType Fixup needed
  600.             newPr.PRisValueTypeFixup = PRisValueTypeFixup;
  601.            
  602.             newPr.PRnewObj = PRnewObj;
  603.             newPr.PRobjectA = PRobjectA;
  604.             newPr.PRprimitiveArray = PRprimitiveArray;
  605.             newPr.PRobjectInfo = PRobjectInfo;
  606.             newPr.PRisRegistered = PRisRegistered;
  607.             newPr.PRisXmlAttribute = PRisXmlAttribute;
  608.            
  609.             return newPr;
  610.         }
  611.        
  612.        
  613.         // Dump ParseRecord.
  614.         [Conditional("SER_LOGGING")]
  615.         internal void Dump()
  616.         {
  617.             #if _DEBUG
  618.             InternalST.Soap("ParseRecord Dump ", PRparseRecordId);
  619.             InternalST.Soap("Enums");
  620.             Util.NVTrace("ParseType", ((Enum)PRparseTypeEnum).ToString());
  621.             Util.NVTrace("ObjectType", ((Enum)PRobjectTypeEnum).ToString());
  622.             Util.NVTrace("ArrayType", ((Enum)PRarrayTypeEnum).ToString());
  623.             Util.NVTrace("MemberType", ((Enum)PRmemberTypeEnum).ToString());
  624.             Util.NVTrace("MemberValue", ((Enum)PRmemberValueEnum).ToString());
  625.             Util.NVTrace("ObjectPosition", ((Enum)PRobjectPositionEnum).ToString());
  626.             Util.NVTrace("ParseState", ((Enum)PRparseStateEnum).ToString());
  627.             InternalST.Soap("Basics");
  628.             Util.NVTrace("Name", PRname);
  629.             Util.NVTrace("PRisParsed", PRisParsed);
  630.             Util.NVTrace("PRisProcessAttributes", PRisParsed);
  631.             Util.NVTrace("PRnameXmlKey", PRnameXmlKey);
  632.             Util.NVTrace("PRxmlNameSpace", PRxmlNameSpace);
  633.             Util.NVTrace("Value ", PRvalue);
  634.             Util.NVTrace("varValue ", PRvarValue);
  635.             if (PRvarValue != null)
  636.                 Util.NVTrace("varValue type", PRvarValue.GetType());
  637.            
  638.             Util.NVTrace("keyDt", PRkeyDt);
  639.             Util.NVTrace("dtType", PRdtType);
  640.             Util.NVTrace("assemblyName", PRassemblyName);
  641.             Util.NVTrace("code", ((Enum)PRdtTypeCode).ToString());
  642.             Util.NVTrace("objectID", PRobjectId);
  643.             Util.NVTrace("idRef", PRidRef);
  644.             Util.NVTrace("isEnum", PRisEnum);
  645.             InternalST.Soap("Array ");
  646.             Util.NVTrace("arrayElementTypeString", PRarrayElementTypeString);
  647.             Util.NVTrace("arrayElementType", PRarrayElementType);
  648.             Util.NVTrace("arrayElementTypeCode", ((Enum)PRarrayElementTypeCode).ToString());
  649.             Util.NVTrace("isArrayVariant", PRisArrayVariant);
  650.             Util.NVTrace("primitiveArrayTypeString", PRprimitiveArrayTypeString);
  651.             Util.NVTrace("rank", PRrank);
  652.             Util.NVTrace("dimensions", Util.PArray(PRlengthA));
  653.             Util.NVTrace("position", Util.PArray(PRpositionA));
  654.             Util.NVTrace("lowerBoundA", Util.PArray(PRlowerBoundA));
  655.             Util.NVTrace("upperBoundA", Util.PArray(PRupperBoundA));
  656.             InternalST.Soap("Header ");
  657.             Util.NVTrace("isMustUnderstand", PRisMustUnderstand);
  658.             Util.NVTrace("isHeaderRoot", PRisHeaderRoot);
  659.             Util.NVTrace("isAttributesProcessed", PRisAttributesProcessed);
  660.             Util.NVTrace("isXmlAttribute", PRisXmlAttribute);
  661.            
  662.             InternalST.Soap("New Object");
  663.             if (PRnewObj != null)
  664.                 Util.NVTrace("newObj", PRnewObj);
  665.             /*
  666. if ((objectInfo != null) && (objectInfo.objectType != null))
  667. Util.NVTrace("objectInfo", objectInfo.objectType.ToString());
  668. */           
  669.             #endif
  670.         }
  671.     }
  672.    
  673.     internal interface ITrace
  674.     {
  675.         string Trace();
  676.     }
  677.    
  678.     // Utilities
  679.     static internal class Util
  680.     {
  681.        
  682.         // Replaces a null string with an empty string
  683.         static internal string PString(string value)
  684.         {
  685.             if (value == null)
  686.                 return "";
  687.             else
  688.                 return value;
  689.         }
  690.        
  691.         #if _DEBUG
  692.         // Converts an object to a string and checks for nulls
  693.         static internal string PString(object value)
  694.         {
  695.             if (value == null)
  696.                 return "";
  697.             else
  698.                 return value.ToString();
  699.         }
  700.        
  701.         // Converts a single int array to a string
  702.        
  703.         static internal string PArray(int[] array)
  704.         {
  705.             if (array != null) {
  706.                 StringBuilder sb = new StringBuilder(10);
  707.                 sb.Append("[");
  708.                 for (int i = 0; i < array.Length; i++) {
  709.                     sb.Append(array[i]);
  710.                     if (i != array.Length - 1)
  711.                         sb.Append(",");
  712.                 }
  713.                 sb.Append("]");
  714.                 return sb.ToString();
  715.             }
  716.             else
  717.                 return "";
  718.         }
  719.         #endif
  720.        
  721.         // Traces a name value pair
  722.        
  723.         [Conditional("SER_LOGGING")]
  724.         static internal void NVTrace(string name, string value)
  725.         {
  726.             InternalST.Soap(" " + name + ((value == null) ? " = null" : " = " + value));
  727.         }
  728.        
  729.         // Traces a name value pair
  730.         [Conditional("SER_LOGGING")]
  731.         static internal void NVTrace(string name, object value)
  732.         {
  733.             try {
  734.                 InternalST.Soap(" " + name + ((value == null) ? " = null" : " = " + value.ToString()));
  735.             }
  736.             catch {
  737.                 InternalST.Soap(" " + name + " = null");
  738.                 //Empty StringBuilder is giving an exception
  739.             }
  740.         }
  741.        
  742.         // Traces a name value pair
  743.        
  744.         [Conditional("_LOGGING")]
  745.         static internal void NVTraceI(string name, string value)
  746.         {
  747.             InternalST.Soap(" " + name + ((value == null) ? " = null" : " = " + value));
  748.         }
  749.        
  750.         // Traces a name value pair
  751.         [Conditional("_LOGGING")]
  752.         static internal void NVTraceI(string name, object value)
  753.         {
  754.             InternalST.Soap(" " + name + ((value == null) ? " = null" : " = " + value.ToString()));
  755.         }
  756.        
  757.     }
  758.    
  759.    
  760.     // Used to fixup value types. Only currently used for value types which are array items.
  761.     internal class ValueFixup : ITrace
  762.     {
  763.         internal ValueFixupEnum valueFixupEnum = ValueFixupEnum.Empty;
  764.         internal Array arrayObj;
  765.         internal int[] indexMap;
  766.         internal object memberObject;
  767.         internal ReadObjectInfo objectInfo;
  768.         internal string memberName;
  769.        
  770.         internal ValueFixup(Array arrayObj, int[] indexMap)
  771.         {
  772.             InternalST.Soap(this, "Array Constructor ", arrayObj);
  773.             valueFixupEnum = ValueFixupEnum.Array;
  774.             this.arrayObj = arrayObj;
  775.             this.indexMap = indexMap;
  776.         }
  777.        
  778.         internal ValueFixup(object memberObject, string memberName, ReadObjectInfo objectInfo)
  779.         {
  780.             InternalST.Soap(this, "Member Constructor ", memberObject);
  781.             valueFixupEnum = ValueFixupEnum.Member;
  782.             this.memberObject = memberObject;
  783.             this.memberName = memberName;
  784.             this.objectInfo = objectInfo;
  785.         }
  786.        
  787.         internal virtual void Fixup(ParseRecord record, ParseRecord parent)
  788.         {
  789.             object obj = record.PRnewObj;
  790.             InternalST.Soap(this, "Fixup ", obj, " ", ((Enum)valueFixupEnum).ToString());
  791.            
  792.             switch (valueFixupEnum) {
  793.                 case ValueFixupEnum.Array:
  794.                     arrayObj.SetValue(obj, indexMap);
  795.                     break;
  796.                 case ValueFixupEnum.Member:
  797.                    
  798.                     InternalST.Soap(this, "Fixup Member new object value ", obj, " memberObject ", memberObject);
  799.                    
  800.                     if (objectInfo.isSi) {
  801.                         InternalST.Soap(this, "Recording a fixup on member: ", memberName, " in object id", parent.PRobjectId, " Required Object ", record.PRobjectId);
  802.                         objectInfo.objectManager.RecordDelayedFixup(parent.PRobjectId, memberName, record.PRobjectId);
  803.                     }
  804.                     else {
  805.                         MemberInfo memberInfo = objectInfo.GetMemberInfo(memberName);
  806.                         InternalST.Soap(this, "Recording a fixup on member:", memberInfo, " in object id ", parent.PRobjectId, " Required Object", record.PRobjectId);
  807.                         objectInfo.objectManager.RecordFixup(parent.PRobjectId, memberInfo, record.PRobjectId);
  808.                     }
  809.                     break;
  810.             }
  811.         }
  812.        
  813.         public virtual string Trace()
  814.         {
  815.             return "ValueFixup" + ((Enum)valueFixupEnum).ToString();
  816.         }
  817.        
  818.     }
  819.    
  820.     // Class used to transmit Enums from the XML and Binary Formatter class to the ObjectWriter and ObjectReader class
  821.     internal sealed class InternalFE
  822.     {
  823.         internal FormatterTypeStyle FEtypeFormat;
  824.         internal FormatterAssemblyStyle FEassemblyFormat;
  825.         internal ISoapMessage FEtopObject;
  826.         internal TypeFilterLevel FEsecurityLevel;
  827.         internal InternalSerializerTypeE FEserializerTypeEnum;
  828.     }
  829.    
  830.     // Class used to Read an XML record which has a fake object as the top object.
  831.     // A fake object is an object which has the methodName as the XML elementName rather
  832.     // then a valid object name.
  833.     // After the information is read a SoapMessage object is created as the top object
  834.     // to return the information as the top object graph
  835.     [Serializable()]
  836.     internal sealed class InternalSoapMessage : ISerializable, IFieldInfo
  837.     {
  838.         internal string methodName = null;
  839.         internal string xmlNameSpace = null;
  840.         internal string[] paramNames = null;
  841.         internal object[] paramValues = null;
  842.         internal Type[] paramTypes = null;
  843.         internal Hashtable keyToNamespaceTable = null;
  844.        
  845.         // Read Constructor
  846.         internal InternalSoapMessage()
  847.         {
  848.             InternalST.Soap(this, "Constructor Read Unitialized ");
  849.         }
  850.        
  851.         // Write Constructor
  852.         internal InternalSoapMessage(string methodName, string xmlNameSpace, string[] paramNames, object[] paramValues, Type[] paramTypes)
  853.         {
  854.             InternalST.Soap(this, "Constructor Write ", methodName);
  855.             this.methodName = methodName;
  856.             this.xmlNameSpace = xmlNameSpace;
  857.             this.paramNames = paramNames;
  858.             this.paramValues = paramValues;
  859.             this.paramTypes = paramTypes;
  860.         }
  861.        
  862.         internal InternalSoapMessage(SerializationInfo info, StreamingContext context)
  863.         {
  864.             InternalST.Soap(this, "Constructor Write SetObjectData ");
  865.             SetObjectData(info, context);
  866.         }
  867.        
  868.         // IFieldInfo
  869.         public string[] FieldNames {
  870.             get { return paramNames; }
  871.             set { paramNames = value; }
  872.         }
  873.        
  874.         // IFieldInfo
  875.         public Type[] FieldTypes {
  876.             get { return paramTypes; }
  877.             set { paramTypes = value; }
  878.         }
  879.        
  880.        
  881.         public void GetObjectData(SerializationInfo info, StreamingContext context)
  882.         {
  883.            
  884.             int numberOfMembers = 0;
  885.            
  886.             if (paramValues != null)
  887.                 numberOfMembers = paramValues.Length;
  888.            
  889.             InternalST.Soap(this, "GetObjectData ", methodName, " " + numberOfMembers);
  890.            
  891.             info.FullTypeName = methodName;
  892.             if (xmlNameSpace != null)
  893.                 info.AssemblyName = xmlNameSpace;
  894.            
  895.             string paramName = null;
  896.             if (paramValues != null) {
  897.                 for (int i = 0; i < paramValues.Length; i++) {
  898.                     InternalST.Soap(this, "GetObjectData AddValue ", paramNames[i], " ", paramValues[i]);
  899.                    
  900.                     if ((paramNames != null) && (paramNames[i] == null))
  901.                         paramName = "param" + i;
  902.                     else
  903.                         paramName = paramNames[i];
  904.                     info.AddValue(paramName, paramValues[i], typeof(object));
  905.                 }
  906.             }
  907.            
  908.         }
  909.        
  910.         internal void SetObjectData(SerializationInfo info, StreamingContext context)
  911.         {
  912.             InternalST.Soap(this, "SetObjectData ");
  913.             ArrayList paramValuesList = new ArrayList(20);
  914.             methodName = (string)info.GetString("__methodName");
  915.             keyToNamespaceTable = (Hashtable)info.GetValue("__keyToNamespaceTable", typeof(Hashtable));
  916.             ArrayList paramNamesList = (ArrayList)info.GetValue("__paramNameList", typeof(ArrayList));
  917.             xmlNameSpace = (string)info.GetString("__xmlNameSpace");
  918.            
  919.             for (int i = 0; i < paramNamesList.Count; i++)
  920.                 paramValuesList.Add(info.GetValue((string)paramNamesList[i], Converter.typeofObject));
  921.            
  922.             paramNames = new string[paramNamesList.Count];
  923.             paramValues = new object[paramValuesList.Count];
  924.            
  925.             for (int i = 0; i < paramNamesList.Count; i++) {
  926.                 paramNames[i] = (string)paramNamesList[i];
  927.                 paramValues[i] = (object)paramValuesList[i];
  928.                 InternalST.Soap(this, "SetObjectData param ", i, " ", paramNames[i], " paramValue ", paramValues[i]);
  929.             }
  930.         }
  931.     }
  932.    
  933.     internal sealed class SoapAttributeInfo
  934.     {
  935.         internal SoapAttributeType m_attributeType;
  936.         internal string m_nameSpace;
  937.         internal string m_elementName;
  938.         internal string m_typeName;
  939.         internal string m_typeNamespace;
  940.        
  941.         internal string AttributeElementName {
  942.             get { return m_elementName; }
  943.         }
  944.        
  945.         internal string AttributeTypeName {
  946.             get { return m_typeName; }
  947.         }
  948.        
  949.         internal bool IsEmbedded()
  950.         {
  951.             if ((m_attributeType & SoapAttributeType.Embedded) > 0)
  952.                 return true;
  953.             else
  954.                 return false;
  955.         }
  956.        
  957.         internal bool IsXmlElement()
  958.         {
  959.             if ((m_attributeType & SoapAttributeType.XmlElement) > 0)
  960.                 return true;
  961.             else
  962.                 return false;
  963.         }
  964.        
  965.         internal bool IsXmlAttribute()
  966.         {
  967.             if ((m_attributeType & SoapAttributeType.XmlAttribute) > 0)
  968.                 return true;
  969.             else
  970.                 return false;
  971.         }
  972.        
  973.         internal bool IsXmlType()
  974.         {
  975.             if ((m_attributeType & SoapAttributeType.XmlType) > 0)
  976.                 return true;
  977.             else
  978.                 return false;
  979.         }
  980.        
  981.         [Conditional("SER_LOGGING")]
  982.         internal void Dump(string id)
  983.         {
  984.             InternalST.Soap("Dump SoapAttributeInfo ", id);
  985.             if (IsXmlType())
  986.                 InternalST.Soap(" SchemaType");
  987.             if (IsEmbedded())
  988.                 InternalST.Soap(" Embedded");
  989.             if (IsXmlElement())
  990.                 InternalST.Soap(" XmlElement");
  991.             if (IsXmlAttribute())
  992.                 InternalST.Soap(" XmlAttribute");
  993.             Util.NVTrace("_nameSpace", m_nameSpace);
  994.             Util.NVTrace("_elementName", m_elementName);
  995.             Util.NVTrace("_type", m_typeName);
  996.         }
  997.     }
  998.    
  999.     internal sealed class NameInfo
  1000.     {
  1001.         internal InternalNameSpaceE NInameSpaceEnum = InternalNameSpaceE.None;
  1002.         internal string NIname;
  1003.         // Name from SerObjectInfo.GetType
  1004.         //internal String elementName; // Name from SerObjectInfo.GetElementName, will be the same as GetType except for interopTypes
  1005.         //internal String interopType;
  1006.         internal long NIobjectId;
  1007.         internal long NIassemId;
  1008.         internal InternalPrimitiveTypeE NIprimitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
  1009.         internal Type NItype;
  1010.         internal bool NIisSealed;
  1011.         internal bool NIisMustUnderstand;
  1012.         internal string NInamespace;
  1013.         internal string NIheaderPrefix;
  1014.         internal string NIitemName;
  1015.         internal bool NIisArray;
  1016.         internal bool NIisArrayItem;
  1017.         internal bool NIisTopLevelObject;
  1018.         internal bool NIisNestedObject;
  1019.         internal bool NItransmitTypeOnObject;
  1020.         internal bool NItransmitTypeOnMember;
  1021.         internal bool NIisParentTypeOnObject;
  1022.         internal bool NIisHeader;
  1023.         internal bool NIisRemoteRecord;
  1024.         internal SoapAttributeInfo NIattributeInfo;
  1025.        
  1026.         internal void Init()
  1027.         {
  1028.             NInameSpaceEnum = InternalNameSpaceE.None;
  1029.             NIname = null;
  1030.             NIobjectId = 0;
  1031.             NIassemId = 0;
  1032.             NIprimitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
  1033.             NItype = null;
  1034.             NIisSealed = false;
  1035.             NItransmitTypeOnObject = false;
  1036.             NItransmitTypeOnMember = false;
  1037.             NIisParentTypeOnObject = false;
  1038.             NIisMustUnderstand = false;
  1039.             NInamespace = null;
  1040.             NIheaderPrefix = null;
  1041.             NIitemName = null;
  1042.             NIisArray = false;
  1043.             NIisArrayItem = false;
  1044.             NIisTopLevelObject = false;
  1045.             NIisNestedObject = false;
  1046.             NIisHeader = false;
  1047.             NIisRemoteRecord = false;
  1048.             NIattributeInfo = null;
  1049.         }
  1050.        
  1051.         [Conditional("SER_LOGGING")]
  1052.         internal void Dump(string value)
  1053.         {
  1054.             Util.NVTrace("nameSpaceEnum", ((Enum)NInameSpaceEnum).ToString());
  1055.             Util.NVTrace("name", NIname);
  1056.             Util.NVTrace("objectId", NIobjectId);
  1057.             Util.NVTrace("assemId", NIassemId);
  1058.             Util.NVTrace("primitiveTypeEnum", ((Enum)NIprimitiveTypeEnum).ToString());
  1059.             Util.NVTrace("type", NItype);
  1060.             Util.NVTrace("isSealed", NIisSealed);
  1061.             Util.NVTrace("transmitTypeOnObject", NItransmitTypeOnObject);
  1062.             Util.NVTrace("transmitTypeOnMember", NItransmitTypeOnMember);
  1063.             Util.NVTrace("isParentTypeOnObject", NIisParentTypeOnObject);
  1064.             Util.NVTrace("isMustUnderstand", NIisMustUnderstand);
  1065.             Util.NVTrace("namespace", NInamespace);
  1066.             Util.NVTrace("headerPrefix", NIheaderPrefix);
  1067.             Util.NVTrace("itemName", NIitemName);
  1068.             Util.NVTrace("isArray", NIisArray);
  1069.             Util.NVTrace("isArrayItem", NIisArrayItem);
  1070.             Util.NVTrace("isTopLevelObject", NIisTopLevelObject);
  1071.             Util.NVTrace("isNestedObject", NIisNestedObject);
  1072.             Util.NVTrace("isHeader", NIisHeader);
  1073.             Util.NVTrace("isRemoteRecord", NIisRemoteRecord);
  1074.             if (NIattributeInfo != null)
  1075.                 NIattributeInfo.Dump(NIname);
  1076.         }
  1077.        
  1078.     }
  1079.    
  1080.     internal sealed class PrimitiveArray
  1081.     {
  1082.         InternalPrimitiveTypeE code;
  1083.         bool[] booleanA = null;
  1084.         char[] charA = null;
  1085.         double[] doubleA = null;
  1086.         Int16[] int16A = null;
  1087.         Int32[] int32A = null;
  1088.         Int64[] int64A = null;
  1089.         sbyte[] sbyteA = null;
  1090.         float[] singleA = null;
  1091.         UInt16[] uint16A = null;
  1092.         UInt32[] uint32A = null;
  1093.         UInt64[] uint64A = null;
  1094.        
  1095.        
  1096.         internal PrimitiveArray(InternalPrimitiveTypeE code, Array array)
  1097.         {
  1098.             Init(code, array);
  1099.         }
  1100.        
  1101.         internal void Init(InternalPrimitiveTypeE code, Array array)
  1102.         {
  1103.             this.code = code;
  1104.             switch (code) {
  1105.                 case InternalPrimitiveTypeE.Boolean:
  1106.                     booleanA = (bool[])array;
  1107.                     break;
  1108.                 case InternalPrimitiveTypeE.Char:
  1109.                     charA = (char[])array;
  1110.                     break;
  1111.                 case InternalPrimitiveTypeE.Double:
  1112.                     doubleA = (double[])array;
  1113.                     break;
  1114.                 case InternalPrimitiveTypeE.Int16:
  1115.                     int16A = (Int16[])array;
  1116.                     break;
  1117.                 case InternalPrimitiveTypeE.Int32:
  1118.                     int32A = (Int32[])array;
  1119.                     break;
  1120.                 case InternalPrimitiveTypeE.Int64:
  1121.                     int64A = (Int64[])array;
  1122.                     break;
  1123.                 case InternalPrimitiveTypeE.SByte:
  1124.                     sbyteA = (sbyte[])array;
  1125.                     break;
  1126.                 case InternalPrimitiveTypeE.Single:
  1127.                     singleA = (float[])array;
  1128.                     break;
  1129.                 case InternalPrimitiveTypeE.UInt16:
  1130.                     uint16A = (UInt16[])array;
  1131.                     break;
  1132.                 case InternalPrimitiveTypeE.UInt32:
  1133.                     uint32A = (UInt32[])array;
  1134.                     break;
  1135.                 case InternalPrimitiveTypeE.UInt64:
  1136.                     uint64A = (UInt64[])array;
  1137.                     break;
  1138.             }
  1139.         }
  1140.        
  1141.         internal string GetValue(int index)
  1142.         {
  1143.             string value = null;
  1144.             switch (code) {
  1145.                 case InternalPrimitiveTypeE.Boolean:
  1146.                     value = (booleanA[index]).ToString();
  1147.                     break;
  1148.                 case InternalPrimitiveTypeE.Char:
  1149.                     if (charA[index] == Char.MinValue)
  1150.                         value = "_0x00_";
  1151.                     else
  1152.                         value = Char.ToString(charA[index]);
  1153.                     break;
  1154.                 case InternalPrimitiveTypeE.Double:
  1155.                     if (Double.IsPositiveInfinity(doubleA[index]))
  1156.                         value = "INF";
  1157.                     else if (Double.IsNegativeInfinity(doubleA[index]))
  1158.                         value = "-INF";
  1159.                     else
  1160.                         value = (doubleA[index]).ToString("R", CultureInfo.InvariantCulture);
  1161.                     break;
  1162.                 case InternalPrimitiveTypeE.Int16:
  1163.                     value = (int16A[index]).ToString(CultureInfo.InvariantCulture);
  1164.                     break;
  1165.                 case InternalPrimitiveTypeE.Int32:
  1166.                     value = (int32A[index]).ToString(CultureInfo.InvariantCulture);
  1167.                     break;
  1168.                 case InternalPrimitiveTypeE.Int64:
  1169.                     value = (int64A[index]).ToString(CultureInfo.InvariantCulture);
  1170.                     break;
  1171.                 case InternalPrimitiveTypeE.SByte:
  1172.                     value = (sbyteA[index]).ToString(CultureInfo.InvariantCulture);
  1173.                     break;
  1174.                 case InternalPrimitiveTypeE.Single:
  1175.                     if (Single.IsPositiveInfinity(singleA[index]))
  1176.                         value = "INF";
  1177.                     else if (Single.IsNegativeInfinity(singleA[index]))
  1178.                         value = "-INF";
  1179.                     else
  1180.                         value = (singleA[index]).ToString("R", CultureInfo.InvariantCulture);
  1181.                     break;
  1182.                 case InternalPrimitiveTypeE.UInt16:
  1183.                     value = (uint16A[index]).ToString(CultureInfo.InvariantCulture);
  1184.                     break;
  1185.                 case InternalPrimitiveTypeE.UInt32:
  1186.                     value = (uint32A[index]).ToString(CultureInfo.InvariantCulture);
  1187.                     break;
  1188.                 case InternalPrimitiveTypeE.UInt64:
  1189.                     value = (uint64A[index]).ToString(CultureInfo.InvariantCulture);
  1190.                     break;
  1191.             }
  1192.             return value;
  1193.         }
  1194.        
  1195.         internal void SetValue(string value, int index)
  1196.         {
  1197.             InternalST.Soap("PrimitiveArray value ", value, " index ", index, " code ", ((Enum)code).ToString());
  1198.             switch (code) {
  1199.                 case InternalPrimitiveTypeE.Boolean:
  1200.                     booleanA[index] = Boolean.Parse(value);
  1201.                     break;
  1202.                 case InternalPrimitiveTypeE.Char:
  1203.                     if ((value[0] == '_') && (value.Equals("_0x00_")))
  1204.                         charA[index] = Char.MinValue;
  1205.                     else
  1206.                         charA[index] = Char.Parse(value);
  1207.                     break;
  1208.                 case InternalPrimitiveTypeE.Double:
  1209.                     if (value == "INF")
  1210.                         doubleA[index] = Double.PositiveInfinity;
  1211.                     else if (value == "-INF")
  1212.                         doubleA[index] = Double.NegativeInfinity;
  1213.                     else
  1214.                         doubleA[index] = Double.Parse(value, CultureInfo.InvariantCulture);
  1215.                     break;
  1216.                 case InternalPrimitiveTypeE.Int16:
  1217.                     int16A[index] = Int16.Parse(value, CultureInfo.InvariantCulture);
  1218.                     break;
  1219.                 case InternalPrimitiveTypeE.Int32:
  1220.                     int32A[index] = Int32.Parse(value, CultureInfo.InvariantCulture);
  1221.                     break;
  1222.                 case InternalPrimitiveTypeE.Int64:
  1223.                     int64A[index] = Int64.Parse(value, CultureInfo.InvariantCulture);
  1224.                     break;
  1225.                 case InternalPrimitiveTypeE.SByte:
  1226.                     sbyteA[index] = SByte.Parse(value, CultureInfo.InvariantCulture);
  1227.                     break;
  1228.                 case InternalPrimitiveTypeE.Single:
  1229.                     if (value == "INF")
  1230.                         singleA[index] = Single.PositiveInfinity;
  1231.                     else if (value == "-INF")
  1232.                         singleA[index] = Single.NegativeInfinity;
  1233.                     else
  1234.                         singleA[index] = Single.Parse(value, CultureInfo.InvariantCulture);
  1235.                     break;
  1236.                 case InternalPrimitiveTypeE.UInt16:
  1237.                     uint16A[index] = UInt16.Parse(value, CultureInfo.InvariantCulture);
  1238.                     break;
  1239.                 case InternalPrimitiveTypeE.UInt32:
  1240.                     uint32A[index] = UInt32.Parse(value, CultureInfo.InvariantCulture);
  1241.                     break;
  1242.                 case InternalPrimitiveTypeE.UInt64:
  1243.                     uint64A[index] = UInt64.Parse(value, CultureInfo.InvariantCulture);
  1244.                     break;
  1245.             }
  1246.         }
  1247.     }
  1248. }

Developer Fusion