The Labs \ Source Viewer \ SSCLI \ System.Runtime.Serialization.Formatters.Binary \ NameCache

  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: CommonClasses
  18. **
  19. **
  20. ** Purpose: utility classes
  21. **
  22. **
  23. ===========================================================*/
  24. // All classes and methods in here are only for the internal use by the XML and Binary Formatters.
  25. // They are public so that the XMLFormatter can address them. Eventually they will
  26. // be signed so that they can't be used by external applications.
  27. namespace System.Runtime.Serialization.Formatters.Binary
  28. {
  29.     using System;
  30.     using System.Collections;
  31.     using System.Reflection;
  32.     using System.Text;
  33.     using System.Globalization;
  34.     using System.Runtime.Serialization.Formatters;
  35.     using System.Runtime.Remoting;
  36.     using System.Runtime.Remoting.Messaging;
  37.     using System.Runtime.InteropServices;
  38.     using System.Runtime.Serialization;
  39.     using System.Diagnostics;
  40.    
  41.     // The ParseRecord class holds the parsed XML information. There is a
  42.     // ParsedRecord for each XML Element
  43.     internal sealed class ParseRecord : ITrace
  44.     {
  45.         #if _DEBUG
  46.         #endif
  47.         static internal int parseRecordIdCount = 1;
  48.        
  49.        
  50.         internal int PRparseRecordId = 0;
  51.        
  52.         // Enums
  53.         internal InternalParseTypeE PRparseTypeEnum = InternalParseTypeE.Empty;
  54.         internal InternalObjectTypeE PRobjectTypeEnum = InternalObjectTypeE.Empty;
  55.         internal InternalArrayTypeE PRarrayTypeEnum = InternalArrayTypeE.Empty;
  56.         internal InternalMemberTypeE PRmemberTypeEnum = InternalMemberTypeE.Empty;
  57.         internal InternalMemberValueE PRmemberValueEnum = InternalMemberValueE.Empty;
  58.         internal InternalObjectPositionE PRobjectPositionEnum = InternalObjectPositionE.Empty;
  59.        
  60.         // Object
  61.         internal string PRname;
  62.        
  63.         // Value
  64.         internal string PRvalue;
  65.         internal object PRvarValue;
  66.        
  67.         // dt attribute
  68.         internal string PRkeyDt;
  69.         internal Type PRdtType;
  70.         internal InternalPrimitiveTypeE PRdtTypeCode;
  71.         internal bool PRisVariant = false;
  72.         // Used by Binary
  73.         internal bool PRisEnum = false;
  74.        
  75.         // Object ID
  76.         internal long PRobjectId;
  77.        
  78.         // Reference ID
  79.         internal long PRidRef;
  80.        
  81.         // Array
  82.        
  83.         // Array Element Type
  84.         internal string PRarrayElementTypeString;
  85.         internal Type PRarrayElementType;
  86.         internal bool PRisArrayVariant = false;
  87.         internal InternalPrimitiveTypeE PRarrayElementTypeCode;
  88.        
  89.         // Parsed array information
  90.         internal int PRrank;
  91.         internal int[] PRlengthA;
  92.         internal int[] PRpositionA;
  93.         internal int[] PRlowerBoundA;
  94.         internal int[] PRupperBoundA;
  95.        
  96.         // Array map for placing array elements in array
  97.         internal int[] PRindexMap;
  98.         internal int PRmemberIndex;
  99.         internal int PRlinearlength;
  100.         internal int[] PRrectangularMap;
  101.         internal bool PRisLowerBound;
  102.        
  103.         // SerializedStreamHeader information
  104.         internal long PRtopId;
  105.         internal long PRheaderId;
  106.        
  107.        
  108.         // MemberInfo accumulated during parsing of members
  109.        
  110.         internal ReadObjectInfo PRobjectInfo;
  111.        
  112.         // ValueType Fixup needed
  113.         internal bool PRisValueTypeFixup = false;
  114.        
  115.         // Created object
  116.         internal object PRnewObj;
  117.         internal object[] PRobjectA;
  118.         //optimization, will contain object[]
  119.         internal PrimitiveArray PRprimitiveArray;
  120.         // for Primitive Soap arrays, optimization
  121.         internal bool PRisRegistered;
  122.         // Used when registering nested classes
  123.         internal object[] PRmemberData;
  124.         // member data is collected here before populating
  125.         internal SerializationInfo PRsi;
  126.        
  127.         internal int PRnullCount;
  128.         // Count of consecutive nulls within an array
  129.        
  130.         internal ParseRecord()
  131.         {
  132.         }
  133.        
  134.        
  135.         #if _DEBUG
  136.         // Get a String describing the ParseRecord
  137.         // ITrace
  138.         public string Trace()
  139.         {
  140.             return "ParseRecord" + PRparseRecordId + " ParseType " + ((Enum)PRparseTypeEnum).ToString() + " name " + PRname + " keyDt " + Util.PString(PRkeyDt);
  141.         }
  142.         #endif
  143.        
  144.         // Initialize ParseRecord. Called when reusing.
  145.         internal void Init()
  146.         {
  147.             // Enums
  148.             PRparseTypeEnum = InternalParseTypeE.Empty;
  149.             PRobjectTypeEnum = InternalObjectTypeE.Empty;
  150.             PRarrayTypeEnum = InternalArrayTypeE.Empty;
  151.             PRmemberTypeEnum = InternalMemberTypeE.Empty;
  152.             PRmemberValueEnum = InternalMemberValueE.Empty;
  153.             PRobjectPositionEnum = InternalObjectPositionE.Empty;
  154.            
  155.             // Object
  156.             PRname = null;
  157.            
  158.             // Value
  159.             PRvalue = null;
  160.            
  161.             // dt attribute
  162.             PRkeyDt = null;
  163.             PRdtType = null;
  164.             PRdtTypeCode = InternalPrimitiveTypeE.Invalid;
  165.             PRisEnum = false;
  166.            
  167.             // Object ID
  168.             PRobjectId = 0;
  169.            
  170.             // Reference ID
  171.             PRidRef = 0;
  172.            
  173.             // Array
  174.            
  175.             // Array Element Type
  176.             PRarrayElementTypeString = null;
  177.             PRarrayElementType = null;
  178.             PRisArrayVariant = false;
  179.             PRarrayElementTypeCode = InternalPrimitiveTypeE.Invalid;
  180.            
  181.            
  182.             // Parsed array information
  183.             PRrank = 0;
  184.             PRlengthA = null;
  185.             PRpositionA = null;
  186.             PRlowerBoundA = null;
  187.             PRupperBoundA = null;
  188.            
  189.             // Array map for placing array elements in array
  190.             PRindexMap = null;
  191.             PRmemberIndex = 0;
  192.             PRlinearlength = 0;
  193.             PRrectangularMap = null;
  194.             PRisLowerBound = false;
  195.            
  196.             // SerializedStreamHeader information
  197.             PRtopId = 0;
  198.             PRheaderId = 0;
  199.            
  200.             // ValueType Fixup needed
  201.             PRisValueTypeFixup = false;
  202.            
  203.             PRnewObj = null;
  204.             PRobjectA = null;
  205.             PRprimitiveArray = null;
  206.             PRobjectInfo = null;
  207.             PRisRegistered = false;
  208.             PRmemberData = null;
  209.             PRsi = null;
  210.            
  211.             PRnullCount = 0;
  212.         }
  213.        
  214.         #if _DEBUG // Dump ParseRecord.
  215.         [Conditional("SER_LOGGING")]
  216.         internal void Dump()
  217.         {
  218.             SerTrace.Log("ParseRecord Dump ", PRparseRecordId);
  219.             SerTrace.Log("Enums");
  220.             Util.NVTrace("ParseType", ((Enum)PRparseTypeEnum).ToString());
  221.             Util.NVTrace("ObjectType", ((Enum)PRobjectTypeEnum).ToString());
  222.             Util.NVTrace("ArrayType", ((Enum)PRarrayTypeEnum).ToString());
  223.             Util.NVTrace("MemberType", ((Enum)PRmemberTypeEnum).ToString());
  224.             Util.NVTrace("MemberValue", ((Enum)PRmemberValueEnum).ToString());
  225.             Util.NVTrace("ObjectPosition", ((Enum)PRobjectPositionEnum).ToString());
  226.             SerTrace.Log("Basics");
  227.             Util.NVTrace("Name", PRname);
  228.             Util.NVTrace("Value ", PRvalue);
  229.             Util.NVTrace("varValue ", PRvarValue);
  230.             if (PRvarValue != null)
  231.                 Util.NVTrace("varValue type", PRvarValue.GetType());
  232.            
  233.             Util.NVTrace("keyDt", PRkeyDt);
  234.             Util.NVTrace("dtType", PRdtType);
  235.             Util.NVTrace("code", ((Enum)PRdtTypeCode).ToString());
  236.             Util.NVTrace("objectID", PRobjectId);
  237.             Util.NVTrace("idRef", PRidRef);
  238.             Util.NVTrace("isEnum", PRisEnum);
  239.             SerTrace.Log("Array ");
  240.             Util.NVTrace("arrayElementTypeString", PRarrayElementTypeString);
  241.             Util.NVTrace("arrayElementType", PRarrayElementType);
  242.             Util.NVTrace("arrayElementTypeCode", ((Enum)PRarrayElementTypeCode).ToString());
  243.             Util.NVTrace("isArrayVariant", PRisArrayVariant);
  244.             Util.NVTrace("rank", PRrank);
  245.             Util.NVTrace("dimensions", Util.PArray(PRlengthA));
  246.             Util.NVTrace("position", Util.PArray(PRpositionA));
  247.             Util.NVTrace("lowerBoundA", Util.PArray(PRlowerBoundA));
  248.             Util.NVTrace("upperBoundA", Util.PArray(PRupperBoundA));
  249.             SerTrace.Log("Header ");
  250.             Util.NVTrace("nullCount", PRnullCount);
  251.            
  252.             SerTrace.Log("New Object");
  253.             if (PRnewObj != null)
  254.                 Util.NVTrace("newObj", PRnewObj);
  255.         }
  256.         #endif
  257.     }
  258.    
  259.     #if _DEBUG
  260.     internal interface ITrace
  261.     {
  262.         string Trace();
  263.     }
  264.     #endif
  265.    
  266.     // Implements a stack used for parsing
  267.     internal sealed class SerStack
  268.     {
  269.         internal object[] objects = new object[5];
  270.         internal string stackId;
  271.         internal int top = -1;
  272.         internal int next = 0;
  273.        
  274.         internal SerStack()
  275.         {
  276.             stackId = "System";
  277.         }
  278.        
  279.         internal SerStack(string stackId)
  280.         {
  281.             this.stackId = stackId;
  282.         }
  283.        
  284.         // Push the object onto the stack
  285.         internal void Push(object obj)
  286.         {
  287.             #if _DEBUG
  288.             SerTrace.Log(this, "Push ", stackId, " ", ((obj is ITrace) ? ((ITrace)obj).Trace() : ""));
  289.             #endif
  290.             if (top == (objects.Length - 1)) {
  291.                 IncreaseCapacity();
  292.             }
  293.             objects[++top] = obj;
  294.         }
  295.        
  296.         // Pop the object from the stack
  297.         internal object Pop()
  298.         {
  299.             if (top < 0)
  300.                 return null;
  301.            
  302.             object obj = objects[top];
  303.             objects[top--] = null;
  304.             #if _DEBUG
  305.             SerTrace.Log(this, "Pop ", stackId, " ", ((obj is ITrace) ? ((ITrace)obj).Trace() : ""));
  306.             #endif
  307.             return obj;
  308.         }
  309.        
  310.         internal void IncreaseCapacity()
  311.         {
  312.             int size = objects.Length * 2;
  313.             object[] newItems = new object[size];
  314.             Array.Copy(objects, 0, newItems, 0, objects.Length);
  315.             objects = newItems;
  316.         }
  317.        
  318.         // Gets the object on the top of the stack
  319.         internal object Peek()
  320.         {
  321.             if (top < 0)
  322.                 return null;
  323.             #if _DEBUG
  324.             SerTrace.Log(this, "Peek ", stackId, " ", ((objects[top] is ITrace) ? ((ITrace)objects[top]).Trace() : ""));
  325.             #endif
  326.             return objects[top];
  327.         }
  328.        
  329.         // Gets the second entry in the stack.
  330.         internal object PeekPeek()
  331.         {
  332.             if (top < 1)
  333.                 return null;
  334.             #if _DEBUG
  335.             SerTrace.Log(this, "PeekPeek ", stackId, " ", ((objects[top - 1] is ITrace) ? ((ITrace)objects[top - 1]).Trace() : ""));
  336.             #endif
  337.             return objects[top - 1];
  338.         }
  339.        
  340.         // The number of entries in the stack
  341.         internal int Count()
  342.         {
  343.             return top + 1;
  344.         }
  345.        
  346.         // The number of entries in the stack
  347.         internal bool IsEmpty()
  348.         {
  349.             if (top > 0)
  350.                 return false;
  351.             else
  352.                 return true;
  353.         }
  354.        
  355.         [Conditional("SER_LOGGING")]
  356.         internal void Dump()
  357.         {
  358.             for (int i = 0; i < Count(); i++) {
  359.                 object obj = objects[i];
  360.                 #if _DEBUG
  361.                 SerTrace.Log(this, "Stack Dump ", stackId, " " + ((obj is ITrace) ? ((ITrace)obj).Trace() : ""));
  362.                 #endif
  363.             }
  364.         }
  365.     }
  366.    
  367.    
  368.     // Implements a Growable array
  369.    
  370.     [Serializable()]
  371.     internal sealed class SizedArray : ICloneable
  372.     {
  373.         internal object[] objects = null;
  374.         internal object[] negObjects = null;
  375.        
  376.         internal SizedArray()
  377.         {
  378.             objects = new object[16];
  379.             negObjects = new object[4];
  380.         }
  381.        
  382.         internal SizedArray(int length)
  383.         {
  384.             objects = new object[length];
  385.             negObjects = new object[length];
  386.         }
  387.        
  388.         private SizedArray(SizedArray sizedArray)
  389.         {
  390.             objects = new object[sizedArray.objects.Length];
  391.             sizedArray.objects.CopyTo(objects, 0);
  392.             negObjects = new object[sizedArray.negObjects.Length];
  393.             sizedArray.negObjects.CopyTo(negObjects, 0);
  394.         }
  395.        
  396.         public object Clone()
  397.         {
  398.             return new SizedArray(this);
  399.         }
  400.        
  401.         internal object this[int index]
  402.         {
  403.             get {
  404.                 if (index < 0) {
  405.                     if (-index > negObjects.Length - 1)
  406.                         return null;
  407.                     return negObjects[-index];
  408.                 }
  409.                 else {
  410.                     if (index > objects.Length - 1)
  411.                         return null;
  412.                     return objects[index];
  413.                 }
  414.             }
  415.             set {
  416.                 if (index < 0) {
  417.                     if (-index > negObjects.Length - 1) {
  418.                         IncreaseCapacity(index);
  419.                     }
  420.                     negObjects[-index] = value;
  421.                    
  422.                 }
  423.                 else {
  424.                     if (index > objects.Length - 1) {
  425.                         IncreaseCapacity(index);
  426.                     }
  427.                     if (objects[index] != null) {
  428.                         //Console.WriteLine("SizedArray Setting a non-zero "+index+" "+value);
  429.                     }
  430.                     objects[index] = value;
  431.                 }
  432.             }
  433.         }
  434.        
  435.         internal void IncreaseCapacity(int index)
  436.         {
  437.             try {
  438.                 if (index < 0) {
  439.                     int size = Math.Max(negObjects.Length * 2, (-index) + 1);
  440.                     object[] newItems = new object[size];
  441.                     Array.Copy(negObjects, 0, newItems, 0, negObjects.Length);
  442.                     negObjects = newItems;
  443.                 }
  444.                 else {
  445.                     int size = Math.Max(objects.Length * 2, index + 1);
  446.                     object[] newItems = new object[size];
  447.                     Array.Copy(objects, 0, newItems, 0, objects.Length);
  448.                     objects = newItems;
  449.                 }
  450.             }
  451.             catch (Exception) {
  452.                 throw new SerializationException(Environment.GetResourceString("Serialization_CorruptedStream"));
  453.             }
  454.         }
  455.        
  456.     }
  457.    
  458.     [Serializable()]
  459.     internal sealed class IntSizedArray : ICloneable
  460.     {
  461.         internal int[] objects = new int[16];
  462.         internal int[] negObjects = new int[4];
  463.        
  464.         public IntSizedArray()
  465.         {
  466.         }
  467.        
  468.         private IntSizedArray(IntSizedArray sizedArray)
  469.         {
  470.             objects = new int[sizedArray.objects.Length];
  471.             sizedArray.objects.CopyTo(objects, 0);
  472.             negObjects = new int[sizedArray.negObjects.Length];
  473.             sizedArray.negObjects.CopyTo(negObjects, 0);
  474.         }
  475.        
  476.         public object Clone()
  477.         {
  478.             return new IntSizedArray(this);
  479.         }
  480.        
  481.        
  482.         internal int this[int index]
  483.         {
  484.             get {
  485.                 if (index < 0) {
  486.                     if (-index > negObjects.Length - 1)
  487.                         return 0;
  488.                     return negObjects[-index];
  489.                 }
  490.                 else {
  491.                     if (index > objects.Length - 1)
  492.                         return 0;
  493.                     return objects[index];
  494.                 }
  495.             }
  496.             set {
  497.                 if (index < 0) {
  498.                     if (-index > negObjects.Length - 1) {
  499.                         IncreaseCapacity(index);
  500.                     }
  501.                     negObjects[-index] = value;
  502.                    
  503.                 }
  504.                 else {
  505.                     if (index > objects.Length - 1) {
  506.                         IncreaseCapacity(index);
  507.                     }
  508.                     objects[index] = value;
  509.                 }
  510.             }
  511.         }
  512.        
  513.         internal void IncreaseCapacity(int index)
  514.         {
  515.             try {
  516.                 if (index < 0) {
  517.                     int size = Math.Max(negObjects.Length * 2, (-index) + 1);
  518.                     int[] newItems = new int[size];
  519.                     Array.Copy(negObjects, 0, newItems, 0, negObjects.Length);
  520.                     negObjects = newItems;
  521.                 }
  522.                 else {
  523.                     int size = Math.Max(objects.Length * 2, index + 1);
  524.                     int[] newItems = new int[size];
  525.                     Array.Copy(objects, 0, newItems, 0, objects.Length);
  526.                     objects = newItems;
  527.                 }
  528.             }
  529.             catch (Exception) {
  530.                 throw new SerializationException(Environment.GetResourceString("Serialization_CorruptedStream"));
  531.             }
  532.         }
  533.     }
  534.    
  535.     internal sealed class NameCache
  536.     {
  537.         static System.Collections.Hashtable ht = new System.Collections.Hashtable();
  538.         string name = null;
  539.        
  540.         internal object GetCachedValue(string name)
  541.         {
  542.             this.name = name;
  543.             return ht[name];
  544.         }
  545.        
  546.         internal void SetCachedValue(object value)
  547.         {
  548.             ht[name] = value;
  549.         }
  550.     }
  551.    
  552.    
  553.     #if _DEBUG
  554.     // Utilities
  555.     static internal class Util
  556.     {
  557.         // Replaces a null string with an empty string
  558.         static internal string PString(string value)
  559.         {
  560.             if (value == null)
  561.                 return "";
  562.             else
  563.                 return value;
  564.         }
  565.        
  566.         // Converts an object to a string and checks for nulls
  567.        
  568.         static internal string PString(object value)
  569.         {
  570.             if (value == null)
  571.                 return "";
  572.             else
  573.                 return value.ToString();
  574.         }
  575.        
  576.         // Converts a single int array to a string
  577.        
  578.         static internal string PArray(int[] array)
  579.         {
  580.             if (array != null) {
  581.                 StringBuilder sb = new StringBuilder(10);
  582.                 sb.Append("[");
  583.                 for (int i = 0; i < array.Length; i++) {
  584.                     sb.Append(array[i]);
  585.                     if (i != array.Length - 1)
  586.                         sb.Append(",");
  587.                 }
  588.                 sb.Append("]");
  589.                 return sb.ToString();
  590.             }
  591.             else
  592.                 return "";
  593.         }
  594.        
  595.         // Traces an name value pair
  596.        
  597.         [Conditional("SER_LOGGING")]
  598.         static internal void NVTrace(string name, string value)
  599.         {
  600.             SerTrace.Log(" " + name + ((value == null) ? " = null" : " = " + value));
  601.         }
  602.        
  603.         // Traces an name value pair
  604.         [Conditional("SER_LOGGING")]
  605.         static internal void NVTrace(string name, object value)
  606.         {
  607.             SerTrace.Log(" " + name + ((value == null) ? " = null" : " = " + value.ToString()));
  608.         }
  609.        
  610.         // Traces an name value pair
  611.        
  612.         [Conditional("_LOGGING")]
  613.         static internal void NVTraceI(string name, string value)
  614.         {
  615.             BCLDebug.Trace("Binary", " " + name + ((value == null) ? " = null" : " = " + value));
  616.         }
  617.        
  618.         // Traces an name value pair
  619.         [Conditional("_LOGGING")]
  620.         static internal void NVTraceI(string name, object value)
  621.         {
  622.             BCLDebug.Trace("Binary", " " + name + ((value == null) ? " = null" : " = " + value.ToString()));
  623.         }
  624.     }
  625.     #endif
  626.    
  627.    
  628.     // Used to fixup value types. Only currently used for valuetypes which are array items.
  629.     internal sealed class ValueFixup
  630.     {
  631.         internal ValueFixupEnum valueFixupEnum = ValueFixupEnum.Empty;
  632.         internal Array arrayObj;
  633.         internal int[] indexMap;
  634.         internal object header = null;
  635.         internal object memberObject;
  636.         static internal MemberInfo valueInfo;
  637.         internal ReadObjectInfo objectInfo;
  638.         internal string memberName;
  639.        
  640.         internal ValueFixup(Array arrayObj, int[] indexMap)
  641.         {
  642.             #if _DEBUG
  643.             SerTrace.Log(this, "Array Constructor ", arrayObj);
  644.             #endif
  645.             valueFixupEnum = ValueFixupEnum.Array;
  646.             this.arrayObj = arrayObj;
  647.             this.indexMap = indexMap;
  648.         }
  649.        
  650.         internal ValueFixup(object memberObject, string memberName, ReadObjectInfo objectInfo)
  651.         {
  652.             #if _DEBUG
  653.             SerTrace.Log(this, "Member Constructor ", memberObject);
  654.             #endif
  655.             valueFixupEnum = ValueFixupEnum.Member;
  656.             this.memberObject = memberObject;
  657.             this.memberName = memberName;
  658.             this.objectInfo = objectInfo;
  659.         }
  660.        
  661.         internal void Fixup(ParseRecord record, ParseRecord parent)
  662.         {
  663.             object obj = record.PRnewObj;
  664.             #if _DEBUG
  665.             SerTrace.Log(this, "Fixup ", obj, " ", ((Enum)valueFixupEnum).ToString());
  666.             #endif
  667.             switch (valueFixupEnum) {
  668.                 case ValueFixupEnum.Array:
  669.                     arrayObj.SetValue(obj, indexMap);
  670.                     break;
  671.                 case ValueFixupEnum.Header:
  672.                     Type type = typeof(Header);
  673.                     if (valueInfo == null) {
  674.                         MemberInfo[] valueInfos = type.GetMember("Value");
  675.                         if (valueInfos.Length != 1)
  676.                             throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_HeaderReflection"), valueInfos.Length));
  677.                         valueInfo = valueInfos[0];
  678.                     }
  679.                     FormatterServices.SerializationSetValue(valueInfo, header, obj);
  680.                     break;
  681.                 case ValueFixupEnum.Member:
  682.                     SerTrace.Log(this, "Fixup Member new object value ", obj, " memberObject ", memberObject);
  683.                    
  684.                     if (objectInfo.isSi) {
  685.                         SerTrace.Log(this, "Recording a fixup on member: ", memberName, " in object id", parent.PRobjectId, " Required Object ", record.PRobjectId);
  686.                         objectInfo.objectManager.RecordDelayedFixup(parent.PRobjectId, memberName, record.PRobjectId);
  687.                         // Console.WriteLine("SerializationInfo: Main Object ({0}): {1}. SubObject ({2}): {3}", parent.PRobjectId,
  688.                         // objectInfo.obj, record.PRobjectId, obj);
  689.                     }
  690.                     else {
  691.                         MemberInfo memberInfo = objectInfo.GetMemberInfo(memberName);
  692.                         SerTrace.Log(this, "Recording a fixup on member:", memberInfo, " in object id ", parent.PRobjectId, " Required Object", record.PRobjectId);
  693.                         if (memberInfo != null)
  694.                             objectInfo.objectManager.RecordFixup(parent.PRobjectId, memberInfo, record.PRobjectId);
  695.                         // Console.WriteLine("MemberFixup: Main Object({0}): {1}. SubObject({2}): {3}", parent.PRobjectId,
  696.                         // objectInfo.obj.GetType(), record.PRobjectId, obj.GetType());
  697.                        
  698.                     }
  699.                     break;
  700.             }
  701.         }
  702.        
  703.         #if _DEBUG
  704.         public string Trace()
  705.         {
  706.             return "ValueFixup" + ((Enum)valueFixupEnum).ToString();
  707.         }
  708.         #endif
  709.     }
  710.    
  711.     // Class used to transmit Enums from the XML and Binary Formatter class to the ObjectWriter and ObjectReader class
  712.     internal sealed class InternalFE
  713.     {
  714.         internal FormatterTypeStyle FEtypeFormat;
  715.         internal FormatterAssemblyStyle FEassemblyFormat;
  716.         internal TypeFilterLevel FEsecurityLevel;
  717.         internal InternalSerializerTypeE FEserializerTypeEnum;
  718.     }
  719.    
  720.    
  721.     internal sealed class NameInfo
  722.     {
  723.         internal string NIFullName;
  724.         // Name from SerObjectInfo.GetType
  725.         internal long NIobjectId;
  726.         internal long NIassemId;
  727.         internal InternalPrimitiveTypeE NIprimitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
  728.         internal Type NItype;
  729.         internal bool NIisSealed;
  730.         internal bool NIisArray;
  731.         internal bool NIisArrayItem;
  732.         internal bool NItransmitTypeOnObject;
  733.         internal bool NItransmitTypeOnMember;
  734.         internal bool NIisParentTypeOnObject;
  735.         internal InternalArrayTypeE NIarrayEnum;
  736.        
  737.         internal NameInfo()
  738.         {
  739.         }
  740.        
  741.        
  742.         internal void Init()
  743.         {
  744.             NIFullName = null;
  745.             NIobjectId = 0;
  746.             NIassemId = 0;
  747.             NIprimitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
  748.             NItype = null;
  749.             NIisSealed = false;
  750.             NItransmitTypeOnObject = false;
  751.             NItransmitTypeOnMember = false;
  752.             NIisParentTypeOnObject = false;
  753.             NIisArray = false;
  754.             NIisArrayItem = false;
  755.             NIarrayEnum = InternalArrayTypeE.Empty;
  756.             NIsealedStatusChecked = false;
  757.         }
  758.        
  759.         #if _DEBUG
  760.         [Conditional("SER_LOGGING")]
  761.         internal void Dump(string value)
  762.         {
  763.             Util.NVTrace("name", NIFullName);
  764.             Util.NVTrace("objectId", NIobjectId);
  765.             Util.NVTrace("assemId", NIassemId);
  766.             Util.NVTrace("primitiveTypeEnum", ((Enum)NIprimitiveTypeEnum).ToString());
  767.             Util.NVTrace("type", NItype);
  768.             Util.NVTrace("isSealed", NIisSealed);
  769.             Util.NVTrace("transmitTypeOnObject", NItransmitTypeOnObject);
  770.             Util.NVTrace("transmitTypeOnMember", NItransmitTypeOnMember);
  771.             Util.NVTrace("isParentTypeOnObject", NIisParentTypeOnObject);
  772.             Util.NVTrace("isArray", NIisArray);
  773.             Util.NVTrace("isArrayItem", NIisArrayItem);
  774.             Util.NVTrace("arrayEnum", ((Enum)NIarrayEnum).ToString());
  775.         }
  776.         #endif
  777.         private bool NIsealedStatusChecked = false;
  778.         public bool IsSealed {
  779.             get {
  780.                 if (!NIsealedStatusChecked) {
  781.                     NIisSealed = NItype.IsSealed;
  782.                     NIsealedStatusChecked = true;
  783.                 }
  784.                 return NIisSealed;
  785.             }
  786.         }
  787.        
  788.         public string NIname {
  789.             get {
  790.                 if (this.NIFullName == null)
  791.                     this.NIFullName = NItype.FullName;
  792.                
  793.                 return this.NIFullName;
  794.             }
  795.             set { this.NIFullName = value; }
  796.         }
  797.     }
  798.    
  799.     internal sealed class PrimitiveArray
  800.     {
  801.         InternalPrimitiveTypeE code;
  802.         bool[] booleanA = null;
  803.         char[] charA = null;
  804.         double[] doubleA = null;
  805.         Int16[] int16A = null;
  806.         Int32[] int32A = null;
  807.         Int64[] int64A = null;
  808.         sbyte[] sbyteA = null;
  809.         float[] singleA = null;
  810.         UInt16[] uint16A = null;
  811.         UInt32[] uint32A = null;
  812.         UInt64[] uint64A = null;
  813.        
  814.        
  815.         internal PrimitiveArray(InternalPrimitiveTypeE code, Array array)
  816.         {
  817.             Init(code, array);
  818.         }
  819.        
  820.         internal void Init(InternalPrimitiveTypeE code, Array array)
  821.         {
  822.             this.code = code;
  823.             switch (code) {
  824.                 case InternalPrimitiveTypeE.Boolean:
  825.                     booleanA = (bool[])array;
  826.                     break;
  827.                 case InternalPrimitiveTypeE.Char:
  828.                     charA = (char[])array;
  829.                     break;
  830.                 case InternalPrimitiveTypeE.Double:
  831.                     doubleA = (double[])array;
  832.                     break;
  833.                 case InternalPrimitiveTypeE.Int16:
  834.                     int16A = (Int16[])array;
  835.                     break;
  836.                 case InternalPrimitiveTypeE.Int32:
  837.                     int32A = (Int32[])array;
  838.                     break;
  839.                 case InternalPrimitiveTypeE.Int64:
  840.                     int64A = (Int64[])array;
  841.                     break;
  842.                 case InternalPrimitiveTypeE.SByte:
  843.                     sbyteA = (sbyte[])array;
  844.                     break;
  845.                 case InternalPrimitiveTypeE.Single:
  846.                     singleA = (float[])array;
  847.                     break;
  848.                 case InternalPrimitiveTypeE.UInt16:
  849.                     uint16A = (UInt16[])array;
  850.                     break;
  851.                 case InternalPrimitiveTypeE.UInt32:
  852.                     uint32A = (UInt32[])array;
  853.                     break;
  854.                 case InternalPrimitiveTypeE.UInt64:
  855.                     uint64A = (UInt64[])array;
  856.                     break;
  857.             }
  858.         }
  859.        
  860.         internal void SetValue(string value, int index)
  861.         {
  862.             switch (code) {
  863.                 case InternalPrimitiveTypeE.Boolean:
  864.                     booleanA[index] = Boolean.Parse(value);
  865.                     break;
  866.                 case InternalPrimitiveTypeE.Char:
  867.                     if ((value[0] == '_') && (value.Equals("_0x00_")))
  868.                         charA[index] = Char.MinValue;
  869.                     else
  870.                         charA[index] = Char.Parse(value);
  871.                     break;
  872.                 case InternalPrimitiveTypeE.Double:
  873.                     doubleA[index] = Double.Parse(value, CultureInfo.InvariantCulture);
  874.                     break;
  875.                 case InternalPrimitiveTypeE.Int16:
  876.                     int16A[index] = Int16.Parse(value, CultureInfo.InvariantCulture);
  877.                     break;
  878.                 case InternalPrimitiveTypeE.Int32:
  879.                     int32A[index] = Int32.Parse(value, CultureInfo.InvariantCulture);
  880.                     break;
  881.                 case InternalPrimitiveTypeE.Int64:
  882.                     int64A[index] = Int64.Parse(value, CultureInfo.InvariantCulture);
  883.                     break;
  884.                 case InternalPrimitiveTypeE.SByte:
  885.                     sbyteA[index] = SByte.Parse(value, CultureInfo.InvariantCulture);
  886.                     break;
  887.                 case InternalPrimitiveTypeE.Single:
  888.                     singleA[index] = Single.Parse(value, CultureInfo.InvariantCulture);
  889.                     break;
  890.                 case InternalPrimitiveTypeE.UInt16:
  891.                     uint16A[index] = UInt16.Parse(value, CultureInfo.InvariantCulture);
  892.                     break;
  893.                 case InternalPrimitiveTypeE.UInt32:
  894.                     uint32A[index] = UInt32.Parse(value, CultureInfo.InvariantCulture);
  895.                     break;
  896.                 case InternalPrimitiveTypeE.UInt64:
  897.                     uint64A[index] = UInt64.Parse(value, CultureInfo.InvariantCulture);
  898.                     break;
  899.             }
  900.         }
  901.     }
  902. }

Developer Fusion