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

  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: CommonBinaryClasses
  18. **
  19. **
  20. ** Purpose: utility classes
  21. **
  22. **
  23. ===========================================================*/
  24. namespace System.Runtime.Serialization.Formatters.Binary
  25. {
  26.    
  27.     using System;
  28.     using System.IO;
  29.     using System.Runtime.Serialization.Formatters;
  30.     using System.Text;
  31.     using System.Collections;
  32.     using System.Reflection;
  33.     using System.Diagnostics;
  34.     using System.Runtime.Remoting.Messaging;
  35.     using System.Globalization;
  36.    
  37.     // Routines to convert between the runtime type and the type as it appears on the wire
  38.     static internal class BinaryConverter
  39.     {
  40.        
  41.         // From the type create the BinaryTypeEnum and typeInformation which describes the type on the wire
  42.        
  43.         static internal BinaryTypeEnum GetBinaryTypeInfo(Type type, WriteObjectInfo objectInfo, string typeName, ObjectWriter objectWriter, out object typeInformation, out int assemId)
  44.         {
  45.             SerTrace.Log("BinaryConverter", "GetBinaryTypeInfo Entry type ", type, ", typeName ", typeName, " objectInfo " + objectInfo);
  46.             BinaryTypeEnum binaryTypeEnum;
  47.            
  48.             assemId = 0;
  49.             typeInformation = null;
  50.            
  51.             if (type == Converter.typeofString)
  52.                 binaryTypeEnum = BinaryTypeEnum.String;
  53.             else if (((objectInfo == null) || ((objectInfo != null) && !objectInfo.isSi)) && (type == Converter.typeofObject)) {
  54.                 // If objectInfo.Si then can be a surrogate which will change the type
  55.                 binaryTypeEnum = BinaryTypeEnum.Object;
  56.             }
  57.             else if (type == Converter.typeofStringArray)
  58.                 binaryTypeEnum = BinaryTypeEnum.StringArray;
  59.             else if (type == Converter.typeofObjectArray)
  60.                 binaryTypeEnum = BinaryTypeEnum.ObjectArray;
  61.             else if (Converter.IsPrimitiveArray(type, out typeInformation))
  62.                 binaryTypeEnum = BinaryTypeEnum.PrimitiveArray;
  63.             else {
  64.                 InternalPrimitiveTypeE primitiveTypeEnum = objectWriter.ToCode(type);
  65.                 switch (primitiveTypeEnum) {
  66.                     case InternalPrimitiveTypeE.Invalid:
  67.                         string assembly = null;
  68.                         if (objectInfo == null) {
  69.                             assembly = type.Assembly.FullName;
  70.                             typeInformation = type.FullName;
  71.                         }
  72.                         else {
  73.                             assembly = objectInfo.GetAssemblyString();
  74.                             typeInformation = objectInfo.GetTypeFullName();
  75.                         }
  76.                        
  77.                         if (assembly.Equals(Converter.urtAssemblyString)) {
  78.                             binaryTypeEnum = BinaryTypeEnum.ObjectUrt;
  79.                             assemId = 0;
  80.                         }
  81.                         else {
  82.                             binaryTypeEnum = BinaryTypeEnum.ObjectUser;
  83.                             BCLDebug.Assert(objectInfo != null, "[BinaryConverter.GetBinaryTypeInfo]objectInfo null for user object");
  84.                             assemId = (int)objectInfo.assemId;
  85.                             if (assemId == 0)
  86.                                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_AssemblyId"), typeInformation));
  87.                         }
  88.                         break;
  89.                     default:
  90.                         binaryTypeEnum = BinaryTypeEnum.Primitive;
  91.                         typeInformation = primitiveTypeEnum;
  92.                         break;
  93.                 }
  94.             }
  95.            
  96.             SerTrace.Log("BinaryConverter", "GetBinaryTypeInfo Exit ", ((Enum)binaryTypeEnum).ToString(), ", typeInformation ", typeInformation, " assemId ", assemId);
  97.             return binaryTypeEnum;
  98.         }
  99.        
  100.        
  101.         // Used for non Si types when Parsing
  102.         static internal BinaryTypeEnum GetParserBinaryTypeInfo(Type type, out object typeInformation)
  103.         {
  104.             SerTrace.Log("BinaryConverter", "GetParserBinaryTypeInfo Entry type ", type);
  105.             BinaryTypeEnum binaryTypeEnum;
  106.             typeInformation = null;
  107.            
  108.             if (type == Converter.typeofString)
  109.                 binaryTypeEnum = BinaryTypeEnum.String;
  110.             else if (type == Converter.typeofObject)
  111.                 binaryTypeEnum = BinaryTypeEnum.Object;
  112.             else if (type == Converter.typeofObjectArray)
  113.                 binaryTypeEnum = BinaryTypeEnum.ObjectArray;
  114.             else if (type == Converter.typeofStringArray)
  115.                 binaryTypeEnum = BinaryTypeEnum.StringArray;
  116.             else if (Converter.IsPrimitiveArray(type, out typeInformation))
  117.                 binaryTypeEnum = BinaryTypeEnum.PrimitiveArray;
  118.             else {
  119.                 InternalPrimitiveTypeE primitiveTypeEnum = Converter.ToCode(type);
  120.                 switch (primitiveTypeEnum) {
  121.                     case InternalPrimitiveTypeE.Invalid:
  122.                         if (Assembly.GetAssembly(type) == Converter.urtAssembly)
  123.                             binaryTypeEnum = BinaryTypeEnum.ObjectUrt;
  124.                         else
  125.                             binaryTypeEnum = BinaryTypeEnum.ObjectUser;
  126.                        
  127.                         typeInformation = type.FullName;
  128.                         break;
  129.                     default:
  130.                         binaryTypeEnum = BinaryTypeEnum.Primitive;
  131.                         typeInformation = primitiveTypeEnum;
  132.                         break;
  133.                 }
  134.             }
  135.            
  136.             SerTrace.Log("BinaryConverter", "GetParserBinaryTypeInfo Exit ", ((Enum)binaryTypeEnum).ToString(), ", typeInformation ", typeInformation);
  137.             return binaryTypeEnum;
  138.         }
  139.        
  140.         // Writes the type information on the wire
  141.         static internal void WriteTypeInfo(BinaryTypeEnum binaryTypeEnum, object typeInformation, int assemId, __BinaryWriter sout)
  142.         {
  143.             SerTrace.Log("BinaryConverter", "WriteTypeInfo Entry ", ((Enum)binaryTypeEnum).ToString(), " ", typeInformation, " assemId ", assemId);
  144.            
  145.             switch (binaryTypeEnum) {
  146.                 case BinaryTypeEnum.Primitive:
  147.                 case BinaryTypeEnum.PrimitiveArray:
  148.                     BCLDebug.Assert(typeInformation != null, "[BinaryConverter.WriteTypeInfo]typeInformation!=null");
  149.                     sout.WriteByte((byte)((InternalPrimitiveTypeE)typeInformation));
  150.                     break;
  151.                 case BinaryTypeEnum.String:
  152.                 case BinaryTypeEnum.Object:
  153.                 case BinaryTypeEnum.StringArray:
  154.                 case BinaryTypeEnum.ObjectArray:
  155.                     break;
  156.                 case BinaryTypeEnum.ObjectUrt:
  157.                     BCLDebug.Assert(typeInformation != null, "[BinaryConverter.WriteTypeInfo]typeInformation!=null");
  158.                     sout.WriteString(typeInformation.ToString());
  159.                     break;
  160.                 case BinaryTypeEnum.ObjectUser:
  161.                     BCLDebug.Assert(typeInformation != null, "[BinaryConverter.WriteTypeInfo]typeInformation!=null");
  162.                     sout.WriteString(typeInformation.ToString());
  163.                     sout.WriteInt32(assemId);
  164.                     break;
  165.                 default:
  166.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_TypeWrite"), ((Enum)binaryTypeEnum).ToString()));
  167.                     break;
  168.             }
  169.             SerTrace.Log("BinaryConverter", "WriteTypeInfo Exit");
  170.         }
  171.        
  172.         // Reads the type information from the wire
  173.         static internal object ReadTypeInfo(BinaryTypeEnum binaryTypeEnum, __BinaryParser input, out int assemId)
  174.         {
  175.             SerTrace.Log("BinaryConverter", "ReadTypeInfo Entry ", ((Enum)binaryTypeEnum).ToString());
  176.             object var = null;
  177.             int readAssemId = 0;
  178.            
  179.             switch (binaryTypeEnum) {
  180.                 case BinaryTypeEnum.Primitive:
  181.                 case BinaryTypeEnum.PrimitiveArray:
  182.                     var = (InternalPrimitiveTypeE)input.ReadByte();
  183.                     break;
  184.                 case BinaryTypeEnum.String:
  185.                 case BinaryTypeEnum.Object:
  186.                 case BinaryTypeEnum.StringArray:
  187.                 case BinaryTypeEnum.ObjectArray:
  188.                     break;
  189.                 case BinaryTypeEnum.ObjectUrt:
  190.                     var = input.ReadString();
  191.                     break;
  192.                 case BinaryTypeEnum.ObjectUser:
  193.                     var = input.ReadString();
  194.                     readAssemId = input.ReadInt32();
  195.                     break;
  196.                 default:
  197.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_TypeRead"), ((Enum)binaryTypeEnum).ToString()));
  198.                     break;
  199.             }
  200.             SerTrace.Log("BinaryConverter", "ReadTypeInfo Exit ", var, " assemId ", readAssemId);
  201.             assemId = readAssemId;
  202.             return var;
  203.         }
  204.        
  205.         // Given the wire type information, returns the actual type and additional information
  206.         static internal void TypeFromInfo(BinaryTypeEnum binaryTypeEnum, object typeInformation, ObjectReader objectReader, BinaryAssemblyInfo assemblyInfo, out InternalPrimitiveTypeE primitiveTypeEnum, out string typeString, out Type type, out bool isVariant)
  207.         {
  208.             SerTrace.Log("BinaryConverter", "TypeFromInfo Entry ", ((Enum)binaryTypeEnum).ToString());
  209.            
  210.             isVariant = false;
  211.             primitiveTypeEnum = InternalPrimitiveTypeE.Invalid;
  212.             typeString = null;
  213.             type = null;
  214.            
  215.             switch (binaryTypeEnum) {
  216.                 case BinaryTypeEnum.Primitive:
  217.                     primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation;
  218.                     typeString = Converter.ToComType(primitiveTypeEnum);
  219.                     type = Converter.ToType(primitiveTypeEnum);
  220.                     break;
  221.                 case BinaryTypeEnum.String:
  222.                     //typeString = "System.String";
  223.                     type = Converter.typeofString;
  224.                     break;
  225.                 case BinaryTypeEnum.Object:
  226.                     //typeString = "System.Object";
  227.                     type = Converter.typeofObject;
  228.                     isVariant = true;
  229.                     break;
  230.                 case BinaryTypeEnum.ObjectArray:
  231.                     //typeString = "System.Object[]";
  232.                     type = Converter.typeofObjectArray;
  233.                     break;
  234.                 case BinaryTypeEnum.StringArray:
  235.                     //typeString = "System.String[]";
  236.                     type = Converter.typeofStringArray;
  237.                     break;
  238.                 case BinaryTypeEnum.PrimitiveArray:
  239.                     primitiveTypeEnum = (InternalPrimitiveTypeE)typeInformation;
  240.                     type = Converter.ToArrayType(primitiveTypeEnum);
  241.                     break;
  242.                 case BinaryTypeEnum.ObjectUser:
  243.                 case BinaryTypeEnum.ObjectUrt:
  244.                     if (typeInformation != null) {
  245.                         typeString = typeInformation.ToString();
  246.                         type = objectReader.GetType(assemblyInfo, typeString);
  247.                         // Temporary for backward compatibility
  248.                         if (type == Converter.typeofObject)
  249.                             isVariant = true;
  250.                     }
  251.                     break;
  252.                 default:
  253.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_TypeRead"), ((Enum)binaryTypeEnum).ToString()));
  254.                     break;
  255.             }
  256.            
  257.             #if _DEBUG
  258.             SerTrace.Log("BinaryConverter", "TypeFromInfo Exit ", ((Enum)primitiveTypeEnum).ToString(), ",typeString ", Util.PString(typeString), ", type ", Util.PString(type), ", isVariant ", isVariant);
  259.             #endif
  260.            
  261.         }
  262.        
  263.         #if _DEBUG
  264.         // Used to write type type on the record dump
  265.         static internal string TypeInfoTraceString(object typeInformation)
  266.         {
  267.             string traceString = null;
  268.             if (typeInformation == null)
  269.                 traceString = "(Null)";
  270.             else if (typeInformation is string)
  271.                 traceString = "(UTF)";
  272.             else
  273.                 traceString = "(Byte)";
  274.             return traceString;
  275.         }
  276.         #endif
  277.        
  278.     }
  279.    
  280.     static internal class IOUtil
  281.     {
  282.         static internal bool FlagTest(MessageEnum flag, MessageEnum target)
  283.         {
  284.             if ((flag & target) == target)
  285.                 return true;
  286.             else
  287.                 return false;
  288.         }
  289.        
  290.         static internal void WriteStringWithCode(string value, __BinaryWriter sout)
  291.         {
  292.             if (value == null)
  293.                 sout.WriteByte((byte)InternalPrimitiveTypeE.Null);
  294.             else {
  295.                 sout.WriteByte((byte)InternalPrimitiveTypeE.String);
  296.                 sout.WriteString(value);
  297.             }
  298.         }
  299.        
  300.         static internal void WriteWithCode(Type type, object value, __BinaryWriter sout)
  301.         {
  302.             if (type == null)
  303.                 sout.WriteByte((byte)InternalPrimitiveTypeE.Null);
  304.             else if (type == Converter.typeofString)
  305.                 WriteStringWithCode((string)value, sout);
  306.             else {
  307.                 InternalPrimitiveTypeE code = Converter.ToCode(type);
  308.                 sout.WriteByte((byte)code);
  309.                 sout.WriteValue(code, value);
  310.             }
  311.         }
  312.        
  313.         static internal object ReadWithCode(__BinaryParser input)
  314.         {
  315.             InternalPrimitiveTypeE code = (InternalPrimitiveTypeE)input.ReadByte();
  316.             if (code == InternalPrimitiveTypeE.Null)
  317.                 return null;
  318.             else if (code == InternalPrimitiveTypeE.String)
  319.                 return input.ReadString();
  320.             else
  321.                 return input.ReadValue(code);
  322.         }
  323.        
  324.         static internal object[] ReadArgs(__BinaryParser input)
  325.         {
  326.             int length = input.ReadInt32();
  327.             object[] args = new object[length];
  328.             for (int i = 0; i < length; i++)
  329.                 args[i] = ReadWithCode(input);
  330.             return args;
  331.         }
  332.        
  333.     }
  334.    
  335.    
  336.     static internal class BinaryUtil
  337.     {
  338.         [Conditional("_LOGGING")]
  339.         public static void NVTraceI(string name, string value)
  340.         {
  341.             if (BCLDebug.CheckEnabled("BINARY"))
  342.                 BCLDebug.Trace("BINARY", " ", name, " = ", value);
  343.         }
  344.        
  345.         // Traces an name value pair
  346.         [Conditional("_LOGGING")]
  347.         public static void NVTraceI(string name, object value)
  348.         {
  349.             if (BCLDebug.CheckEnabled("BINARY"))
  350.                 BCLDebug.Trace("BINARY", " ", name, " = ", value);
  351.         }
  352.        
  353.     }
  354.    
  355.    
  356.     // Interface for Binary Records.
  357.     internal interface IStreamable
  358.     {
  359.         void Read(__BinaryParser input);
  360.         void Write(__BinaryWriter sout);
  361.         #if _DEBUG
  362.         void Dump();
  363.         #endif
  364.     }
  365.    
  366.     internal sealed class BinaryAssemblyInfo
  367.     {
  368.         internal string assemblyString;
  369.         private Assembly assembly;
  370.        
  371.        
  372.         internal BinaryAssemblyInfo(string assemblyString)
  373.         {
  374.             this.assemblyString = assemblyString;
  375.         }
  376.        
  377.         internal BinaryAssemblyInfo(string assemblyString, Assembly assembly)
  378.         {
  379.             this.assemblyString = assemblyString;
  380.             this.assembly = assembly;
  381.         }
  382.        
  383.         internal Assembly GetAssembly()
  384.         {
  385.             if (assembly == null) {
  386.                 assembly = FormatterServices.LoadAssemblyFromStringNoThrow(assemblyString);
  387.                 if (assembly == null)
  388.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_AssemblyNotFound"), assemblyString));
  389.             }
  390.             return assembly;
  391.         }
  392.     }
  393.    
  394.     // The Following classes read and write the binary records
  395.     internal sealed class SerializationHeaderRecord : IStreamable
  396.     {
  397.         internal Int32 binaryFormatterMajorVersion = 1;
  398.         internal Int32 binaryFormatterMinorVersion = 0;
  399.         internal BinaryHeaderEnum binaryHeaderEnum;
  400.         internal Int32 topId;
  401.         internal Int32 headerId;
  402.         internal Int32 majorVersion;
  403.         internal Int32 minorVersion;
  404.        
  405.         internal SerializationHeaderRecord()
  406.         {
  407.         }
  408.        
  409.         internal SerializationHeaderRecord(BinaryHeaderEnum binaryHeaderEnum, Int32 topId, Int32 headerId, Int32 majorVersion, Int32 minorVersion)
  410.         {
  411.             this.binaryHeaderEnum = binaryHeaderEnum;
  412.             this.topId = topId;
  413.             this.headerId = headerId;
  414.             this.majorVersion = majorVersion;
  415.             this.minorVersion = minorVersion;
  416.         }
  417.        
  418.         public void Write(__BinaryWriter sout)
  419.         {
  420.             majorVersion = binaryFormatterMajorVersion;
  421.             minorVersion = binaryFormatterMinorVersion;
  422.             sout.WriteByte((byte)binaryHeaderEnum);
  423.             sout.WriteInt32(topId);
  424.             sout.WriteInt32(headerId);
  425.             sout.WriteInt32(binaryFormatterMajorVersion);
  426.             sout.WriteInt32(binaryFormatterMinorVersion);
  427.         }
  428.        
  429.         private static int GetInt32(byte[] buffer, int index)
  430.         {
  431.             return (int)(buffer[index] | buffer[index + 1] << 8 | buffer[index + 2] << 16 | buffer[index + 3] << 24);
  432.         }
  433.        
  434.         public void Read(__BinaryParser input)
  435.         {
  436.             byte[] headerBytes = input.ReadBytes(17);
  437.             // Throw if we couldnt read header bytes
  438.             if (headerBytes.Length < 17)
  439.                 __Error.EndOfFile();
  440.            
  441.             majorVersion = GetInt32(headerBytes, 9);
  442.             if (majorVersion > binaryFormatterMajorVersion)
  443.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_InvalidFormat"), BitConverter.ToString(headerBytes)));
  444.            
  445.             // binaryHeaderEnum has already been read
  446.             binaryHeaderEnum = (BinaryHeaderEnum)headerBytes[0];
  447.             topId = GetInt32(headerBytes, 1);
  448.             headerId = GetInt32(headerBytes, 5);
  449.             minorVersion = GetInt32(headerBytes, 13);
  450.         }
  451.        
  452.         public void Dump()
  453.         {
  454.             DumpInternal();
  455.         }
  456.        
  457.        
  458.         [Conditional("_LOGGING")]
  459.         private void DumpInternal()
  460.         {
  461.             if (BCLDebug.CheckEnabled("BINARY")) {
  462.                 BCLDebug.Trace("BINARY", "*****SerializationHeaderRecord*****");
  463.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", ((Enum)binaryHeaderEnum).ToString());
  464.                 BinaryUtil.NVTraceI("topId (Int32)", topId);
  465.                 BinaryUtil.NVTraceI("headerId (Int32)", headerId);
  466.                 BinaryUtil.NVTraceI("majorVersion (Int32)", majorVersion);
  467.                 BinaryUtil.NVTraceI("minorVersion (Int32)", minorVersion);
  468.                 BCLDebug.Trace("BINARY", "***********************************");
  469.             }
  470.         }
  471.     }
  472.    
  473.    
  474.     internal sealed class BinaryAssembly : IStreamable
  475.     {
  476.         internal Int32 assemId;
  477.         internal string assemblyString;
  478.        
  479.         internal BinaryAssembly()
  480.         {
  481.         }
  482.        
  483.        
  484.         internal void Set(Int32 assemId, string assemblyString)
  485.         {
  486.             SerTrace.Log(this, "BinaryAssembly Set ", assemId, " ", assemblyString);
  487.             this.assemId = assemId;
  488.             this.assemblyString = assemblyString;
  489.         }
  490.        
  491.        
  492.         public void Write(__BinaryWriter sout)
  493.         {
  494.             sout.WriteByte((byte)BinaryHeaderEnum.Assembly);
  495.             sout.WriteInt32(assemId);
  496.             sout.WriteString(assemblyString);
  497.         }
  498.        
  499.         public void Read(__BinaryParser input)
  500.         {
  501.             assemId = input.ReadInt32();
  502.             assemblyString = input.ReadString();
  503.         }
  504.        
  505.         public void Dump()
  506.         {
  507.             DumpInternal();
  508.         }
  509.        
  510.         [Conditional("_LOGGING")]
  511.         private void DumpInternal()
  512.         {
  513.             if (BCLDebug.CheckEnabled("BINARY")) {
  514.                 BCLDebug.Trace("BINARY", "*****BinaryAssembly*****");
  515.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "Assembly");
  516.                 BinaryUtil.NVTraceI("assemId (Int32)", assemId);
  517.                 BinaryUtil.NVTraceI("Assembly (UTF)", assemblyString);
  518.                 BCLDebug.Trace("BINARY", "****************************");
  519.             }
  520.         }
  521.     }
  522.    
  523.     internal sealed class BinaryCrossAppDomainAssembly : IStreamable
  524.     {
  525.         internal Int32 assemId;
  526.         internal Int32 assemblyIndex;
  527.        
  528.         internal BinaryCrossAppDomainAssembly()
  529.         {
  530.         }
  531.        
  532.         public void Write(__BinaryWriter sout)
  533.         {
  534.             sout.WriteByte((byte)BinaryHeaderEnum.CrossAppDomainAssembly);
  535.             sout.WriteInt32(assemId);
  536.             sout.WriteInt32(assemblyIndex);
  537.         }
  538.        
  539.         public void Read(__BinaryParser input)
  540.         {
  541.             assemId = input.ReadInt32();
  542.             assemblyIndex = input.ReadInt32();
  543.         }
  544.        
  545.         public void Dump()
  546.         {
  547.             DumpInternal();
  548.         }
  549.        
  550.         [Conditional("_LOGGING")]
  551.         private void DumpInternal()
  552.         {
  553.             if (BCLDebug.CheckEnabled("BINARY")) {
  554.                 BCLDebug.Trace("BINARY", "*****BinaryCrossAppDomainAssembly*****");
  555.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "CrossAppDomainAssembly");
  556.                 BinaryUtil.NVTraceI("assemId (Int32)", assemId);
  557.                 BinaryUtil.NVTraceI("assemblyIndex (Int32)", assemblyIndex);
  558.                 BCLDebug.Trace("BINARY", "****************************");
  559.             }
  560.         }
  561.     }
  562.    
  563.    
  564.     internal sealed class BinaryObject : IStreamable
  565.     {
  566.         internal Int32 objectId;
  567.         internal Int32 mapId;
  568.        
  569.         internal BinaryObject()
  570.         {
  571.         }
  572.        
  573.         internal void Set(Int32 objectId, Int32 mapId)
  574.         {
  575.             SerTrace.Log(this, "BinaryObject Set ", objectId, " ", mapId);
  576.             this.objectId = objectId;
  577.             this.mapId = mapId;
  578.         }
  579.        
  580.        
  581.         public void Write(__BinaryWriter sout)
  582.         {
  583.             sout.WriteByte((byte)BinaryHeaderEnum.Object);
  584.             sout.WriteInt32(objectId);
  585.             sout.WriteInt32(mapId);
  586.         }
  587.        
  588.         public void Read(__BinaryParser input)
  589.         {
  590.             objectId = input.ReadInt32();
  591.             mapId = input.ReadInt32();
  592.         }
  593.        
  594.         public void Dump()
  595.         {
  596.             DumpInternal();
  597.         }
  598.        
  599.         [Conditional("_LOGGING")]
  600.         private void DumpInternal()
  601.         {
  602.             if (BCLDebug.CheckEnabled("BINARY")) {
  603.                 BCLDebug.Trace("BINARY", "*****BinaryObject*****");
  604.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "Object");
  605.                 BinaryUtil.NVTraceI("objectId (Int32)", objectId);
  606.                 BinaryUtil.NVTraceI("mapId (Int32)", mapId);
  607.                 BCLDebug.Trace("BINARY", "****************************");
  608.             }
  609.         }
  610.     }
  611.    
  612.     internal sealed class BinaryMethodCall
  613.     {
  614.         string uri;
  615.         string methodName;
  616.         string typeName;
  617.         Type[] instArgs;
  618.         object[] args;
  619.         object methodSignature;
  620.         object callContext;
  621.         string scallContext;
  622.         object properties;
  623.         Type[] argTypes;
  624.         bool bArgsPrimitive = true;
  625.         MessageEnum messageEnum;
  626.         object[] callA;
  627.        
  628.         // If the argument list contains only primitive or strings it is written out as part of the header
  629.         // if not the args are written out as a separate array
  630.         internal object[] WriteArray(string uri, string methodName, string typeName, Type[] instArgs, object[] args, object methodSignature, object callContext, object[] properties)
  631.         {
  632.             this.uri = uri;
  633.             this.methodName = methodName;
  634.             this.typeName = typeName;
  635.             this.instArgs = instArgs;
  636.             this.args = args;
  637.             this.methodSignature = methodSignature;
  638.             this.callContext = callContext;
  639.             this.properties = properties;
  640.            
  641.             int arraySize = 0;
  642.             if (args == null || args.Length == 0)
  643.                 messageEnum = MessageEnum.NoArgs;
  644.             else {
  645.                 argTypes = new Type[args.Length];
  646.                 // Check if args are all string or primitives
  647.                 bArgsPrimitive = true;
  648.                 for (int i = 0; i < args.Length; i++) {
  649.                     if (args[i] != null) {
  650.                         argTypes[i] = args[i].GetType();
  651.                         if (!(argTypes[i].IsPrimitive || argTypes[i] == Converter.typeofString) || args[i] is ISerializable) {
  652.                             bArgsPrimitive = false;
  653.                             break;
  654.                         }
  655.                     }
  656.                 }
  657.                
  658.                
  659.                 if (bArgsPrimitive)
  660.                     messageEnum = MessageEnum.ArgsInline;
  661.                 else {
  662.                     arraySize++;
  663.                     messageEnum = MessageEnum.ArgsInArray;
  664.                 }
  665.             }
  666.            
  667.            
  668.             if (instArgs != null) {
  669.                 arraySize++;
  670.                 messageEnum |= MessageEnum.GenericMethod;
  671.             }
  672.            
  673.             if (methodSignature != null) {
  674.                 arraySize++;
  675.                 messageEnum |= MessageEnum.MethodSignatureInArray;
  676.             }
  677.            
  678.             if (callContext == null)
  679.                 messageEnum |= MessageEnum.NoContext;
  680.             else if (callContext is string)
  681.                 messageEnum |= MessageEnum.ContextInline;
  682.             else {
  683.                 arraySize++;
  684.                 messageEnum |= MessageEnum.ContextInArray;
  685.             }
  686.            
  687.             if (properties != null) {
  688.                 arraySize++;
  689.                 messageEnum |= MessageEnum.PropertyInArray;
  690.             }
  691.            
  692.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInArray) && arraySize == 1) {
  693.                 messageEnum ^= MessageEnum.ArgsInArray;
  694.                 messageEnum |= MessageEnum.ArgsIsArray;
  695.                 return args;
  696.             }
  697.            
  698.            
  699.             if (arraySize > 0) {
  700.                 int arrayPosition = 0;
  701.                 callA = new object[arraySize];
  702.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInArray))
  703.                     callA[arrayPosition++] = args;
  704.                
  705.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.GenericMethod))
  706.                     callA[arrayPosition++] = instArgs;
  707.                
  708.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.MethodSignatureInArray))
  709.                     callA[arrayPosition++] = methodSignature;
  710.                
  711.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInArray))
  712.                     callA[arrayPosition++] = callContext;
  713.                
  714.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.PropertyInArray))
  715.                     callA[arrayPosition] = properties;
  716.                
  717.                 return callA;
  718.             }
  719.             else
  720.                 return null;
  721.         }
  722.        
  723.         internal void Write(__BinaryWriter sout)
  724.         {
  725.             sout.WriteByte((byte)BinaryHeaderEnum.MethodCall);
  726.             sout.WriteInt32((Int32)messageEnum);
  727.             //IOUtil.WriteStringWithCode(uri, sout);
  728.             IOUtil.WriteStringWithCode(methodName, sout);
  729.             IOUtil.WriteStringWithCode(typeName, sout);
  730.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInline))
  731.                 IOUtil.WriteStringWithCode((string)callContext, sout);
  732.            
  733.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInline)) {
  734.                 sout.WriteInt32(args.Length);
  735.                 for (int i = 0; i < args.Length; i++) {
  736.                     IOUtil.WriteWithCode(argTypes[i], args[i], sout);
  737.                 }
  738.                
  739.             }
  740.         }
  741.        
  742.         internal void Read(__BinaryParser input)
  743.         {
  744.             messageEnum = (MessageEnum)input.ReadInt32();
  745.             //uri = (String)IOUtil.ReadWithCode(input);
  746.             methodName = (string)IOUtil.ReadWithCode(input);
  747.             typeName = (string)IOUtil.ReadWithCode(input);
  748.            
  749.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInline)) {
  750.                 scallContext = (string)IOUtil.ReadWithCode(input);
  751.                 LogicalCallContext lcallContext = new LogicalCallContext();
  752.                 lcallContext.RemotingData.LogicalCallID = scallContext;
  753.                 callContext = lcallContext;
  754.             }
  755.            
  756.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInline))
  757.                 args = IOUtil.ReadArgs(input);
  758.         }
  759.        
  760.         internal IMethodCallMessage ReadArray(object[] callA, object handlerObject)
  761.         {
  762.             /*
  763.             if (callA.Length != 7)
  764.                 throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_Method")));
  765.                 */           
  766.            
  767. if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsIsArray)) {
  768.                 args = callA;
  769.             }
  770.             else {
  771.                 int arrayPosition = 0;
  772.                
  773.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInArray)) {
  774.                     if (callA.Length < arrayPosition)
  775.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Method")));
  776.                     args = (object[])callA[arrayPosition++];
  777.                 }
  778.                
  779.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.GenericMethod)) {
  780.                     if (callA.Length < arrayPosition)
  781.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Method")));
  782.                     instArgs = (Type[])callA[arrayPosition++];
  783.                 }
  784.                
  785.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.MethodSignatureInArray)) {
  786.                     if (callA.Length < arrayPosition)
  787.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Method")));
  788.                     methodSignature = callA[arrayPosition++];
  789.                 }
  790.                
  791.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInArray)) {
  792.                     if (callA.Length < arrayPosition)
  793.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Method")));
  794.                     callContext = callA[arrayPosition++];
  795.                 }
  796.                
  797.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.PropertyInArray)) {
  798.                     if (callA.Length < arrayPosition)
  799.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Method")));
  800.                     properties = callA[arrayPosition++];
  801.                 }
  802.             }
  803.            
  804.             return new MethodCall(handlerObject, new BinaryMethodCallMessage(uri, methodName, typeName, instArgs, args, methodSignature, (LogicalCallContext)callContext, (object[])properties));
  805.         }
  806.        
  807.         internal void Dump()
  808.         {
  809.             DumpInternal();
  810.         }
  811.        
  812.         [Conditional("_LOGGING")]
  813.         private void DumpInternal()
  814.         {
  815.             if (BCLDebug.CheckEnabled("BINARY")) {
  816.                 BCLDebug.Trace("BINARY", "*****BinaryMethodCall*****");
  817.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "MethodCall");
  818.                 BinaryUtil.NVTraceI("messageEnum (Int32)", ((Enum)messageEnum).ToString());
  819.                 //BinaryUtil.NVTraceI("uri",uri);
  820.                 BinaryUtil.NVTraceI("methodName", methodName);
  821.                 BinaryUtil.NVTraceI("typeName", typeName);
  822.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInline)) {
  823.                     if (callContext is string)
  824.                         BinaryUtil.NVTraceI("callContext", (string)callContext);
  825.                     else
  826.                         BinaryUtil.NVTraceI("callContext", scallContext);
  827.                 }
  828.                
  829.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInline)) {
  830.                     BinaryUtil.NVTraceI("args Length", args.Length);
  831.                     for (int i = 0; i < args.Length; i++) {
  832.                         BinaryUtil.NVTraceI("arg[" + i + "]", args[i]);
  833.                     }
  834.                 }
  835.                
  836.                 BCLDebug.Trace("BINARY", "****************************");
  837.             }
  838.         }
  839.     }
  840.    
  841.     internal sealed class BinaryMethodReturn : IStreamable
  842.     {
  843.         object returnValue;
  844.         object[] args;
  845.         Exception exception;
  846.         object callContext;
  847.         string scallContext;
  848.         object properties;
  849.         Type[] argTypes;
  850.         bool bArgsPrimitive = true;
  851.         MessageEnum messageEnum;
  852.         object[] callA;
  853.         Type returnType;
  854.         static object instanceOfVoid = FormatterServices.GetUninitializedObject(Converter.typeofSystemVoid);
  855.        
  856.         internal BinaryMethodReturn()
  857.         {
  858.         }
  859.        
  860.         // If the argument list contains only primitive or strings it is written out as part of the header
  861.         // if not the args are written out as a separate array
  862.         internal object[] WriteArray(object returnValue, object[] args, Exception exception, object callContext, object[] properties)
  863.         {
  864.             SerTrace.Log(this, "WriteArray returnValue ", returnValue, "exception ", exception, " callContext ", callContext, " properties ", properties);
  865.            
  866.             this.returnValue = returnValue;
  867.             this.args = args;
  868.             this.exception = exception;
  869.             this.callContext = callContext;
  870.             this.properties = properties;
  871.            
  872.             int arraySize = 0;
  873.             if (args == null || args.Length == 0)
  874.                 messageEnum = MessageEnum.NoArgs;
  875.             else {
  876.                 argTypes = new Type[args.Length];
  877.                
  878.                 // Check if args are all string or primitives
  879.                
  880.                 bArgsPrimitive = true;
  881.                 for (int i = 0; i < args.Length; i++) {
  882.                     if (args[i] != null) {
  883.                         argTypes[i] = args[i].GetType();
  884.                         if (!(argTypes[i].IsPrimitive || argTypes[i] == Converter.typeofString)) {
  885.                             bArgsPrimitive = false;
  886.                             break;
  887.                         }
  888.                     }
  889.                 }
  890.                
  891.                 if (bArgsPrimitive)
  892.                     messageEnum = MessageEnum.ArgsInline;
  893.                 else {
  894.                     arraySize++;
  895.                     messageEnum = MessageEnum.ArgsInArray;
  896.                 }
  897.             }
  898.            
  899.            
  900.             if (returnValue == null)
  901.                 messageEnum |= MessageEnum.NoReturnValue;
  902.             else if (returnValue.GetType() == typeof(void))
  903.                 messageEnum |= MessageEnum.ReturnValueVoid;
  904.             else {
  905.                 returnType = returnValue.GetType();
  906.                 if (returnType.IsPrimitive || returnType == Converter.typeofString)
  907.                     messageEnum |= MessageEnum.ReturnValueInline;
  908.                 else {
  909.                     arraySize++;
  910.                     messageEnum |= MessageEnum.ReturnValueInArray;
  911.                 }
  912.             }
  913.            
  914.             if (exception != null) {
  915.                 arraySize++;
  916.                 messageEnum |= MessageEnum.ExceptionInArray;
  917.             }
  918.            
  919.             if (callContext == null)
  920.                 messageEnum |= MessageEnum.NoContext;
  921.             else if (callContext is string)
  922.                 messageEnum |= MessageEnum.ContextInline;
  923.             else {
  924.                 arraySize++;
  925.                 messageEnum |= MessageEnum.ContextInArray;
  926.             }
  927.            
  928.             if (properties != null) {
  929.                 arraySize++;
  930.                 messageEnum |= MessageEnum.PropertyInArray;
  931.             }
  932.            
  933.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInArray) && (arraySize == 1)) {
  934.                 messageEnum ^= MessageEnum.ArgsInArray;
  935.                 messageEnum |= MessageEnum.ArgsIsArray;
  936.                 return args;
  937.             }
  938.            
  939.             if (arraySize > 0) {
  940.                 int arrayPosition = 0;
  941.                 callA = new object[arraySize];
  942.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInArray))
  943.                     callA[arrayPosition++] = args;
  944.                
  945.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueInArray))
  946.                     callA[arrayPosition++] = returnValue;
  947.                
  948.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ExceptionInArray))
  949.                     callA[arrayPosition++] = exception;
  950.                
  951.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInArray))
  952.                     callA[arrayPosition++] = callContext;
  953.                
  954.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.PropertyInArray))
  955.                     callA[arrayPosition] = properties;
  956.                
  957.                 return callA;
  958.             }
  959.             else
  960.                 return null;
  961.         }
  962.        
  963.        
  964.         public void Write(__BinaryWriter sout)
  965.         {
  966.             sout.WriteByte((byte)BinaryHeaderEnum.MethodReturn);
  967.             sout.WriteInt32((Int32)messageEnum);
  968.            
  969.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueInline)) {
  970.                 IOUtil.WriteWithCode(returnType, returnValue, sout);
  971.             }
  972.            
  973.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInline))
  974.                 IOUtil.WriteStringWithCode((string)callContext, sout);
  975.            
  976.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInline)) {
  977.                 sout.WriteInt32(args.Length);
  978.                 for (int i = 0; i < args.Length; i++) {
  979.                     IOUtil.WriteWithCode(argTypes[i], args[i], sout);
  980.                 }
  981.             }
  982.         }
  983.        
  984.         public void Read(__BinaryParser input)
  985.         {
  986.             messageEnum = (MessageEnum)input.ReadInt32();
  987.            
  988.             if (IOUtil.FlagTest(messageEnum, MessageEnum.NoReturnValue))
  989.                 returnValue = null;
  990.             else if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueVoid)) {
  991.                 returnValue = instanceOfVoid;
  992.             }
  993.             else if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueInline))
  994.                 returnValue = IOUtil.ReadWithCode(input);
  995.            
  996.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInline)) {
  997.                 scallContext = (string)IOUtil.ReadWithCode(input);
  998.                 LogicalCallContext lcallContext = new LogicalCallContext();
  999.                 lcallContext.RemotingData.LogicalCallID = scallContext;
  1000.                 callContext = lcallContext;
  1001.             }
  1002.            
  1003.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInline))
  1004.                 args = IOUtil.ReadArgs(input);
  1005.         }
  1006.        
  1007.         internal IMethodReturnMessage ReadArray(object[] returnA, IMethodCallMessage methodCallMessage, object handlerObject)
  1008.         {
  1009.             if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsIsArray)) {
  1010.                 args = returnA;
  1011.             }
  1012.             else {
  1013.                 int arrayPosition = 0;
  1014.                
  1015.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInArray)) {
  1016.                     if (returnA.Length < arrayPosition)
  1017.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Method")));
  1018.                     args = (object[])returnA[arrayPosition++];
  1019.                 }
  1020.                
  1021.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueInArray)) {
  1022.                     if (returnA.Length < arrayPosition)
  1023.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Method")));
  1024.                     returnValue = returnA[arrayPosition++];
  1025.                 }
  1026.                
  1027.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ExceptionInArray)) {
  1028.                     if (returnA.Length < arrayPosition)
  1029.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Method")));
  1030.                     exception = (Exception)returnA[arrayPosition++];
  1031.                 }
  1032.                
  1033.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInArray)) {
  1034.                     if (returnA.Length < arrayPosition)
  1035.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Method")));
  1036.                     callContext = returnA[arrayPosition++];
  1037.                 }
  1038.                
  1039.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.PropertyInArray)) {
  1040.                     if (returnA.Length < arrayPosition)
  1041.                         throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Method")));
  1042.                     properties = returnA[arrayPosition++];
  1043.                 }
  1044.             }
  1045.             return new MethodResponse(methodCallMessage, handlerObject, new BinaryMethodReturnMessage(returnValue, args, exception, (LogicalCallContext)callContext, (object[])properties));
  1046.         }
  1047.        
  1048.         public void Dump()
  1049.         {
  1050.             DumpInternal();
  1051.         }
  1052.        
  1053.         [Conditional("_LOGGING")]
  1054.         private void DumpInternal()
  1055.         {
  1056.             if (BCLDebug.CheckEnabled("BINARY")) {
  1057.                 BCLDebug.Trace("BINARY", "*****BinaryMethodReturn*****");
  1058.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "MethodReturn");
  1059.                 BinaryUtil.NVTraceI("messageEnum (Int32)", ((Enum)messageEnum).ToString());
  1060.                
  1061.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ReturnValueInline))
  1062.                     BinaryUtil.NVTraceI("returnValue", returnValue);
  1063.                
  1064.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ContextInline)) {
  1065.                     if (callContext is string)
  1066.                         BinaryUtil.NVTraceI("callContext", (string)callContext);
  1067.                     else
  1068.                         BinaryUtil.NVTraceI("callContext", scallContext);
  1069.                 }
  1070.                
  1071.                 if (IOUtil.FlagTest(messageEnum, MessageEnum.ArgsInline)) {
  1072.                     BinaryUtil.NVTraceI("args Length", args.Length);
  1073.                     for (int i = 0; i < args.Length; i++) {
  1074.                         BinaryUtil.NVTraceI("arg[" + i + "]", args[i]);
  1075.                     }
  1076.                 }
  1077.                
  1078.                 BCLDebug.Trace("BINARY", "****************************");
  1079.             }
  1080.         }
  1081.     }
  1082.    
  1083.    
  1084.    
  1085.     internal sealed class BinaryObjectString : IStreamable
  1086.     {
  1087.         internal Int32 objectId;
  1088.         internal string value;
  1089.        
  1090.         internal BinaryObjectString()
  1091.         {
  1092.         }
  1093.        
  1094.         internal void Set(Int32 objectId, string value)
  1095.         {
  1096.             SerTrace.Log(this, "BinaryObjectString set ", objectId, " ", value);
  1097.             this.objectId = objectId;
  1098.             this.value = value;
  1099.         }
  1100.        
  1101.        
  1102.         public void Write(__BinaryWriter sout)
  1103.         {
  1104.             sout.WriteByte((byte)BinaryHeaderEnum.ObjectString);
  1105.             sout.WriteInt32(objectId);
  1106.             sout.WriteString(value);
  1107.         }
  1108.        
  1109.         public void Read(__BinaryParser input)
  1110.         {
  1111.             objectId = input.ReadInt32();
  1112.             value = input.ReadString();
  1113.         }
  1114.        
  1115.         public void Dump()
  1116.         {
  1117.             DumpInternal();
  1118.         }
  1119.        
  1120.         [Conditional("_LOGGING")]
  1121.         private void DumpInternal()
  1122.         {
  1123.             if (BCLDebug.CheckEnabled("BINARY")) {
  1124.                 BCLDebug.Trace("BINARY", "*****BinaryObjectString*****");
  1125.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "ObjectString");
  1126.                 BinaryUtil.NVTraceI("objectId (Int32)", objectId);
  1127.                 BinaryUtil.NVTraceI("value (UTF)", value);
  1128.                 BCLDebug.Trace("BINARY", "****************************");
  1129.             }
  1130.         }
  1131.     }
  1132.    
  1133.     internal sealed class BinaryCrossAppDomainString : IStreamable
  1134.     {
  1135.         internal Int32 objectId;
  1136.         internal Int32 value;
  1137.        
  1138.         internal BinaryCrossAppDomainString()
  1139.         {
  1140.         }
  1141.        
  1142.         public void Write(__BinaryWriter sout)
  1143.         {
  1144.             sout.WriteByte((byte)BinaryHeaderEnum.CrossAppDomainString);
  1145.             sout.WriteInt32(objectId);
  1146.             sout.WriteInt32(value);
  1147.         }
  1148.        
  1149.         public void Read(__BinaryParser input)
  1150.         {
  1151.             objectId = input.ReadInt32();
  1152.             value = input.ReadInt32();
  1153.         }
  1154.        
  1155.         public void Dump()
  1156.         {
  1157.             DumpInternal();
  1158.         }
  1159.        
  1160.         [Conditional("_LOGGING")]
  1161.         private void DumpInternal()
  1162.         {
  1163.             if (BCLDebug.CheckEnabled("BINARY")) {
  1164.                 BCLDebug.Trace("BINARY", "*****BinaryCrossAppDomainString*****");
  1165.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "CrossAppDomainString");
  1166.                 BinaryUtil.NVTraceI("objectId (Int32)", objectId);
  1167.                 BinaryUtil.NVTraceI("value (Int32)", value);
  1168.                 BCLDebug.Trace("BINARY", "****************************");
  1169.             }
  1170.         }
  1171.     }
  1172.    
  1173.     internal sealed class BinaryCrossAppDomainMap : IStreamable
  1174.     {
  1175.         internal Int32 crossAppDomainArrayIndex;
  1176.        
  1177.         internal BinaryCrossAppDomainMap()
  1178.         {
  1179.         }
  1180.        
  1181.         public void Write(__BinaryWriter sout)
  1182.         {
  1183.             sout.WriteByte((byte)BinaryHeaderEnum.CrossAppDomainMap);
  1184.             sout.WriteInt32(crossAppDomainArrayIndex);
  1185.         }
  1186.        
  1187.         public void Read(__BinaryParser input)
  1188.         {
  1189.             crossAppDomainArrayIndex = input.ReadInt32();
  1190.         }
  1191.        
  1192.         public void Dump()
  1193.         {
  1194.             DumpInternal();
  1195.         }
  1196.        
  1197.         [Conditional("_LOGGING")]
  1198.         private void DumpInternal()
  1199.         {
  1200.             if (BCLDebug.CheckEnabled("BINARY")) {
  1201.                 BCLDebug.Trace("BINARY", "*****BinaryCrossAppDomainMap*****");
  1202.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "CrossAppDomainMap");
  1203.                 BinaryUtil.NVTraceI("crossAppDomainArrayIndex (Int32)", crossAppDomainArrayIndex);
  1204.                 BCLDebug.Trace("BINARY", "****************************");
  1205.             }
  1206.         }
  1207.     }
  1208.    
  1209.    
  1210.     internal sealed class MemberPrimitiveTyped : IStreamable
  1211.     {
  1212.         internal InternalPrimitiveTypeE primitiveTypeEnum;
  1213.         internal object value;
  1214.        
  1215.         internal MemberPrimitiveTyped()
  1216.         {
  1217.         }
  1218.        
  1219.         internal void Set(InternalPrimitiveTypeE primitiveTypeEnum, object value)
  1220.         {
  1221.             SerTrace.Log(this, "MemberPrimitiveTyped Set ", ((Enum)primitiveTypeEnum).ToString(), " ", value);
  1222.             this.primitiveTypeEnum = primitiveTypeEnum;
  1223.             this.value = value;
  1224.         }
  1225.        
  1226.        
  1227.         public void Write(__BinaryWriter sout)
  1228.         {
  1229.             sout.WriteByte((byte)BinaryHeaderEnum.MemberPrimitiveTyped);
  1230.             sout.WriteByte((byte)primitiveTypeEnum);
  1231.             //pdj
  1232.             sout.WriteValue(primitiveTypeEnum, value);
  1233.         }
  1234.        
  1235.         public void Read(__BinaryParser input)
  1236.         {
  1237.             primitiveTypeEnum = (InternalPrimitiveTypeE)input.ReadByte();
  1238.             //PDJ
  1239.             value = input.ReadValue(primitiveTypeEnum);
  1240.         }
  1241.        
  1242.         public void Dump()
  1243.         {
  1244.             DumpInternal();
  1245.         }
  1246.        
  1247.         [Conditional("_LOGGING")]
  1248.         private void DumpInternal()
  1249.         {
  1250.             if (BCLDebug.CheckEnabled("BINARY")) {
  1251.                 BCLDebug.Trace("BINARY", "*****MemberPrimitiveTyped*****");
  1252.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "MemberPrimitiveTyped");
  1253.                 BinaryUtil.NVTraceI("primitiveTypeEnum (Byte)", ((Enum)primitiveTypeEnum).ToString());
  1254.                 BinaryUtil.NVTraceI("value (" + Converter.ToComType(primitiveTypeEnum) + ")", value);
  1255.                 BCLDebug.Trace("BINARY", "****************************");
  1256.             }
  1257.         }
  1258.     }
  1259.    
  1260.    
  1261.     internal sealed class BinaryObjectWithMap : IStreamable
  1262.     {
  1263.         internal BinaryHeaderEnum binaryHeaderEnum;
  1264.         internal Int32 objectId;
  1265.         internal string name;
  1266.         internal Int32 numMembers;
  1267.         internal string[] memberNames;
  1268.         internal Int32 assemId;
  1269.        
  1270.         internal BinaryObjectWithMap()
  1271.         {
  1272.         }
  1273.        
  1274.         internal BinaryObjectWithMap(BinaryHeaderEnum binaryHeaderEnum)
  1275.         {
  1276.             this.binaryHeaderEnum = binaryHeaderEnum;
  1277.         }
  1278.        
  1279.         internal void Set(Int32 objectId, string name, Int32 numMembers, string[] memberNames, Int32 assemId)
  1280.         {
  1281.             #if _DEBUG
  1282.             SerTrace.Log(this, "BinaryObjectWithMap Set ", objectId, " assemId ", assemId, " ", Util.PString(name), " numMembers ", numMembers);
  1283.             #endif
  1284.             this.objectId = objectId;
  1285.             this.name = name;
  1286.             this.numMembers = numMembers;
  1287.             this.memberNames = memberNames;
  1288.             this.assemId = assemId;
  1289.            
  1290.             if (assemId > 0)
  1291.                 binaryHeaderEnum = BinaryHeaderEnum.ObjectWithMapAssemId;
  1292.             else
  1293.                 binaryHeaderEnum = BinaryHeaderEnum.ObjectWithMap;
  1294.            
  1295.         }
  1296.        
  1297.         public void Write(__BinaryWriter sout)
  1298.         {
  1299.            
  1300.             sout.WriteByte((byte)binaryHeaderEnum);
  1301.             sout.WriteInt32(objectId);
  1302.             sout.WriteString(name);
  1303.             sout.WriteInt32(numMembers);
  1304.             for (int i = 0; i < numMembers; i++)
  1305.                 sout.WriteString(memberNames[i]);
  1306.             if (assemId > 0)
  1307.                 sout.WriteInt32(assemId);
  1308.         }
  1309.        
  1310.         public void Read(__BinaryParser input)
  1311.         {
  1312.             objectId = input.ReadInt32();
  1313.             name = input.ReadString();
  1314.             numMembers = input.ReadInt32();
  1315.             memberNames = new string[numMembers];
  1316.             for (int i = 0; i < numMembers; i++) {
  1317.                 memberNames[i] = input.ReadString();
  1318.                 SerTrace.Log(this, "BinaryObjectWithMap Read ", i, " ", memberNames[i]);
  1319.             }
  1320.            
  1321.             if (binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapAssemId) {
  1322.                 assemId = input.ReadInt32();
  1323.             }
  1324.         }
  1325.        
  1326.        
  1327.         public void Dump()
  1328.         {
  1329.             DumpInternal();
  1330.         }
  1331.        
  1332.         [Conditional("_LOGGING")]
  1333.         private void DumpInternal()
  1334.         {
  1335.             if (BCLDebug.CheckEnabled("BINARY")) {
  1336.                 BCLDebug.Trace("BINARY", "*****BinaryObjectWithMap*****");
  1337.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", ((Enum)binaryHeaderEnum).ToString());
  1338.                 BinaryUtil.NVTraceI("objectId (Int32)", objectId);
  1339.                 BinaryUtil.NVTraceI("name (UTF)", name);
  1340.                 BinaryUtil.NVTraceI("numMembers (Int32)", numMembers);
  1341.                 for (int i = 0; i < numMembers; i++)
  1342.                     BinaryUtil.NVTraceI("memberNames (UTF)", memberNames[i]);
  1343.                 if (binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapAssemId)
  1344.                     BinaryUtil.NVTraceI("assemId (Int32)", assemId);
  1345.                 BCLDebug.Trace("BINARY", "****************************");
  1346.             }
  1347.         }
  1348.     }
  1349.    
  1350.    
  1351.     internal sealed class BinaryObjectWithMapTyped : IStreamable
  1352.     {
  1353.         internal BinaryHeaderEnum binaryHeaderEnum;
  1354.         internal Int32 objectId;
  1355.         internal string name;
  1356.         internal Int32 numMembers;
  1357.         internal string[] memberNames;
  1358.         internal BinaryTypeEnum[] binaryTypeEnumA;
  1359.         internal object[] typeInformationA;
  1360.         internal Int32[] memberAssemIds;
  1361.         internal Int32 assemId;
  1362.        
  1363.         internal BinaryObjectWithMapTyped()
  1364.         {
  1365.         }
  1366.        
  1367.         internal BinaryObjectWithMapTyped(BinaryHeaderEnum binaryHeaderEnum)
  1368.         {
  1369.             this.binaryHeaderEnum = binaryHeaderEnum;
  1370.         }
  1371.        
  1372.        
  1373.        
  1374.         internal void Set(Int32 objectId, string name, Int32 numMembers, string[] memberNames, BinaryTypeEnum[] binaryTypeEnumA, object[] typeInformationA, Int32[] memberAssemIds, Int32 assemId)
  1375.         {
  1376.             SerTrace.Log(this, "BinaryObjectWithMapTyped Set ", objectId, " assemId ", assemId, " ", name, " numMembers ", numMembers);
  1377.             this.objectId = objectId;
  1378.             this.assemId = assemId;
  1379.             this.name = name;
  1380.             this.numMembers = numMembers;
  1381.             this.memberNames = memberNames;
  1382.             this.binaryTypeEnumA = binaryTypeEnumA;
  1383.             this.typeInformationA = typeInformationA;
  1384.             this.memberAssemIds = memberAssemIds;
  1385.             this.assemId = assemId;
  1386.            
  1387.             if (assemId > 0)
  1388.                 binaryHeaderEnum = BinaryHeaderEnum.ObjectWithMapTypedAssemId;
  1389.             else
  1390.                 binaryHeaderEnum = BinaryHeaderEnum.ObjectWithMapTyped;
  1391.         }
  1392.        
  1393.        
  1394.         public void Write(__BinaryWriter sout)
  1395.         {
  1396.             sout.WriteByte((byte)binaryHeaderEnum);
  1397.             sout.WriteInt32(objectId);
  1398.             sout.WriteString(name);
  1399.             sout.WriteInt32(numMembers);
  1400.             for (int i = 0; i < numMembers; i++)
  1401.                 sout.WriteString(memberNames[i]);
  1402.             for (int i = 0; i < numMembers; i++)
  1403.                 sout.WriteByte((byte)binaryTypeEnumA[i]);
  1404.             for (int i = 0; i < numMembers; i++)
  1405.                 //if (binaryTypeEnumA[i] != BinaryTypeEnum.ObjectUrt && binaryTypeEnumA[i] != BinaryTypeEnum.ObjectUser)
  1406.                 BinaryConverter.WriteTypeInfo(binaryTypeEnumA[i], typeInformationA[i], memberAssemIds[i], sout);
  1407.            
  1408.             if (assemId > 0)
  1409.                 sout.WriteInt32(assemId);
  1410.            
  1411.         }
  1412.        
  1413.         public void Read(__BinaryParser input)
  1414.         {
  1415.             // binaryHeaderEnum has already been read
  1416.             objectId = input.ReadInt32();
  1417.             name = input.ReadString();
  1418.             numMembers = input.ReadInt32();
  1419.             memberNames = new string[numMembers];
  1420.             binaryTypeEnumA = new BinaryTypeEnum[numMembers];
  1421.             typeInformationA = new object[numMembers];
  1422.             memberAssemIds = new Int32[numMembers];
  1423.             for (int i = 0; i < numMembers; i++)
  1424.                 memberNames[i] = input.ReadString();
  1425.             for (int i = 0; i < numMembers; i++)
  1426.                 binaryTypeEnumA[i] = (BinaryTypeEnum)input.ReadByte();
  1427.             for (int i = 0; i < numMembers; i++)
  1428.                 if (binaryTypeEnumA[i] != BinaryTypeEnum.ObjectUrt && binaryTypeEnumA[i] != BinaryTypeEnum.ObjectUser)
  1429.                     typeInformationA[i] = BinaryConverter.ReadTypeInfo(binaryTypeEnumA[i], input, out memberAssemIds[i]);
  1430.                 else
  1431.                     BinaryConverter.ReadTypeInfo(binaryTypeEnumA[i], input, out memberAssemIds[i]);
  1432.            
  1433.             if (binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTypedAssemId) {
  1434.                 assemId = input.ReadInt32();
  1435.             }
  1436.         }
  1437.        
  1438.         #if _DEBUG
  1439.         public void Dump()
  1440.         {
  1441.             DumpInternal();
  1442.         }
  1443.        
  1444.         [Conditional("_LOGGING")]
  1445.         private void DumpInternal()
  1446.         {
  1447.             if (BCLDebug.CheckEnabled("BINARY")) {
  1448.                 BCLDebug.Trace("BINARY", "*****BinaryObjectWithMapTyped*****");
  1449.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", ((Enum)binaryHeaderEnum).ToString());
  1450.                 BinaryUtil.NVTraceI("objectId (Int32)", objectId);
  1451.                 BinaryUtil.NVTraceI("name (UTF)", name);
  1452.                 BinaryUtil.NVTraceI("numMembers (Int32)", numMembers);
  1453.                 for (int i = 0; i < numMembers; i++)
  1454.                     BinaryUtil.NVTraceI("memberNames (UTF)", memberNames[i]);
  1455.                 for (int i = 0; i < numMembers; i++)
  1456.                     BinaryUtil.NVTraceI("binaryTypeEnum(" + i + ") (Byte)", ((Enum)binaryTypeEnumA[i]).ToString());
  1457.                 for (int i = 0; i < numMembers; i++)
  1458.                     if ((binaryTypeEnumA[i] == BinaryTypeEnum.Primitive) || (binaryTypeEnumA[i] == BinaryTypeEnum.PrimitiveArray) || (binaryTypeEnumA[i] == BinaryTypeEnum.ObjectUrt) || (binaryTypeEnumA[i] == BinaryTypeEnum.ObjectUser)) {
  1459.                         BinaryUtil.NVTraceI("typeInformation(" + i + ") " + BinaryConverter.TypeInfoTraceString(typeInformationA[i]), typeInformationA[i]);
  1460.                         if (binaryTypeEnumA[i] == BinaryTypeEnum.ObjectUser)
  1461.                             BinaryUtil.NVTraceI("memberAssemId(" + i + ") (Int32)", memberAssemIds[i]);
  1462.                     }
  1463.                
  1464.                 /*
  1465.                     for (int i=0; i<numMembers; i++)
  1466.                     {
  1467.                     if (binaryTypeEnumA[i] == BinaryTypeEnum.ObjectUser)
  1468.                     BinaryUtil.NVTraceI("memberAssemId("+i+") (Int32)", memberAssemIds[i]);
  1469.                     }
  1470.     */               
  1471. if (binaryHeaderEnum == BinaryHeaderEnum.ObjectWithMapTypedAssemId)
  1472.                     BinaryUtil.NVTraceI("assemId (Int32)", assemId);
  1473.                 BCLDebug.Trace("BINARY", "****************************");
  1474.             }
  1475.         }
  1476.         #endif
  1477.     }
  1478.    
  1479.    
  1480.     internal sealed class BinaryArray : IStreamable
  1481.     {
  1482.         internal Int32 objectId;
  1483.         internal Int32 rank;
  1484.         internal Int32[] lengthA;
  1485.         internal Int32[] lowerBoundA;
  1486.         internal BinaryTypeEnum binaryTypeEnum;
  1487.         internal object typeInformation;
  1488.         internal int assemId = 0;
  1489.        
  1490.         private BinaryHeaderEnum binaryHeaderEnum;
  1491.         internal BinaryArrayTypeEnum binaryArrayTypeEnum;
  1492.        
  1493.         internal BinaryArray()
  1494.         {
  1495.             SerTrace.Log(this, "BinaryArray Constructor 1 ");
  1496.         }
  1497.        
  1498.         // Read constructor
  1499.         internal BinaryArray(BinaryHeaderEnum binaryHeaderEnum)
  1500.         {
  1501.             SerTrace.Log(this, "BinaryArray Constructor 2 ", ((Enum)binaryHeaderEnum).ToString());
  1502.             this.binaryHeaderEnum = binaryHeaderEnum;
  1503.         }
  1504.        
  1505.        
  1506.         internal void Set(Int32 objectId, Int32 rank, Int32[] lengthA, Int32[] lowerBoundA, BinaryTypeEnum binaryTypeEnum, object typeInformation, BinaryArrayTypeEnum binaryArrayTypeEnum, int assemId)
  1507.         {
  1508.             SerTrace.Log(this, "BinaryArray Set objectId ", objectId, " rank ", rank, " ", ((Enum)binaryTypeEnum).ToString(), ", assemId ", assemId);
  1509.             this.objectId = objectId;
  1510.             this.binaryArrayTypeEnum = binaryArrayTypeEnum;
  1511.             this.rank = rank;
  1512.             this.lengthA = lengthA;
  1513.             this.lowerBoundA = lowerBoundA;
  1514.             this.binaryTypeEnum = binaryTypeEnum;
  1515.             this.typeInformation = typeInformation;
  1516.             this.assemId = assemId;
  1517.             binaryHeaderEnum = BinaryHeaderEnum.Array;
  1518.            
  1519.             if (binaryArrayTypeEnum == BinaryArrayTypeEnum.Single) {
  1520.                 if (binaryTypeEnum == BinaryTypeEnum.Primitive)
  1521.                     binaryHeaderEnum = BinaryHeaderEnum.ArraySinglePrimitive;
  1522.                 else if (binaryTypeEnum == BinaryTypeEnum.String)
  1523.                     binaryHeaderEnum = BinaryHeaderEnum.ArraySingleString;
  1524.                 else if (binaryTypeEnum == BinaryTypeEnum.Object)
  1525.                     binaryHeaderEnum = BinaryHeaderEnum.ArraySingleObject;
  1526.             }
  1527.             SerTrace.Log(this, "BinaryArray Set Exit ", ((Enum)binaryHeaderEnum).ToString());
  1528.         }
  1529.        
  1530.        
  1531.         public void Write(__BinaryWriter sout)
  1532.         {
  1533.             SerTrace.Log(this, "Write");
  1534.             switch (binaryHeaderEnum) {
  1535.                 case BinaryHeaderEnum.ArraySinglePrimitive:
  1536.                     sout.WriteByte((byte)binaryHeaderEnum);
  1537.                     sout.WriteInt32(objectId);
  1538.                     sout.WriteInt32(lengthA[0]);
  1539.                     sout.WriteByte((byte)((InternalPrimitiveTypeE)typeInformation));
  1540.                     break;
  1541.                 case BinaryHeaderEnum.ArraySingleString:
  1542.                     sout.WriteByte((byte)binaryHeaderEnum);
  1543.                     sout.WriteInt32(objectId);
  1544.                     sout.WriteInt32(lengthA[0]);
  1545.                     break;
  1546.                 case BinaryHeaderEnum.ArraySingleObject:
  1547.                     sout.WriteByte((byte)binaryHeaderEnum);
  1548.                     sout.WriteInt32(objectId);
  1549.                     sout.WriteInt32(lengthA[0]);
  1550.                     break;
  1551.                 default:
  1552.                     sout.WriteByte((byte)binaryHeaderEnum);
  1553.                     sout.WriteInt32(objectId);
  1554.                     sout.WriteByte((byte)binaryArrayTypeEnum);
  1555.                     sout.WriteInt32(rank);
  1556.                     for (int i = 0; i < rank; i++)
  1557.                         sout.WriteInt32(lengthA[i]);
  1558.                     if ((binaryArrayTypeEnum == BinaryArrayTypeEnum.SingleOffset) || (binaryArrayTypeEnum == BinaryArrayTypeEnum.JaggedOffset) || (binaryArrayTypeEnum == BinaryArrayTypeEnum.RectangularOffset)) {
  1559.                         for (int i = 0; i < rank; i++)
  1560.                             sout.WriteInt32(lowerBoundA[i]);
  1561.                     }
  1562.                     sout.WriteByte((byte)binaryTypeEnum);
  1563.                     BinaryConverter.WriteTypeInfo(binaryTypeEnum, typeInformation, assemId, sout);
  1564.                     break;
  1565.             }
  1566.            
  1567.         }
  1568.        
  1569.         public void Read(__BinaryParser input)
  1570.         {
  1571.             switch (binaryHeaderEnum) {
  1572.                 case BinaryHeaderEnum.ArraySinglePrimitive:
  1573.                     objectId = input.ReadInt32();
  1574.                     lengthA = new int[1];
  1575.                     lengthA[0] = input.ReadInt32();
  1576.                     binaryArrayTypeEnum = BinaryArrayTypeEnum.Single;
  1577.                     rank = 1;
  1578.                     lowerBoundA = new Int32[rank];
  1579.                     binaryTypeEnum = BinaryTypeEnum.Primitive;
  1580.                     typeInformation = (InternalPrimitiveTypeE)input.ReadByte();
  1581.                     break;
  1582.                 case BinaryHeaderEnum.ArraySingleString:
  1583.                     objectId = input.ReadInt32();
  1584.                     lengthA = new int[1];
  1585.                     lengthA[0] = (int)input.ReadInt32();
  1586.                     binaryArrayTypeEnum = BinaryArrayTypeEnum.Single;
  1587.                     rank = 1;
  1588.                     lowerBoundA = new Int32[rank];
  1589.                     binaryTypeEnum = BinaryTypeEnum.String;
  1590.                     typeInformation = null;
  1591.                     break;
  1592.                 case BinaryHeaderEnum.ArraySingleObject:
  1593.                     objectId = input.ReadInt32();
  1594.                     lengthA = new int[1];
  1595.                     lengthA[0] = (int)input.ReadInt32();
  1596.                     binaryArrayTypeEnum = BinaryArrayTypeEnum.Single;
  1597.                     rank = 1;
  1598.                     lowerBoundA = new Int32[rank];
  1599.                     binaryTypeEnum = BinaryTypeEnum.Object;
  1600.                     typeInformation = null;
  1601.                     break;
  1602.                 default:
  1603.                     objectId = input.ReadInt32();
  1604.                     binaryArrayTypeEnum = (BinaryArrayTypeEnum)input.ReadByte();
  1605.                     rank = input.ReadInt32();
  1606.                     lengthA = new Int32[rank];
  1607.                     lowerBoundA = new Int32[rank];
  1608.                     for (int i = 0; i < rank; i++)
  1609.                         lengthA[i] = input.ReadInt32();
  1610.                     if ((binaryArrayTypeEnum == BinaryArrayTypeEnum.SingleOffset) || (binaryArrayTypeEnum == BinaryArrayTypeEnum.JaggedOffset) || (binaryArrayTypeEnum == BinaryArrayTypeEnum.RectangularOffset)) {
  1611.                         for (int i = 0; i < rank; i++)
  1612.                             lowerBoundA[i] = input.ReadInt32();
  1613.                     }
  1614.                     binaryTypeEnum = (BinaryTypeEnum)input.ReadByte();
  1615.                     typeInformation = BinaryConverter.ReadTypeInfo(binaryTypeEnum, input, out assemId);
  1616.                     break;
  1617.             }
  1618.         }
  1619.        
  1620.         #if _DEBUG
  1621.         public void Dump()
  1622.         {
  1623.             DumpInternal();
  1624.         }
  1625.        
  1626.         [Conditional("_LOGGING")]
  1627.         private void DumpInternal()
  1628.         {
  1629.             if (BCLDebug.CheckEnabled("BINARY")) {
  1630.                 switch (binaryHeaderEnum) {
  1631.                     case BinaryHeaderEnum.ArraySinglePrimitive:
  1632.                         BCLDebug.Trace("BINARY", "*****ArraySinglePrimitive*****");
  1633.                         BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", ((Enum)binaryHeaderEnum).ToString());
  1634.                         BinaryUtil.NVTraceI("objectId (Int32)", objectId);
  1635.                         BinaryUtil.NVTraceI("length (Int32)", lengthA[0]);
  1636.                         BinaryUtil.NVTraceI("InternalPrimitiveTypeE (Byte)", ((Enum)typeInformation).ToString());
  1637.                         BCLDebug.Trace("BINARY", "****************************");
  1638.                         break;
  1639.                     case BinaryHeaderEnum.ArraySingleString:
  1640.                         BCLDebug.Trace("BINARY", "*****ArraySingleString*****");
  1641.                         BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", ((Enum)binaryHeaderEnum).ToString());
  1642.                         BinaryUtil.NVTraceI("objectId (Int32)", objectId);
  1643.                         BinaryUtil.NVTraceI("length (Int32)", lengthA[0]);
  1644.                         BCLDebug.Trace("BINARY", "****************************");
  1645.                         break;
  1646.                     case BinaryHeaderEnum.ArraySingleObject:
  1647.                         BCLDebug.Trace("BINARY", "*****ArraySingleObject*****");
  1648.                         BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", ((Enum)binaryHeaderEnum).ToString());
  1649.                         BinaryUtil.NVTraceI("objectId (Int32)", objectId);
  1650.                         BinaryUtil.NVTraceI("length (Int32)", lengthA[0]);
  1651.                         BCLDebug.Trace("BINARY", "****************************");
  1652.                         break;
  1653.                     default:
  1654.                         BCLDebug.Trace("BINARY", "*****BinaryArray*****");
  1655.                         BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", ((Enum)binaryHeaderEnum).ToString());
  1656.                         BinaryUtil.NVTraceI("objectId (Int32)", objectId);
  1657.                         BinaryUtil.NVTraceI("binaryArrayTypeEnum (Byte)", ((Enum)binaryArrayTypeEnum).ToString());
  1658.                         BinaryUtil.NVTraceI("rank (Int32)", rank);
  1659.                         for (int i = 0; i < rank; i++)
  1660.                             BinaryUtil.NVTraceI("length (Int32)", lengthA[i]);
  1661.                         if ((binaryArrayTypeEnum == BinaryArrayTypeEnum.SingleOffset) || (binaryArrayTypeEnum == BinaryArrayTypeEnum.JaggedOffset) || (binaryArrayTypeEnum == BinaryArrayTypeEnum.RectangularOffset)) {
  1662.                             for (int i = 0; i < rank; i++)
  1663.                                 BinaryUtil.NVTraceI("lowerBound (Int32)", lowerBoundA[i]);
  1664.                         }
  1665.                         BinaryUtil.NVTraceI("binaryTypeEnum (Byte)", ((Enum)binaryTypeEnum).ToString());
  1666.                         if ((binaryTypeEnum == BinaryTypeEnum.Primitive) || (binaryTypeEnum == BinaryTypeEnum.PrimitiveArray) || (binaryTypeEnum == BinaryTypeEnum.ObjectUrt) || (binaryTypeEnum == BinaryTypeEnum.ObjectUser))
  1667.                             BinaryUtil.NVTraceI("typeInformation " + BinaryConverter.TypeInfoTraceString(typeInformation), typeInformation);
  1668.                         if (binaryTypeEnum == BinaryTypeEnum.ObjectUser)
  1669.                             BinaryUtil.NVTraceI("assemId (Int32)", assemId);
  1670.                         BCLDebug.Trace("BINARY", "****************************");
  1671.                         break;
  1672.                 }
  1673.             }
  1674.         }
  1675.         #endif
  1676.     }
  1677.    
  1678.     internal sealed class MemberPrimitiveUnTyped : IStreamable
  1679.     {
  1680.         // Used for members with primitive values and types are needed
  1681.        
  1682.         internal InternalPrimitiveTypeE typeInformation;
  1683.         internal object value;
  1684.        
  1685.         internal MemberPrimitiveUnTyped()
  1686.         {
  1687.         }
  1688.        
  1689.         internal void Set(InternalPrimitiveTypeE typeInformation, object value)
  1690.         {
  1691.             SerTrace.Log(this, "MemberPrimitiveUnTyped Set typeInformation ", typeInformation, " value ", value);
  1692.             this.typeInformation = typeInformation;
  1693.             this.value = value;
  1694.         }
  1695.        
  1696.         internal void Set(InternalPrimitiveTypeE typeInformation)
  1697.         {
  1698.             SerTrace.Log(this, "MemberPrimitiveUnTyped Set ", typeInformation);
  1699.             this.typeInformation = typeInformation;
  1700.         }
  1701.        
  1702.        
  1703.        
  1704.         public void Write(__BinaryWriter sout)
  1705.         {
  1706.             sout.WriteValue(typeInformation, value);
  1707.         }
  1708.        
  1709.         public void Read(__BinaryParser input)
  1710.         {
  1711.             //binaryHeaderEnum = input.ReadByte(); already read
  1712.             value = input.ReadValue(typeInformation);
  1713.         }
  1714.        
  1715.         public void Dump()
  1716.         {
  1717.             DumpInternal();
  1718.         }
  1719.        
  1720.         [Conditional("_LOGGING")]
  1721.         private void DumpInternal()
  1722.         {
  1723.             if (BCLDebug.CheckEnabled("BINARY")) {
  1724.                 string typeString = Converter.ToComType(typeInformation);
  1725.                 BCLDebug.Trace("BINARY", "*****MemberPrimitiveUnTyped*****");
  1726.                 BinaryUtil.NVTraceI("value (" + typeString + ")", value);
  1727.                 BCLDebug.Trace("BINARY", "****************************");
  1728.             }
  1729.         }
  1730.     }
  1731.    
  1732.    
  1733.     internal sealed class MemberReference : IStreamable
  1734.     {
  1735.         internal Int32 idRef;
  1736.        
  1737.         internal MemberReference()
  1738.         {
  1739.         }
  1740.        
  1741.         internal void Set(Int32 idRef)
  1742.         {
  1743.             SerTrace.Log(this, "MemberReference Set ", idRef);
  1744.             this.idRef = idRef;
  1745.         }
  1746.        
  1747.         public void Write(__BinaryWriter sout)
  1748.         {
  1749.             sout.WriteByte((byte)BinaryHeaderEnum.MemberReference);
  1750.             sout.WriteInt32(idRef);
  1751.         }
  1752.        
  1753.         public void Read(__BinaryParser input)
  1754.         {
  1755.             //binaryHeaderEnum = input.ReadByte(); already read
  1756.             idRef = input.ReadInt32();
  1757.         }
  1758.        
  1759.         public void Dump()
  1760.         {
  1761.             DumpInternal();
  1762.         }
  1763.        
  1764.         [Conditional("_LOGGING")]
  1765.         private void DumpInternal()
  1766.         {
  1767.             if (BCLDebug.CheckEnabled("BINARY")) {
  1768.                 BCLDebug.Trace("BINARY", "*****MemberReference*****");
  1769.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", ((Enum)BinaryHeaderEnum.MemberReference).ToString());
  1770.                 BinaryUtil.NVTraceI("idRef (Int32)", idRef);
  1771.                 BCLDebug.Trace("BINARY", "****************************");
  1772.             }
  1773.         }
  1774.     }
  1775.    
  1776.     internal sealed class ObjectNull : IStreamable
  1777.     {
  1778.         internal int nullCount;
  1779.        
  1780.         internal ObjectNull()
  1781.         {
  1782.         }
  1783.        
  1784.         internal void SetNullCount(int nullCount)
  1785.         {
  1786.             this.nullCount = nullCount;
  1787.         }
  1788.        
  1789.         public void Write(__BinaryWriter sout)
  1790.         {
  1791.             if (nullCount == 1) {
  1792.                 sout.WriteByte((byte)BinaryHeaderEnum.ObjectNull);
  1793.             }
  1794.             else if (nullCount < 256) {
  1795.                 sout.WriteByte((byte)BinaryHeaderEnum.ObjectNullMultiple256);
  1796.                 sout.WriteByte((byte)nullCount);
  1797.                 //Console.WriteLine("Write nullCount "+nullCount);
  1798.             }
  1799.             else {
  1800.                 sout.WriteByte((byte)BinaryHeaderEnum.ObjectNullMultiple);
  1801.                 sout.WriteInt32(nullCount);
  1802.                 //Console.WriteLine("Write nullCount "+nullCount);
  1803.             }
  1804.         }
  1805.        
  1806.        
  1807.         public void Read(__BinaryParser input)
  1808.         {
  1809.             Read(input, BinaryHeaderEnum.ObjectNull);
  1810.         }
  1811.        
  1812.         public void Read(__BinaryParser input, BinaryHeaderEnum binaryHeaderEnum)
  1813.         {
  1814.             //binaryHeaderEnum = input.ReadByte(); already read
  1815.             switch (binaryHeaderEnum) {
  1816.                 case BinaryHeaderEnum.ObjectNull:
  1817.                     nullCount = 1;
  1818.                     break;
  1819.                 case BinaryHeaderEnum.ObjectNullMultiple256:
  1820.                     nullCount = input.ReadByte();
  1821.                     //Console.WriteLine("Read nullCount "+nullCount);
  1822.                     break;
  1823.                 case BinaryHeaderEnum.ObjectNullMultiple:
  1824.                     nullCount = input.ReadInt32();
  1825.                     //Console.WriteLine("Read nullCount "+nullCount);
  1826.                     break;
  1827.             }
  1828.         }
  1829.        
  1830.         public void Dump()
  1831.         {
  1832.             DumpInternal();
  1833.         }
  1834.        
  1835.         [Conditional("_LOGGING")]
  1836.         private void DumpInternal()
  1837.         {
  1838.             if (BCLDebug.CheckEnabled("BINARY")) {
  1839.                 BCLDebug.Trace("BINARY", "*****ObjectNull*****");
  1840.                 if (nullCount == 1) {
  1841.                     BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "ObjectNull");
  1842.                 }
  1843.                 else if (nullCount < 256) {
  1844.                     BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "ObjectNullMultiple256");
  1845.                     BinaryUtil.NVTraceI("nullCount (Byte)", nullCount);
  1846.                 }
  1847.                 else {
  1848.                     BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "ObjectNullMultiple");
  1849.                     BinaryUtil.NVTraceI("nullCount (Int32)", nullCount);
  1850.                 }
  1851.                
  1852.                 BCLDebug.Trace("BINARY", "********************");
  1853.             }
  1854.         }
  1855.     }
  1856.    
  1857.     internal sealed class MessageEnd : IStreamable
  1858.     {
  1859.        
  1860.         internal MessageEnd()
  1861.         {
  1862.         }
  1863.        
  1864.         public void Write(__BinaryWriter sout)
  1865.         {
  1866.             sout.WriteByte((byte)BinaryHeaderEnum.MessageEnd);
  1867.         }
  1868.        
  1869.         public void Read(__BinaryParser input)
  1870.         {
  1871.             //binaryHeaderEnum = input.ReadByte(); already read
  1872.         }
  1873.        
  1874.         public void Dump()
  1875.         {
  1876.             DumpInternal(null);
  1877.         }
  1878.        
  1879.         public void Dump(Stream sout)
  1880.         {
  1881.             DumpInternal(sout);
  1882.         }
  1883.        
  1884.         [Conditional("_LOGGING")]
  1885.         private void DumpInternal(Stream sout)
  1886.         {
  1887.             if (BCLDebug.CheckEnabled("BINARY")) {
  1888.                 BCLDebug.Trace("BINARY", "*****MessageEnd*****");
  1889.                 BinaryUtil.NVTraceI("binaryHeaderEnum (Byte)", "MessageEnd");
  1890.                 long length = -1;
  1891.                 if (sout != null && sout.CanSeek) {
  1892.                     length = sout.Length;
  1893.                     BinaryUtil.NVTraceI("Total Message Length in Bytes ", length);
  1894.                 }
  1895.                 BCLDebug.Trace("BINARY", "********************");
  1896.             }
  1897.         }
  1898.     }
  1899.    
  1900.    
  1901.     // When an ObjectWithMap or an ObjectWithMapTyped is read off the stream, an ObjectMap class is created
  1902.     // to remember the type information.
  1903.     internal sealed class ObjectMap
  1904.     {
  1905.         internal string objectName;
  1906.         internal Type objectType;
  1907.        
  1908.         internal BinaryTypeEnum[] binaryTypeEnumA;
  1909.         internal object[] typeInformationA;
  1910.         internal Type[] memberTypes;
  1911.         internal string[] memberNames;
  1912.         internal ReadObjectInfo objectInfo;
  1913.         internal bool isInitObjectInfo = true;
  1914.         internal ObjectReader objectReader = null;
  1915.         internal Int32 objectId;
  1916.         internal BinaryAssemblyInfo assemblyInfo;
  1917.        
  1918.         internal ObjectMap(string objectName, Type objectType, string[] memberNames, ObjectReader objectReader, Int32 objectId, BinaryAssemblyInfo assemblyInfo)
  1919.         {
  1920.             SerTrace.Log(this, "Constructor 1 objectName ", objectName, ", objectType ", objectType);
  1921.             this.objectName = objectName;
  1922.             this.objectType = objectType;
  1923.             this.memberNames = memberNames;
  1924.             this.objectReader = objectReader;
  1925.             this.objectId = objectId;
  1926.             this.assemblyInfo = assemblyInfo;
  1927.            
  1928.             objectInfo = objectReader.CreateReadObjectInfo(objectType);
  1929.             memberTypes = objectInfo.GetMemberTypes(memberNames, objectType);
  1930.            
  1931.             binaryTypeEnumA = new BinaryTypeEnum[memberTypes.Length];
  1932.             typeInformationA = new object[memberTypes.Length];
  1933.            
  1934.             for (int i = 0; i < memberTypes.Length; i++) {
  1935.                 object typeInformation = null;
  1936.                 BinaryTypeEnum binaryTypeEnum = BinaryConverter.GetParserBinaryTypeInfo(memberTypes[i], out typeInformation);
  1937.                 binaryTypeEnumA[i] = binaryTypeEnum;
  1938.                 typeInformationA[i] = typeInformation;
  1939.             }
  1940.         }
  1941.        
  1942.         internal ObjectMap(string objectName, string[] memberNames, BinaryTypeEnum[] binaryTypeEnumA, object[] typeInformationA, int[] memberAssemIds, ObjectReader objectReader, Int32 objectId, BinaryAssemblyInfo assemblyInfo, SizedArray assemIdToAssemblyTable)
  1943.         {
  1944.             SerTrace.Log(this, "Constructor 2 objectName ", objectName);
  1945.             this.objectName = objectName;
  1946.             this.memberNames = memberNames;
  1947.             this.binaryTypeEnumA = binaryTypeEnumA;
  1948.             this.typeInformationA = typeInformationA;
  1949.             this.objectReader = objectReader;
  1950.             this.objectId = objectId;
  1951.             this.assemblyInfo = assemblyInfo;
  1952.            
  1953.             if (assemblyInfo == null)
  1954.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Serialization_Assembly"), objectName));
  1955.            
  1956.             objectType = objectReader.GetType(assemblyInfo, objectName);
  1957.            
  1958.             memberTypes = new Type[memberNames.Length];
  1959.            
  1960.             for (int i = 0; i < memberNames.Length; i++) {
  1961.                 InternalPrimitiveTypeE primitiveTypeEnum;
  1962.                 string typeString;
  1963.                 Type type;
  1964.                 bool isVariant;
  1965.                
  1966.                 BinaryConverter.TypeFromInfo(binaryTypeEnumA[i], typeInformationA[i], objectReader, (BinaryAssemblyInfo)assemIdToAssemblyTable[memberAssemIds[i]], out primitiveTypeEnum, out typeString, out type, out isVariant);
  1967.                 //if (type == null)
  1968.                 // throw new SerializationException(String.Format(Environment.GetResourceString("Serialization_TypeResolved"),objectName+" "+memberNames[i]+" "+typeInformationA[i]));
  1969.                 memberTypes[i] = type;
  1970.             }
  1971.            
  1972.             objectInfo = objectReader.CreateReadObjectInfo(objectType, memberNames, null);
  1973.             if (!objectInfo.isSi)
  1974.                 objectInfo.GetMemberTypes(memberNames, objectInfo.objectType);
  1975.             // Check version match
  1976.         }
  1977.        
  1978.         internal ReadObjectInfo CreateObjectInfo(ref SerializationInfo si, ref object[] memberData)
  1979.         {
  1980.             if (isInitObjectInfo) {
  1981.                 isInitObjectInfo = false;
  1982.                 objectInfo.InitDataStore(ref si, ref memberData);
  1983.                 return objectInfo;
  1984.             }
  1985.             else {
  1986.                 objectInfo.PrepareForReuse();
  1987.                 objectInfo.InitDataStore(ref si, ref memberData);
  1988.                 return objectInfo;
  1989.             }
  1990.         }
  1991.        
  1992.        
  1993.         // No member type information
  1994.         static internal ObjectMap Create(string name, Type objectType, string[] memberNames, ObjectReader objectReader, Int32 objectId, BinaryAssemblyInfo assemblyInfo)
  1995.         {
  1996.             return new ObjectMap(name, objectType, memberNames, objectReader, objectId, assemblyInfo);
  1997.         }
  1998.        
  1999.         // Member type information
  2000.         static internal ObjectMap Create(string name, string[] memberNames, BinaryTypeEnum[] binaryTypeEnumA, object[] typeInformationA, int[] memberAssemIds, ObjectReader objectReader, Int32 objectId, BinaryAssemblyInfo assemblyInfo, SizedArray assemIdToAssemblyTable)
  2001.         {
  2002.             return new ObjectMap(name, memberNames, binaryTypeEnumA, typeInformationA, memberAssemIds, objectReader, objectId, assemblyInfo, assemIdToAssemblyTable);
  2003.         }
  2004.     }
  2005.    
  2006.     // For each object or array being read off the stream, an ObjectProgress object is created. This object
  2007.     // keeps track of the progress of the parsing. When an object is being parsed, it keeps track of
  2008.     // the object member being parsed. When an array is being parsed it keeps track of the position within the
  2009.     // array.
  2010.     internal sealed class ObjectProgress
  2011.     {
  2012.         static internal int opRecordIdCount = 1;
  2013.         internal int opRecordId;
  2014.        
  2015.        
  2016.         // Control
  2017.         internal bool isInitial;
  2018.         internal int count;
  2019.         //Progress count
  2020.         internal BinaryTypeEnum expectedType = BinaryTypeEnum.ObjectUrt;
  2021.         internal object expectedTypeInformation = null;
  2022.        
  2023.         internal string name;
  2024.         internal InternalObjectTypeE objectTypeEnum = InternalObjectTypeE.Empty;
  2025.         internal InternalMemberTypeE memberTypeEnum;
  2026.         internal InternalMemberValueE memberValueEnum;
  2027.         internal Type dtType;
  2028.        
  2029.         // Array Information
  2030.         internal int numItems;
  2031.         internal BinaryTypeEnum binaryTypeEnum;
  2032.         internal object typeInformation;
  2033.         internal int nullCount;
  2034.        
  2035.         // Member Information
  2036.         internal int memberLength;
  2037.         internal BinaryTypeEnum[] binaryTypeEnumA;
  2038.         internal object[] typeInformationA;
  2039.         internal string[] memberNames;
  2040.         internal Type[] memberTypes;
  2041.        
  2042.         // ParseRecord
  2043.         internal ParseRecord pr = new ParseRecord();
  2044.        
  2045.        
  2046.         internal ObjectProgress()
  2047.         {
  2048.             Counter();
  2049.         }
  2050.        
  2051.         [Conditional("SER_LOGGING")]
  2052.         private void Counter()
  2053.         {
  2054.             lock (this) {
  2055.                 opRecordId = opRecordIdCount++;
  2056.                 if (opRecordIdCount > 1000)
  2057.                     opRecordIdCount = 1;
  2058.             }
  2059.         }
  2060.        
  2061.         internal void Init()
  2062.         {
  2063.             isInitial = false;
  2064.             count = 0;
  2065.             expectedType = BinaryTypeEnum.ObjectUrt;
  2066.             expectedTypeInformation = null;
  2067.            
  2068.             name = null;
  2069.             objectTypeEnum = InternalObjectTypeE.Empty;
  2070.             memberTypeEnum = InternalMemberTypeE.Empty;
  2071.             memberValueEnum = InternalMemberValueE.Empty;
  2072.             dtType = null;
  2073.            
  2074.             // Array Information
  2075.             numItems = 0;
  2076.             nullCount = 0;
  2077.             //binaryTypeEnum
  2078.             typeInformation = null;
  2079.            
  2080.             // Member Information
  2081.             memberLength = 0;
  2082.             binaryTypeEnumA = null;
  2083.             typeInformationA = null;
  2084.             memberNames = null;
  2085.             memberTypes = null;
  2086.            
  2087.             pr.Init();
  2088.         }
  2089.        
  2090.         //Array item entry of nulls has a count of nulls represented by that item. The first null has been
  2091.         // incremented by GetNext, the rest of the null counts are incremented here
  2092.         internal void ArrayCountIncrement(int value)
  2093.         {
  2094.             count += value;
  2095.         }
  2096.        
  2097.         // Specifies what is to parsed next from the wire.
  2098.         internal bool GetNext(out BinaryTypeEnum outBinaryTypeEnum, out object outTypeInformation)
  2099.         {
  2100.             //Initialize the out params up here.
  2101.             outBinaryTypeEnum = BinaryTypeEnum.Primitive;
  2102.             outTypeInformation = null;
  2103.            
  2104.             #if _DEBUG
  2105.             SerTrace.Log(this, "GetNext Entry");
  2106.             Dump();
  2107.             #endif
  2108.            
  2109.             if (objectTypeEnum == InternalObjectTypeE.Array) {
  2110.                 SerTrace.Log(this, "GetNext Array");
  2111.                 // Array
  2112.                 if (count == numItems)
  2113.                     return false;
  2114.                 else {
  2115.                     outBinaryTypeEnum = binaryTypeEnum;
  2116.                     outTypeInformation = typeInformation;
  2117.                     if (count == 0)
  2118.                         isInitial = false;
  2119.                     count++;
  2120.                     SerTrace.Log(this, "GetNext Array Exit ", ((Enum)outBinaryTypeEnum).ToString(), " ", outTypeInformation);
  2121.                     return true;
  2122.                 }
  2123.             }
  2124.             else {
  2125.                 // Member
  2126.                 SerTrace.Log(this, "GetNext Member");
  2127.                 if ((count == memberLength) && (!isInitial))
  2128.                     return false;
  2129.                 else {
  2130.                     outBinaryTypeEnum = binaryTypeEnumA[count];
  2131.                     outTypeInformation = typeInformationA[count];
  2132.                     if (count == 0)
  2133.                         isInitial = false;
  2134.                     name = memberNames[count];
  2135.                     if (memberTypes == null) {
  2136.                         SerTrace.Log(this, "GetNext memberTypes = null");
  2137.                     }
  2138.                     dtType = memberTypes[count];
  2139.                     count++;
  2140.                     SerTrace.Log(this, "GetNext Member Exit ", ((Enum)outBinaryTypeEnum).ToString(), " ", outTypeInformation, " memberName ", name);
  2141.                     return true;
  2142.                 }
  2143.             }
  2144.         }
  2145.        
  2146.         #if _DEBUG
  2147.         // Get a String describing the ObjectProgress Record
  2148.         public string Trace()
  2149.         {
  2150.             return "ObjectProgress " + opRecordId + " name " + Util.PString(name) + " expectedType " + ((Enum)expectedType).ToString();
  2151.         }
  2152.        
  2153.         // Dump contents of record
  2154.        
  2155.         [Conditional("SER_LOGGING")]
  2156.         internal void Dump()
  2157.         {
  2158.             try {
  2159.                 SerTrace.Log("ObjectProgress Dump ");
  2160.                 Util.NVTrace("opRecordId", opRecordId);
  2161.                 Util.NVTrace("isInitial", isInitial);
  2162.                 Util.NVTrace("count", count);
  2163.                 Util.NVTrace("expectedType", ((Enum)expectedType).ToString());
  2164.                 Util.NVTrace("expectedTypeInformation", expectedTypeInformation);
  2165.                 SerTrace.Log("ParseRecord Information");
  2166.                 Util.NVTrace("name", name);
  2167.                 Util.NVTrace("objectTypeEnum", ((Enum)objectTypeEnum).ToString());
  2168.                 Util.NVTrace("memberTypeEnum", ((Enum)memberTypeEnum).ToString());
  2169.                 Util.NVTrace("memberValueEnum", ((Enum)memberValueEnum).ToString());
  2170.                 if (dtType != null)
  2171.                     Util.NVTrace("dtType", dtType.ToString());
  2172.                 SerTrace.Log("Array Information");
  2173.                 Util.NVTrace("numItems", numItems);
  2174.                 Util.NVTrace("binaryTypeEnum", ((Enum)binaryTypeEnum).ToString());
  2175.                 Util.NVTrace("typeInformation", typeInformation);
  2176.                 SerTrace.Log("Member Information");
  2177.                 Util.NVTrace("memberLength", memberLength);
  2178.                 if (binaryTypeEnumA != null) {
  2179.                     for (int i = 0; i < memberLength; i++)
  2180.                         Util.NVTrace("binaryTypeEnumA", ((Enum)binaryTypeEnumA[i]).ToString());
  2181.                 }
  2182.                 if (typeInformationA != null) {
  2183.                     for (int i = 0; i < memberLength; i++)
  2184.                         Util.NVTrace("typeInformationA", typeInformationA[i]);
  2185.                 }
  2186.                 if (memberNames != null) {
  2187.                     for (int i = 0; i < memberLength; i++)
  2188.                         Util.NVTrace("memberNames", memberNames[i]);
  2189.                 }
  2190.                 if (memberTypes != null) {
  2191.                     for (int i = 0; i < memberLength; i++)
  2192.                         Util.NVTrace("memberTypes", memberTypes[i].ToString());
  2193.                 }
  2194.             }
  2195.             catch (Exception e) {
  2196.                 BCLDebug.Log("[ObjectProgress.Dump]Unable to Dump Object Progress.");
  2197.                 BCLDebug.Log("[ObjectProgress.Dump]Error: " + e);
  2198.             }
  2199.         }
  2200.         #endif
  2201.     }
  2202.    
  2203. }

Developer Fusion