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

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

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. //============================================================
  16. //
  17. // Class: SerObjectInfo
  18. // Purpose: Holds information about an objects Members
  19. //
  20. // Date: September 29, 1999
  21. //
  22. //============================================================
  25. namespace System.Runtime.Serialization.Formatters.Soap
  26. {
  27.     using System.Runtime.Remoting;
  28.     using System.Runtime.Remoting.Metadata;
  29.     using System.Runtime.Serialization;
  30.     using System;
  31.     using System.Collections;
  32.     using System.Reflection;
  33.     using System.Diagnostics;
  34.     using System.Globalization;
  35.    
  36.     // This class contains information about an object. It is used so that
  37.     // the rest of the Formatter routines can use a common interface for
  38.     // a normal object, an ISerializable object, and a surrogate object
  39.     //
  40.     // The methods in this class are for the internal use of the Formatters.
  41.     // There use will be restricted when signing is supported for assemblies
  42.     internal sealed class WriteObjectInfo
  43.     {
  44.         internal int objectInfoId;
  45.        
  46.         internal object obj;
  47.         internal Type objectType;
  48.        
  49.         internal bool isSi = false;
  50.         internal bool isNamed = false;
  51.         internal bool isTyped = false;
  52.        
  53.         internal SerializationInfo si = null;
  54.        
  55.         internal SerObjectInfoCache cache = null;
  56.        
  57.         internal object[] memberData = null;
  58.         internal ISerializationSurrogate serializationSurrogate = null;
  59.         internal ISurrogateSelector surrogateSelector;
  60.         internal IFormatterConverter converter;
  61.        
  62.         internal StreamingContext context;
  63.        
  64.         internal SerObjectInfoInit serObjectInfoInit = null;
  65.        
  66.         // Writing and Parsing information
  67.         internal long objectId;
  68.         internal long assemId;
  69.        
  70.         private int lastPosition = 0;
  71.         private SoapAttributeInfo parentMemberAttributeInfo;
  72.         internal bool isArray = false;
  73.         internal SoapAttributeInfo typeAttributeInfo;
  74.         internal WriteObjectInfo arrayElemObjectInfo;
  75.        
  76.        
  77.         internal WriteObjectInfo()
  78.         {
  79.         }
  80.        
  81.         internal void ObjectEnd()
  82.         {
  83.             InternalST.Soap(this, objectInfoId, " objectType ", objectType, " ObjectEnd");
  84.             PutObjectInfo(serObjectInfoInit, this);
  85.         }
  86.        
  87.         private void InternalInit()
  88.         {
  89.             InternalST.Soap(this, objectInfoId, " InternalInit");
  90.             obj = null;
  91.             objectType = null;
  92.             isSi = false;
  93.             isNamed = false;
  94.             isTyped = false;
  95.             si = null;
  96.             cache = null;
  97.             memberData = null;
  98.             isArray = false;
  99.            
  100.             // Writing and Parsing information
  101.             objectId = 0;
  102.             assemId = 0;
  103.            
  104.             // Added for Soap
  105.             lastPosition = 0;
  106.             typeAttributeInfo = null;
  107.             parentMemberAttributeInfo = null;
  108.             arrayElemObjectInfo = null;
  109.         }
  110.        
  111.         static internal WriteObjectInfo Serialize(object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SoapAttributeInfo attributeInfo, ObjectWriter objectWriter)
  112.         {
  113.             WriteObjectInfo soi = GetObjectInfo(serObjectInfoInit);
  114.            
  115.             soi.InitSerialize(obj, surrogateSelector, context, serObjectInfoInit, converter, attributeInfo, objectWriter);
  116.             return soi;
  117.         }
  118.        
  119.         // Write constructor
  120.         internal void InitSerialize(object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SoapAttributeInfo attributeInfo, ObjectWriter objectWriter)
  121.         {
  122.             InternalST.Soap(this, objectInfoId, " Constructor 1 ", obj);
  123.             this.context = context;
  124.             this.obj = obj;
  125.             this.serObjectInfoInit = serObjectInfoInit;
  126.             this.parentMemberAttributeInfo = attributeInfo;
  127.             this.surrogateSelector = surrogateSelector;
  128.             this.converter = converter;
  129.             ISurrogateSelector surrogateSelectorTemp;
  130.            
  131.             if (RemotingServices.IsTransparentProxy(obj))
  132.                 objectType = Converter.typeofMarshalByRefObject;
  133.             else
  134.                 objectType = obj.GetType();
  135.            
  136.             if (objectType.IsArray) {
  137.                 arrayElemObjectInfo = Serialize(objectType.GetElementType(), surrogateSelector, context, serObjectInfoInit, converter, null);
  138.                 typeAttributeInfo = GetTypeAttributeInfo();
  139.                 isArray = true;
  140.                 InitNoMembers();
  141.                 return;
  142.             }
  143.            
  144.             InternalST.Soap(this, objectInfoId, " Constructor 1 trace 2");
  145.            
  146.             typeAttributeInfo = GetTypeAttributeInfo();
  147.            
  148.             objectWriter.ObjectManager.RegisterObject(obj);
  149.             if (surrogateSelector != null && (serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp)) != null) {
  150.                 InternalST.Soap(this, objectInfoId, " Constructor 1 trace 3");
  151.                 si = new SerializationInfo(objectType, converter);
  152.                 if (!objectType.IsPrimitive)
  153.                     serializationSurrogate.GetObjectData(obj, si, context);
  154.                 InitSiWrite(objectWriter);
  155.             }
  156.             else if (obj is ISerializable) {
  157.                 if (!objectType.IsSerializable) {
  158.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_NonSerType"), objectType.FullName, objectType.Module.Assembly.FullName));
  159.                 }
  160.                 si = new SerializationInfo(objectType, converter);
  161.                 ((ISerializable)obj).GetObjectData(si, context);
  162.                 InternalST.Soap(this, objectInfoId, " Constructor 1 trace 4 ISerializable " + objectType);
  163.                 InitSiWrite(objectWriter);
  164.             }
  165.             else {
  166.                 InternalST.Soap(this, objectInfoId, " Constructor 1 trace 5");
  167.                 InitMemberInfo();
  168.             }
  169.         }
  170.        
  171.         [Conditional("SER_LOGGING")]
  172.         private void DumpMemberInfo()
  173.         {
  174.             for (int i = 0; i < cache.memberInfos.Length; i++) {
  175.                 InternalST.Soap(this, objectInfoId, " Constructor 1 memberInfos data ", cache.memberInfos[i].Name, " ", memberData[i]);
  176.                
  177.             }
  178.         }
  179.        
  180.         static internal WriteObjectInfo Serialize(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SoapAttributeInfo attributeInfo)
  181.         {
  182.             WriteObjectInfo soi = GetObjectInfo(serObjectInfoInit);
  183.             soi.InitSerialize(objectType, surrogateSelector, context, serObjectInfoInit, converter, attributeInfo);
  184.             return soi;
  185.         }
  186.        
  187.         // Write Constructor used for array types or null members
  188.         internal void InitSerialize(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, SoapAttributeInfo attributeInfo)
  189.         {
  190.            
  191.             InternalST.Soap(this, objectInfoId, " Constructor 2 ", objectType);
  192.            
  193.             this.objectType = objectType;
  194.             this.context = context;
  195.             this.serObjectInfoInit = serObjectInfoInit;
  196.             this.parentMemberAttributeInfo = attributeInfo;
  197.             this.surrogateSelector = surrogateSelector;
  198.             this.converter = converter;
  199.            
  200.             if (objectType.IsArray) {
  201.                 arrayElemObjectInfo = Serialize(objectType.GetElementType(), surrogateSelector, context, serObjectInfoInit, converter, null);
  202.                 typeAttributeInfo = GetTypeAttributeInfo();
  203.                 InitNoMembers();
  204.                 return;
  205.             }
  206.            
  207.             typeAttributeInfo = GetTypeAttributeInfo();
  208.            
  209.             ISurrogateSelector surrogateSelectorTemp = null;
  210.            
  211.             if (surrogateSelector != null)
  212.                 serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp);
  213.            
  214.             if (serializationSurrogate != null) {
  215.                 isSi = true;
  216.             }
  217.             else if (objectType == Converter.typeofObject) {
  218.             }
  219.             else if (Converter.typeofISerializable.IsAssignableFrom(objectType))
  220.                 isSi = true;
  221.            
  222.             if (isSi) {
  223.                 si = new SerializationInfo(objectType, converter);
  224.                 cache = new SerObjectInfoCache();
  225.                 cache.fullTypeName = si.FullTypeName;
  226.                 cache.assemblyString = si.AssemblyName;
  227.             }
  228.             else {
  229.                 InitMemberInfo();
  230.             }
  231.            
  232.             InternalST.Soap(this, objectInfoId, " ", objectType, " InitSerialize Exit ", isSi);
  233.         }
  234.        
  235.         private void InitSiWrite(ObjectWriter objectWriter)
  236.         {
  237.             InternalST.Soap(this, objectInfoId, " InitSiWrite Entry ");
  238.             // FormatterWrapper instructs the Formatters to use the
  239.             // __WrappedObject has the real object. This is a way
  240.             // to get Surrogates to return a real object.
  241.             if (si.FullTypeName.Equals("FormatterWrapper")) {
  242.                 obj = si.GetValue("__WrappedObject", Converter.typeofObject);
  243.                 InitSerialize(obj, surrogateSelector, context, serObjectInfoInit, converter, null, objectWriter);
  244.             }
  245.             else {
  246.                
  247.                 SerializationInfoEnumerator siEnum = null;
  248.                 isSi = true;
  249.                 siEnum = si.GetEnumerator();
  250.                 int infoLength = 0;
  251.                
  252.                 infoLength = si.MemberCount;
  253.                
  254.                 int count = infoLength;
  255.                
  256.                 // For ISerializable cache cannot be saved because each object instance can have different values
  257.                 // BinaryWriter only puts the map on the wire if the ISerializable map cannot be reused.
  258.                 cache = new SerObjectInfoCache();
  259.                 cache.memberNames = new string[count];
  260.                 cache.memberTypes = new Type[count];
  261.                 memberData = new object[count];
  262.                
  263.                 cache.fullTypeName = si.FullTypeName;
  264.                 cache.assemblyString = si.AssemblyName;
  265.                 siEnum = si.GetEnumerator();
  266.                 for (int i = 0; siEnum.MoveNext(); i++) {
  267.                     cache.memberNames[i] = siEnum.Name;
  268.                     cache.memberTypes[i] = siEnum.ObjectType;
  269.                     memberData[i] = siEnum.Value;
  270.                     InternalST.Soap(this, objectInfoId + " ", objectType, " InitSiWrite ", cache.memberNames[i], " Type ", cache.memberTypes[i], " data ", memberData[i]);
  271.                 }
  272.                
  273.                 isNamed = true;
  274.                 isTyped = false;
  275.             }
  276.             InternalST.Soap(this, objectInfoId, " InitSiWrite Exit ");
  277.         }
  278.        
  279.         private void InitNoMembers()
  280.         {
  281.             cache = (SerObjectInfoCache)serObjectInfoInit.seenBeforeTable[objectType];
  282.             if (cache == null) {
  283.                 InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo new cache");
  284.                 cache = new SerObjectInfoCache();
  285.                 cache.fullTypeName = objectType.FullName;
  286.                 cache.assemblyString = objectType.Module.Assembly.FullName;
  287.                 serObjectInfoInit.seenBeforeTable.Add(objectType, cache);
  288.             }
  289.         }
  290.        
  291.         private void InitMemberInfo()
  292.         {
  293.             InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo Entry");
  294.            
  295.             cache = (SerObjectInfoCache)serObjectInfoInit.seenBeforeTable[objectType];
  296.             if (cache == null) {
  297.                 InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo new cache");
  298.                 cache = new SerObjectInfoCache();
  299.                 int count = 0;
  300.                 // byref will only occur for MethodSignature
  301.                 if (!objectType.IsByRef) {
  302.                     cache.memberInfos = FormatterServices.GetSerializableMembers(objectType, context);
  303.                     count = cache.memberInfos.Length;
  304.                 }
  305.                 cache.memberNames = new string[count];
  306.                 cache.memberTypes = new Type[count];
  307.                 cache.memberAttributeInfos = new SoapAttributeInfo[count];
  308.                
  309.                 // Calculate new arrays
  310.                 for (int i = 0; i < count; i++) {
  311.                     cache.memberNames[i] = cache.memberInfos[i].Name;
  312.                     cache.memberTypes[i] = GetMemberType(cache.memberInfos[i]);
  313.                     cache.memberAttributeInfos[i] = Attr.GetMemberAttributeInfo(cache.memberInfos[i], cache.memberNames[i], cache.memberTypes[i]);
  314.                     InternalST.Soap(this, objectInfoId, " InitMemberInfo name ", cache.memberNames[i], ", type ", cache.memberTypes[i], ", memberInfoType ", cache.memberInfos[i].GetType());
  315.                 }
  316.                 cache.fullTypeName = objectType.FullName;
  317.                 cache.assemblyString = objectType.Module.Assembly.FullName;
  318.                 serObjectInfoInit.seenBeforeTable.Add(objectType, cache);
  319.             }
  320.            
  321.             if (obj != null) {
  322.                 memberData = FormatterServices.GetObjectData(obj, cache.memberInfos);
  323.                 DumpMemberInfo();
  324.             }
  325.            
  326.             isTyped = true;
  327.             isNamed = true;
  328.             InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo Exit");
  329.         }
  330.        
  331.        
  332.         // Return type name for the object.
  333.        
  334.         internal string GetTypeFullName()
  335.         {
  336.             InternalST.Soap(this, objectInfoId, " ", objectType, " GetTypeFullName isSi ", isSi, " " + cache.fullTypeName);
  337.             return cache.fullTypeName;
  338.         }
  339.        
  340.         internal string GetAssemblyString()
  341.         {
  342.             string assemblyString = null;
  343.             InternalST.Soap(this, objectInfoId, " ", objectType, " GetAssemblyString Entry isSi ", isSi);
  344.            
  345.             if (arrayElemObjectInfo != null)
  346.                 assemblyString = arrayElemObjectInfo.GetAssemblyString();
  347.             else if (IsAttributeNameSpace())
  348.                 assemblyString = typeAttributeInfo.m_nameSpace;
  349.             else
  350.                 assemblyString = cache.assemblyString;
  351.            
  352.             InternalST.Soap(this, objectInfoId, " ", objectType, " GetAssemblyString Exit ", assemblyString);
  353.             return assemblyString;
  354.         }
  355.        
  356.        
  357.         // Retrieves the member type from the MemberInfo
  358.        
  359.         internal Type GetMemberType(MemberInfo objMember)
  360.         {
  361.             Type objectType = null;
  362.            
  363.             if (objMember is FieldInfo) {
  364.                 objectType = ((FieldInfo)objMember).FieldType;
  365.                 InternalST.Soap(this, objectInfoId, " ", "GetMemberType FieldInfo ", objectType);
  366.             }
  367.             else if (objMember is PropertyInfo) {
  368.                 objectType = ((PropertyInfo)objMember).PropertyType;
  369.                 InternalST.Soap(this, objectInfoId, " ", "GetMemberType PropertyInfo ", objectType);
  370.             }
  371.             else {
  372.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_SerMemberInfo"), objMember.GetType()));
  373.             }
  374.            
  375.             return objectType;
  376.         }
  377.        
  378.         // Return the information about the object's members
  379.        
  380.         internal void GetMemberInfo(out string[] outMemberNames, out Type[] outMemberTypes, out object[] outMemberData, out SoapAttributeInfo[] outAttributeInfo)
  381.         {
  382.             outMemberNames = cache.memberNames;
  383.             outMemberTypes = cache.memberTypes;
  384.             outMemberData = memberData;
  385.             outAttributeInfo = cache.memberAttributeInfos;
  386.            
  387.             if (isSi) {
  388.                 if (!isNamed)
  389.                     throw new SerializationException(SoapUtil.GetResourceString("Serialization_ISerializableMemberInfo"));
  390.             }
  391.         }
  392.        
  393.         private static WriteObjectInfo GetObjectInfo(SerObjectInfoInit serObjectInfoInit)
  394.         {
  395.             WriteObjectInfo objectInfo = null;
  396.            
  397.             if (!serObjectInfoInit.oiPool.IsEmpty()) {
  398.                 objectInfo = (WriteObjectInfo)serObjectInfoInit.oiPool.Pop();
  399.                 objectInfo.InternalInit();
  400.                 //InternalST.Soap( "GetObjectInfo",objectInfo.objectInfoId," GetObjectInfo from pool");
  401.             }
  402.             else {
  403.                 objectInfo = new WriteObjectInfo();
  404.                 objectInfo.objectInfoId = serObjectInfoInit.objectInfoIdCount++;
  405.                 //InternalST.Soap( "GetObjectInfo",objectInfo.objectInfoId," GetObjectInfo new not from pool");
  406.             }
  407.            
  408.             return objectInfo;
  409.         }
  410.        
  411.         private int Position(string name)
  412.         {
  413.             InternalST.Soap(this, objectInfoId, " Position ", lastPosition, " ", name);
  414.             if (cache.memberNames[lastPosition].Equals(name)) {
  415.                 return lastPosition;
  416.             }
  417.             else if ((++lastPosition < cache.memberNames.Length) && (cache.memberNames[lastPosition].Equals(name))) {
  418.                 return lastPosition;
  419.             }
  420.             else {
  421.                 // Search for name
  422.                 InternalST.Soap(this, objectInfoId, " Position miss search for name " + name);
  423.                 for (int i = 0; i < cache.memberNames.Length; i++) {
  424.                     if (cache.memberNames[i].Equals(name)) {
  425.                         lastPosition = i;
  426.                         return lastPosition;
  427.                     }
  428.                 }
  429.                
  430.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_Position"), objectType + " " + name));
  431.             }
  432.         }
  433.        
  434.         private static void PutObjectInfo(SerObjectInfoInit serObjectInfoInit, WriteObjectInfo objectInfo)
  435.         {
  436.             serObjectInfoInit.oiPool.Push(objectInfo);
  437.             //InternalST.Soap( "PutObjectInfo",objectInfo.objectInfoId," PutObjectInfo to pool");
  438.         }
  439.        
  440.         internal bool IsInteropNameSpace()
  441.         {
  442.             if (arrayElemObjectInfo != null)
  443.                 return arrayElemObjectInfo.IsInteropNameSpace();
  444.            
  445.             if (IsAttributeNameSpace() || IsCallElement())
  446.                 return true;
  447.             else
  448.                 return false;
  449.         }
  450.        
  451.         internal bool IsCallElement()
  452.         {
  453.             // This should only return true when this object is being
  454.             // serialized first.
  455.            
  456.             if ((objectType != Converter.typeofObject) && (Converter.typeofIMethodCallMessage.IsAssignableFrom(objectType) && !Converter.typeofIConstructionCallMessage.IsAssignableFrom(objectType)) || (objectType == Converter.typeofReturnMessage) || (objectType == Converter.typeofInternalSoapMessage)) {
  457.                 return true;
  458.             }
  459.             else {
  460.                 return false;
  461.             }
  462.         }
  463.        
  464.         internal bool IsCustomXmlAttribute()
  465.         {
  466.             if (arrayElemObjectInfo != null)
  467.                 return arrayElemObjectInfo.IsCustomXmlAttribute();
  468.            
  469.             if ((typeAttributeInfo != null) && ((typeAttributeInfo.m_attributeType & SoapAttributeType.XmlAttribute) != 0))
  470.                 return true;
  471.             else
  472.                 return false;
  473.         }
  474.        
  475.         internal bool IsCustomXmlElement()
  476.         {
  477.             if (arrayElemObjectInfo != null)
  478.                 return arrayElemObjectInfo.IsCustomXmlElement();
  479.            
  480.             if ((typeAttributeInfo != null) && ((typeAttributeInfo.m_attributeType & SoapAttributeType.XmlElement) != 0))
  481.                 return true;
  482.             else
  483.                 return false;
  484.         }
  485.        
  486.         internal bool IsAttributeNameSpace()
  487.         {
  488.             if (arrayElemObjectInfo != null)
  489.                 return arrayElemObjectInfo.IsAttributeNameSpace();
  490.            
  491.             if ((typeAttributeInfo != null) && (typeAttributeInfo.m_nameSpace != null))
  492.                 return true;
  493.             else
  494.                 return false;
  495.         }
  496.        
  497.         // Check for Interop type (SchemaType)
  498.         private SoapAttributeInfo GetTypeAttributeInfo()
  499.         {
  500.             if (arrayElemObjectInfo != null)
  501.                 return arrayElemObjectInfo.GetTypeAttributeInfo();
  502.            
  503.             SoapAttributeInfo attributeInfo = null;
  504.             if (parentMemberAttributeInfo != null)
  505.                 attributeInfo = parentMemberAttributeInfo;
  506.             else
  507.                 attributeInfo = new SoapAttributeInfo();
  508.            
  509.             Attr.ProcessTypeAttribute(objectType, attributeInfo);
  510.            
  511.             attributeInfo.Dump("type " + objectType);
  512.             return attributeInfo;
  513.         }
  514.        
  515.        
  516.         // Specifies whether the embedded attribute is set for a member.
  517.        
  518.         internal bool IsEmbeddedAttribute(string name)
  519.         {
  520.             InternalST.Soap(this, objectInfoId, " ", objectType, " IsEmbedded Entry ", name);
  521.            
  522.             if (arrayElemObjectInfo != null)
  523.                 return arrayElemObjectInfo.IsEmbeddedAttribute(name);
  524.            
  525.             bool isEmbedded = false;
  526.             if (cache.memberAttributeInfos != null && cache.memberAttributeInfos.Length > 0) {
  527.                 SoapAttributeInfo attributeInfo = cache.memberAttributeInfos[Position(name)];
  528.                 isEmbedded = attributeInfo.IsEmbedded();
  529.             }
  530.             InternalST.Soap(this, objectInfoId, " ", objectType, " IsEmbedded Exit ", isEmbedded);
  531.             return isEmbedded;
  532.         }
  533.     }
  534.    
  535.    
  536.     internal sealed class ReadObjectInfo
  537.     {
  538.         internal int objectInfoId;
  539.        
  540.         internal object obj;
  541.         internal Type objectType;
  542.        
  543.        
  544.         internal ObjectManager objectManager;
  545.        
  546.         internal int count;
  547.        
  548.         internal bool isSi = false;
  549.         internal bool isNamed = false;
  550.         internal bool isTyped = false;
  551.        
  552.         internal SerializationInfo si = null;
  553.        
  554.         internal SerObjectInfoCache cache = null;
  555.        
  556.         internal string[] wireMemberNames = null;
  557.         internal Type[] wireMemberTypes = null;
  558.         internal object[] memberData = null;
  559.         internal string[] memberNames = null;
  560.        
  561.         private int lastPosition = 0;
  562.        
  563.         internal ISurrogateSelector surrogateSelector = null;
  564.         internal ISerializationSurrogate serializationSurrogate = null;
  565.        
  566.         internal StreamingContext context;
  567.        
  568.        
  569.         // Si Read
  570.         internal ArrayList memberTypesList;
  571.        
  572.         internal SerObjectInfoInit serObjectInfoInit = null;
  573.        
  574.         internal IFormatterConverter formatterConverter;
  575.        
  576.         // fake object for soap top record when remoting or IRemotingFormatter interface
  577.         internal bool bfake = false;
  578.         internal bool bSoapFault = false;
  579.         internal ArrayList paramNameList;
  580.         // Contain parameter names in correct order
  581.         private int majorVersion = 0;
  582.         private int minorVersion = 0;
  583.         internal SoapAttributeInfo typeAttributeInfo;
  584.         private ReadObjectInfo arrayElemObjectInfo;
  585.         private int numberMembersSeen = 0;
  586.        
  587.         internal ReadObjectInfo()
  588.         {
  589.         }
  590.        
  591.         internal void ObjectEnd()
  592.         {
  593.             InternalST.Soap(this, objectInfoId, " objectType ", objectType, " ObjectEnd");
  594.             PutObjectInfo(serObjectInfoInit, this);
  595.         }
  596.        
  597.         private void InternalInit()
  598.         {
  599.             InternalST.Soap(this, objectInfoId, " objectType ", objectType, " InternalInit");
  600.             obj = null;
  601.             objectType = null;
  602.             count = 0;
  603.             isSi = false;
  604.             isNamed = false;
  605.             isTyped = false;
  606.             si = null;
  607.             wireMemberNames = null;
  608.             wireMemberTypes = null;
  609.             cache = null;
  610.             lastPosition = 0;
  611.             numberMembersSeen = 0;
  612.            
  613.             bfake = false;
  614.             bSoapFault = false;
  615.             majorVersion = 0;
  616.             minorVersion = 0;
  617.             typeAttributeInfo = null;
  618.             arrayElemObjectInfo = null;
  619.            
  620.            
  621.            
  622.             // Si Read
  623.             if (memberTypesList != null) {
  624.                 memberTypesList.Clear();
  625.             }
  626.            
  627.         }
  628.        
  629.         static internal ReadObjectInfo Create(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, ObjectManager objectManager, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, string assemblyName)
  630.         {
  631.             ReadObjectInfo soi = GetObjectInfo(serObjectInfoInit);
  632.             soi.Init(objectType, surrogateSelector, context, objectManager, serObjectInfoInit, converter, assemblyName);
  633.             return soi;
  634.         }
  635.        
  636.        
  637.         // Read Constructor
  638.         internal void Init(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, ObjectManager objectManager, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, string assemblyName)
  639.         {
  640.            
  641.             InternalST.Soap(this, objectInfoId, " Constructor 3 ", objectType);
  642.            
  643.             this.objectType = objectType;
  644.             this.objectManager = objectManager;
  645.             this.context = context;
  646.             this.serObjectInfoInit = serObjectInfoInit;
  647.             this.formatterConverter = converter;
  648.            
  649.             InitReadConstructor(objectType, surrogateSelector, context, assemblyName);
  650.         }
  651.        
  652.         static internal ReadObjectInfo Create(Type objectType, string[] memberNames, Type[] memberTypes, ISurrogateSelector surrogateSelector, StreamingContext context, ObjectManager objectManager, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, string assemblyName)
  653.         {
  654.             ReadObjectInfo soi = GetObjectInfo(serObjectInfoInit);
  655.             soi.Init(objectType, memberNames, memberTypes, surrogateSelector, context, objectManager, serObjectInfoInit, converter, assemblyName);
  656.             return soi;
  657.         }
  658.        
  659.         // Read Constructor
  660.         internal void Init(Type objectType, string[] memberNames, Type[] memberTypes, ISurrogateSelector surrogateSelector, StreamingContext context, ObjectManager objectManager, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, string assemblyName)
  661.         {
  662.             InternalST.Soap(this, objectInfoId, " Constructor 5 ", objectType);
  663.             this.objectType = objectType;
  664.             this.objectManager = objectManager;
  665.             this.wireMemberNames = memberNames;
  666.             this.wireMemberTypes = memberTypes;
  667.             this.context = context;
  668.             this.serObjectInfoInit = serObjectInfoInit;
  669.             this.formatterConverter = converter;
  670.             if (memberNames != null)
  671.                 isNamed = true;
  672.             if (memberTypes != null)
  673.                 isTyped = true;
  674.            
  675.             InitReadConstructor(objectType, surrogateSelector, context, assemblyName);
  676.         }
  677.        
  678.         private void InitReadConstructor(Type objectType, ISurrogateSelector surrogateSelector, StreamingContext context, string assemblyName)
  679.         {
  680.             InternalST.Soap(this, objectInfoId, " ", objectType, " InitReadConstructor Entry ", objectType);
  681.            
  682.             if (objectType.IsArray) {
  683.                 arrayElemObjectInfo = Create(objectType.GetElementType(), surrogateSelector, context, objectManager, serObjectInfoInit, formatterConverter, assemblyName);
  684.                 typeAttributeInfo = GetTypeAttributeInfo();
  685.                 InitNoMembers();
  686.                 return;
  687.             }
  688.            
  689.             ISurrogateSelector surrogateSelectorTemp = null;
  690.            
  691.             if (surrogateSelector != null)
  692.                 serializationSurrogate = surrogateSelector.GetSurrogate(objectType, context, out surrogateSelectorTemp);
  693.            
  694.             if (serializationSurrogate != null) {
  695.                 isSi = true;
  696.             }
  697.             else if (objectType == Converter.typeofObject) {
  698.             }
  699.             else if (Converter.typeofISerializable.IsAssignableFrom(objectType))
  700.                 isSi = true;
  701.            
  702.             if (isSi) {
  703.                 si = new SerializationInfo(objectType, formatterConverter);
  704.                 InitSiRead(assemblyName);
  705.             }
  706.             else {
  707.                 InitMemberInfo();
  708.             }
  709.             InternalST.Soap(this, objectInfoId, " ", objectType, " InitReadConstructor Exit ", isSi);
  710.         }
  711.        
  712.         private void InitSiRead(string assemblyName)
  713.         {
  714.             InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo new cache");
  715.             if (assemblyName != null) {
  716.                 // Need to set to assembly name from the wire. This assembly name could contain version information
  717.                 // not in the default assembly name which was returned from fusion
  718.                 si.AssemblyName = assemblyName;
  719.             }
  720.             cache = new SerObjectInfoCache();
  721.             cache.fullTypeName = si.FullTypeName;
  722.             cache.assemblyString = si.AssemblyName;
  723.            
  724.             // Input from IFieldInfo
  725.             cache.memberNames = wireMemberNames;
  726.             cache.memberTypes = wireMemberTypes;
  727.            
  728.             if (memberTypesList != null) {
  729.                 memberTypesList = new ArrayList(20);
  730.             }
  731.            
  732.            
  733.             if (wireMemberNames != null && wireMemberTypes != null)
  734.                 isTyped = true;
  735.         }
  736.        
  737.         private void InitNoMembers()
  738.         {
  739.             cache = (SerObjectInfoCache)serObjectInfoInit.seenBeforeTable[objectType];
  740.             if (cache == null) {
  741.                 InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo new cache");
  742.                 cache = new SerObjectInfoCache();
  743.                 cache.fullTypeName = objectType.FullName;
  744.                 cache.assemblyString = objectType.Module.Assembly.FullName;
  745.                 serObjectInfoInit.seenBeforeTable.Add(objectType, cache);
  746.             }
  747.         }
  748.        
  749.         private void InitMemberInfo()
  750.         {
  751.             InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo Entry");
  752.            
  753.             cache = (SerObjectInfoCache)serObjectInfoInit.seenBeforeTable[objectType];
  754.             if (cache == null) {
  755.                 InternalST.Soap(this, objectInfoId, " ", objectType, " InitMemberInfo new cache");
  756.                 cache = new SerObjectInfoCache();
  757.                 cache.memberInfos = FormatterServices.GetSerializableMembers(objectType, context);
  758.                 count = cache.memberInfos.Length;
  759.                 cache.memberNames = new string[count];
  760.                 cache.memberTypes = new Type[count];
  761.                 cache.memberAttributeInfos = new SoapAttributeInfo[count];
  762.                
  763.                 // Calculate new arrays
  764.                 for (int i = 0; i < count; i++) {
  765.                     cache.memberNames[i] = cache.memberInfos[i].Name;
  766.                     cache.memberTypes[i] = GetMemberType(cache.memberInfos[i]);
  767.                     cache.memberAttributeInfos[i] = Attr.GetMemberAttributeInfo(cache.memberInfos[i], cache.memberNames[i], cache.memberTypes[i]);
  768.                     InternalST.Soap(this, objectInfoId, " InitMemberInfo name ", cache.memberNames[i], ", type ", cache.me