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

  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: ObjectReader
  18. // Purpose: DeSerializes XML in SOAP Format into an an object graph
  19. //
  20. // Date: June 10, 1999
  21. //
  22. //============================================================
  23. namespace System.Runtime.Serialization.Formatters.Soap
  24. {
  25.    
  26.     using System;
  27.     using System.IO;
  28.     using System.Reflection;
  29.     using System.Collections;
  30.     using System.Text;
  31.     using System.Runtime.Remoting;
  32.     using System.Runtime.Remoting.Metadata.W3cXsd2001;
  33.     using System.Runtime.Remoting.Messaging;
  34.     using System.Runtime.Serialization;
  35.     using System.Security;
  36.     using System.Security.Permissions;
  37.     using System.Diagnostics;
  38.     using System.Globalization;
  39.    
  40.     internal sealed class ObjectReader
  41.     {
  42.        
  43.         // System.Serializer information
  44.         internal ObjectIDGenerator m_idGenerator;
  45.         internal Stream m_stream;
  46.         internal ISurrogateSelector m_surrogates;
  47.         internal StreamingContext m_context;
  48.         internal ObjectManager m_objectManager;
  49.         internal InternalFE formatterEnums;
  50.         internal SerializationBinder m_binder;
  51.        
  52.         internal SoapHandler soapHandler;
  53.         //Set from SoapHandler
  54.         // Fake Top object and headers
  55.         internal long topId = 0;
  56.         internal SerStack topStack;
  57.         // Stack for placing ProcessRecords if the top record cannot be serialized on the first pass.
  58.         internal bool isTopObjectSecondPass = false;
  59.         internal bool isTopObjectResolved = true;
  60.         internal bool isHeaderHandlerCalled = false;
  61.         internal Exception deserializationSecurityException = null;
  62.         internal object handlerObject = null;
  63.         internal object topObject;
  64.         internal long soapFaultId;
  65.         internal Header[] headers;
  66.         internal Header[] newheaders;
  67.         internal bool IsFakeTopObject = false;
  68.         internal HeaderHandler handler;
  69.         internal SerObjectInfoInit serObjectInfoInit = null;
  70.         internal IFormatterConverter m_formatterConverter = null;
  71.        
  72.         // Stack of Object ParseRecords
  73.         internal SerStack stack = new SerStack("ObjectReader Object Stack");
  74.        
  75.         // ValueType Fixup Stack
  76.         internal SerStack valueFixupStack = new SerStack("ValueType Fixup Stack");
  77.        
  78.         // Generate Object Id's
  79.         internal Hashtable objectIdTable = new Hashtable(25);
  80.         // holds the keyId value from the XML input and associated internal Id
  81.         internal long objectIds = 0;
  82.        
  83.         internal int paramPosition = 0;
  84.         //Position of parameter if soap top fake record.
  85.         internal int majorVersion = 0;
  86.         internal int minorVersion = 0;
  87.        
  88.         internal string faultString = null;
  89.        
  90.         // GetType - eliminate redundant Type.GetType()
  91.         //internal Hashtable typeTable = new Hashtable(10);
  92.        
  93.         static internal SecurityPermission serializationPermission = new SecurityPermission(SecurityPermissionFlag.SerializationFormatter);
  94.         private static FileIOPermission sfileIOPermission = new FileIOPermission(PermissionState.Unrestricted);
  95.        
  96.        
  97.         internal ObjectReader(Stream stream, ISurrogateSelector selector, StreamingContext context, InternalFE formatterEnums, SerializationBinder binder)
  98.         {
  99.             InternalST.Soap(this, "Constructor ISurrogateSelector ", ((selector == null) ? "null selector " : "selector present"));
  100.            
  101.             if (stream == null) {
  102.                 throw new ArgumentNullException("stream", SoapUtil.GetResourceString("ArgumentNull_Stream"));
  103.             }
  104.            
  105.             m_stream = stream;
  106.             m_surrogates = selector;
  107.             m_context = context;
  108.             m_binder = binder;
  109.             this.formatterEnums = formatterEnums;
  110.            
  111.             InternalST.Soap(this, "Constructor formatterEnums.FEtopObject ", formatterEnums.FEtopObject);
  112.             if (formatterEnums.FEtopObject != null)
  113.                 IsFakeTopObject = true;
  114.             else
  115.                 IsFakeTopObject = false;
  116.            
  117.             m_formatterConverter = new FormatterConverter();
  118.         }
  119.        
  120.        
  121.         private ObjectManager GetObjectManager()
  122.         {
  123.             new SecurityPermission(SecurityPermissionFlag.SerializationFormatter).Assert();
  124.             return new ObjectManager(m_surrogates, m_context);
  125.         }
  126.        
  127.        
  128.        
  129.        
  130.         // Deserialize the stream into an object graph.
  131.         internal object Deserialize(HeaderHandler handler, ISerParser serParser)
  132.         {
  133.            
  134.             InternalST.Soap(this, "Deserialize Entry handler", handler);
  135.            
  136.             if (serParser == null)
  137.                 throw new ArgumentNullException("serParser", String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("ArgumentNull_WithParamName"), serParser));
  138.            
  139.            
  140.             deserializationSecurityException = null;
  141.             try {
  142.                 serializationPermission.Demand();
  143.             }
  144.             catch (Exception e) {
  145.                 deserializationSecurityException = e;
  146.             }
  147.             catch {
  148.                 deserializationSecurityException = new Exception(SoapUtil.GetResourceString("Serialization_NonClsCompliantException"));
  149.             }
  150.            
  151.             this.handler = handler;
  152.             isTopObjectSecondPass = false;
  153.             isHeaderHandlerCalled = false;
  154.            
  155.             if (handler != null)
  156.                 IsFakeTopObject = true;
  157.            
  158.             m_idGenerator = new ObjectIDGenerator();
  159.            
  160.            
  161.             m_objectManager = GetObjectManager();
  162.            
  163.             serObjectInfoInit = new SerObjectInfoInit();
  164.             objectIdTable.Clear();
  165.             objectIds = 0;
  166.            
  167.             // Will call back to ParseObject, ParseHeader for each object found
  168.             serParser.Run();
  169.            
  170.             if (handler != null) {
  171.                 InternalST.Soap(this, "Deserialize Fixup Before Delegate Invoke");
  172.                 m_objectManager.DoFixups();
  173.                 // Fixup for headers
  174.                 // Header handler isn't invoked until method name is known from body fake record
  175.                 // Except for SoapFault, in which case it is invoked below
  176.                 if (handlerObject == null) {
  177.                     InternalST.Soap(this, "Deserialize Before SoapFault Delegate Invoke ");
  178.                     handlerObject = handler(newheaders);
  179.                     InternalST.Soap(this, "Deserialize after SoapFault Delegate Invoke");
  180.                 }
  181.                
  182.                
  183.                 // SoapFault creation Create a fake Pr for the handlerObject to use.
  184.                 // Create a member for the fake pr with name __fault;
  185.                 if ((soapFaultId > 0) && (handlerObject != null)) {
  186.                     InternalST.Soap(this, "Deserialize SoapFault ");
  187.                     topStack = new SerStack("Top ParseRecords");
  188.                     ParseRecord pr = new ParseRecord();
  189.                     pr.PRparseTypeEnum = InternalParseTypeE.Object;
  190.                     pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
  191.                     pr.PRparseStateEnum = InternalParseStateE.Object;
  192.                     pr.PRname = "Response";
  193.                     topStack.Push(pr);
  194.                     pr = new ParseRecord();
  195.                     pr.PRparseTypeEnum = InternalParseTypeE.Member;
  196.                     pr.PRobjectPositionEnum = InternalObjectPositionE.Child;
  197.                     pr.PRmemberTypeEnum = InternalMemberTypeE.Field;
  198.                     pr.PRmemberValueEnum = InternalMemberValueE.Reference;
  199.                     pr.PRparseStateEnum = InternalParseStateE.Member;
  200.                     pr.PRname = "__fault";
  201.                     pr.PRidRef = soapFaultId;
  202.                     topStack.Push(pr);
  203.                     pr = new ParseRecord();
  204.                     pr.PRparseTypeEnum = InternalParseTypeE.ObjectEnd;
  205.                     pr.PRobjectPositionEnum = InternalObjectPositionE.Top;
  206.                     pr.PRparseStateEnum = InternalParseStateE.Object;
  207.                     pr.PRname = "Response";
  208.                     topStack.Push(pr);
  209.                     isTopObjectResolved = false;
  210.                 }
  211.             }
  212.            
  213.            
  214.             // Resolve fake top object if necessary
  215.             if (!isTopObjectResolved) {
  216.                 //resolve top object
  217.                 InternalST.Soap(this, "Deserialize TopObject Second Pass");
  218.                 isTopObjectSecondPass = true;
  219.                 topStack.Reverse();
  220.                 // The top of the stack now contains the fake record
  221.                 // When it is Parsed, the handler object will be substituted
  222.                 // for it in ParseObject.
  223.                 int topStackLength = topStack.Count();
  224.                 ParseRecord pr = null;
  225.                 for (int i = 0; i < topStackLength; i++) {
  226.                     pr = (ParseRecord)topStack.Pop();
  227.                     Parse(pr);
  228.                 }
  229.             }
  230.            
  231.            
  232.             InternalST.Soap(this, "Deserialize Finished Parsing DoFixups");
  233.            
  234.             m_objectManager.DoFixups();
  235.            
  236.             if (topObject == null)
  237.                 throw new SerializationException(SoapUtil.GetResourceString("Serialization_TopObject"));
  238.            
  239.             //if topObject has a surrogate then the actual object may be changed during special fixup
  240.             //So refresh it using topID.
  241.             if (HasSurrogate(topObject.GetType()) && topId != 0)
  242.                 //Not yet resolved
  243.                 topObject = m_objectManager.GetObject(topId);
  244.            
  245.             if (topObject is IObjectReference) {
  246.                 topObject = ((IObjectReference)topObject).GetRealObject(m_context);
  247.             }
  248.            
  249.             InternalST.Soap(this, "Deserialize Exit ", topObject);
  250.            
  251.             m_objectManager.RaiseDeserializationEvent();
  252.            
  253.            
  254.            
  255.             if ((formatterEnums.FEtopObject != null) && (topObject is InternalSoapMessage)) {
  256.                 // Convert InternalSoapMessage to SoapMessage
  257.                 InternalST.Soap(this, "Deserialize SoapMessage Entry ");
  258.                
  259.                 InternalSoapMessage ismc = (InternalSoapMessage)topObject;
  260.                 ISoapMessage smc = (ISoapMessage)formatterEnums.FEtopObject;
  261.                 smc.MethodName = ismc.methodName;
  262.                 smc.XmlNameSpace = ismc.xmlNameSpace;
  263.                 smc.ParamNames = ismc.paramNames;
  264.                 smc.ParamValues = ismc.paramValues;
  265.                 smc.Headers = headers;
  266.                 topObject = smc;
  267.                 isTopObjectResolved = true;
  268.                 InternalST.Soap(this, "Deserialize SoapMessage Exit topObject ", topObject, " method name ", smc.MethodName);
  269.             }
  270.            
  271.             return topObject;
  272.         }
  273.        
  274.         private bool HasSurrogate(Type t)
  275.         {
  276.             if (m_surrogates == null)
  277.                 return false;
  278.             ISurrogateSelector notUsed;
  279.             return m_surrogates.GetSurrogate(t, m_context, out notUsed) != null;
  280.         }
  281.        
  282.         private void CheckSerializable(Type t)
  283.         {
  284.             if (!t.IsSerializable && !HasSurrogate(t))
  285.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_NonSerType"), t.FullName, t.Module.Assembly.FullName));
  286.         }
  287.        
  288.         internal ReadObjectInfo CreateReadObjectInfo(Type objectType, string assemblyName)
  289.         {
  290.             ReadObjectInfo objectInfo = ReadObjectInfo.Create(objectType, m_surrogates, m_context, m_objectManager, serObjectInfoInit, m_formatterConverter, assemblyName);
  291.             objectInfo.SetVersion(majorVersion, minorVersion);
  292.             return objectInfo;
  293.         }
  294.        
  295.         internal ReadObjectInfo CreateReadObjectInfo(Type objectType, string[] memberNames, Type[] memberTypes, string assemblyName)
  296.         {
  297.             ReadObjectInfo objectInfo = ReadObjectInfo.Create(objectType, memberNames, memberTypes, m_surrogates, m_context, m_objectManager, serObjectInfoInit, m_formatterConverter, assemblyName);
  298.             objectInfo.SetVersion(majorVersion, minorVersion);
  299.             return objectInfo;
  300.         }
  301.        
  302.        
  303.         // Main Parse routine, called by the XML Parse Handlers in XMLParser and also called internally to
  304.         // parse the fake top object.
  305.         internal void Parse(ParseRecord pr)
  306.         {
  307.             InternalST.Soap(this, "Parse Entry");
  308.             stack.Dump();
  309.             pr.Dump();
  310.            
  311.             switch (pr.PRparseTypeEnum) {
  312.                 case InternalParseTypeE.SerializedStreamHeader:
  313.                     ParseSerializedStreamHeader(pr);
  314.                     break;
  315.                 case InternalParseTypeE.SerializedStreamHeaderEnd:
  316.                     ParseSerializedStreamHeaderEnd(pr);
  317.                     break;
  318.                 case InternalParseTypeE.Object:
  319.                     ParseObject(pr);
  320.                     break;
  321.                 case InternalParseTypeE.ObjectEnd:
  322.                     ParseObjectEnd(pr);
  323.                     break;
  324.                 case InternalParseTypeE.Member:
  325.                     ParseMember(pr);
  326.                     break;
  327.                 case InternalParseTypeE.MemberEnd:
  328.                     ParseMemberEnd(pr);
  329.                     break;
  330.                 case InternalParseTypeE.Body:
  331.                 case InternalParseTypeE.BodyEnd:
  332.                 case InternalParseTypeE.Envelope:
  333.                 case InternalParseTypeE.EnvelopeEnd:
  334.                     break;
  335.                 case InternalParseTypeE.Empty:
  336.                 default:
  337.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_XMLElement"), pr.PRname));
  338.                     break;
  339.                
  340.             }
  341.         }
  342.        
  343.         // Styled ParseError output
  344.         private void ParseError(ParseRecord processing, ParseRecord onStack)
  345.         {
  346.             InternalST.Soap(this, " ParseError ", processing, " ", onStack);
  347.             throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_ParseError"), onStack.PRname + " " + ((Enum)onStack.PRparseTypeEnum).ToString() + " " + processing.PRname + " " + ((Enum)processing.PRparseTypeEnum).ToString()));
  348.         }
  349.        
  350.         // Parse the SerializedStreamHeader element. This is the first element in the stream if present
  351.         private void ParseSerializedStreamHeader(ParseRecord pr)
  352.         {
  353.             InternalST.Soap(this, "SerializedHeader ", pr);
  354.             stack.Push(pr);
  355.         }
  356.        
  357.         // Parse the SerializedStreamHeader end element. This is the last element in the stream if present
  358.         private void ParseSerializedStreamHeaderEnd(ParseRecord pr)
  359.         {
  360.             InternalST.Soap(this, "SerializedHeaderEnd ", pr);
  361.             stack.Pop();
  362.         }
  363.        
  364.        
  365.        
  366.         private bool IsRemoting {
  367. //return (m_context.State & (StreamingContextStates.Persistence|StreamingContextStates.File|StreamingContextStates.Clone)) == 0;
  368.             get { return IsFakeTopObject; }
  369.         }
  370.        
  371.         private void CheckSecurity(ParseRecord pr)
  372.         {
  373.             InternalST.SoapAssert(pr != null, "[BinaryObjectReader.CheckSecurity]pr!=null");
  374.             Type t = pr.PRdtType;
  375.            
  376.             if (t != null) {
  377.                 if (IsRemoting) {
  378.                     if (typeof(MarshalByRefObject).IsAssignableFrom(t))
  379.                         throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_MBRAsMBV"), t.FullName));
  380.                     FormatterServices.CheckTypeSecurity(t, formatterEnums.FEsecurityLevel);
  381.                 }
  382.             }
  383.            
  384.             //If we passed the security check, they can do whatever they'd like,
  385.             //so we'll just short-circuit this.
  386.             if (deserializationSecurityException == null) {
  387.                 return;
  388.             }
  389.            
  390.             // BaseTypes and Array of basetypes allowed
  391.            
  392.             if (t != null) {
  393.                 if (t.IsPrimitive || t == Converter.typeofString)
  394.                     return;
  395.                
  396.                 if (typeof(Enum).IsAssignableFrom(t))
  397.                     return;
  398.                
  399.                 if (t.IsArray) {
  400.                     Type type = t.GetElementType();
  401.                     if (type.IsPrimitive || type == Converter.typeofString)
  402.                         return;
  403.                 }
  404.             }
  405.            
  406.             throw deserializationSecurityException;
  407.         }
  408.        
  409.         // New object encountered in stream
  410.         private void ParseObject(ParseRecord pr)
  411.         {
  412.             InternalST.Soap(this, "ParseObject Entry ");
  413.            
  414.             if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top)
  415.                 topId = pr.PRobjectId;
  416.            
  417.             if (pr.PRparseTypeEnum == InternalParseTypeE.Object) {
  418.                 InternalST.Soap(this, "ParseObject Push " + pr.PRname);
  419.                 stack.Push(pr);
  420.                 // Nested objects member names are already on stack
  421.             }
  422.            
  423.             if (pr.PRobjectTypeEnum == InternalObjectTypeE.Array) {
  424.                 ParseArray(pr);
  425.                 InternalST.Soap(this, "ParseObject Exit, ParseArray ");
  426.                 return;
  427.             }
  428.            
  429.             if ((pr.PRdtType == null) && !IsFakeTopObject)
  430.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TopObjectInstantiate"), pr.PRname));
  431.            
  432.            
  433.             if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top && IsFakeTopObject && pr.PRdtType != Converter.typeofSoapFault) {
  434.                
  435.                 // Soap fake top object
  436.                 if (handler != null) {
  437.                     // Handler object will supply real top object
  438.                     InternalST.Soap(this, "ParseObject FakeTopObject with handlerObject ");
  439.                    
  440.                     // Now know the method name, can call header handler
  441.                     //Create header for method name
  442.                     if (!isHeaderHandlerCalled) {
  443.                         newheaders = null;
  444.                         isHeaderHandlerCalled = true;
  445.                         if (headers == null) {
  446.                             newheaders = new Header[1];
  447.                         }
  448.                         else {
  449.                             newheaders = new Header[headers.Length + 1];
  450.                             Array.Copy(headers, 0, newheaders, 1, headers.Length);
  451.                         }
  452.                        
  453.                         Header methodNameHeader = new Header("__methodName", pr.PRname, false, pr.PRnameXmlKey);
  454.                         newheaders[0] = methodNameHeader;
  455.                         InternalST.Soap(this, "Deserialize Before Delegate Invoke ");
  456.                         handlerObject = handler(newheaders);
  457.                        
  458.                         InternalST.Soap(this, "Deserialize after Delegate Invoke");
  459.                         InternalST.Soap(this, "Deserialize delgate object ", ((handlerObject == null) ? "null" : handlerObject));
  460.                     }
  461.                    
  462.                     if (isHeaderHandlerCalled) {
  463.                         // Handler object has supplied the real object for the fake object
  464.                         // which is on top of the stack
  465.                         pr.PRnewObj = handlerObject;
  466.                         pr.PRdtType = handlerObject.GetType();
  467.                         CheckSecurity(pr);
  468.                         if (pr.PRnewObj is IFieldInfo) {
  469.                             IFieldInfo fi = (IFieldInfo)pr.PRnewObj;
  470.                             if ((fi.FieldTypes != null) && (fi.FieldTypes.Length > 0)) {
  471.                                 pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, fi.FieldNames, fi.FieldTypes, pr.PRassemblyName);
  472.                             }
  473.                         }
  474.                     }
  475.                     else {
  476.                         // Handler object has not yet been asked for the real object
  477.                         // Stack the parse record until the second pass
  478.                         isTopObjectResolved = false;
  479.                         topStack = new SerStack("Top ParseRecords");
  480.                         InternalST.Soap(this, "ParseObject Handler Push " + pr.PRname);
  481.                         topStack.Push(pr.Copy());
  482.                         return;
  483.                     }
  484.                 }
  485.                 else if (formatterEnums.FEtopObject != null) {
  486.                     // SoapMessage will be used as the real object
  487.                     InternalST.Soap(this, "ParseObject FakeTopObject with SoapMessage ");
  488.                     if (isTopObjectSecondPass) {
  489.                         // This creates a the SoapMessage object as the real object, at this point it is an unitialized object.
  490.                         pr.PRnewObj = new InternalSoapMessage();
  491.                         pr.PRdtType = typeof(InternalSoapMessage);
  492.                         CheckSecurity(pr);
  493.                         if (formatterEnums.FEtopObject != null) {
  494.                             ISoapMessage soapMessage = (ISoapMessage)formatterEnums.FEtopObject;
  495.                             pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, soapMessage.ParamNames, soapMessage.ParamTypes, pr.PRassemblyName);
  496.                         }
  497.                     }
  498.                     else {
  499.                         // Stack the parse record until the second pass
  500.                         isTopObjectResolved = false;
  501.                         topStack = new SerStack("Top ParseRecords");
  502.                         topStack.Push(pr.Copy());
  503.                         return;
  504.                     }
  505.                 }
  506.             }
  507.             else if (pr.PRdtType == Converter.typeofString) {
  508.                 // String as a top level object
  509.                 if (pr.PRvalue != null) {
  510.                     pr.PRnewObj = pr.PRvalue;
  511.                     if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  512.                         InternalST.Soap(this, "ParseObject String as top level, Top Object Resolved");
  513.                         isTopObjectResolved = true;
  514.                         topObject = pr.PRnewObj;
  515.                         //stack.Pop();
  516.                         return;
  517.                     }
  518.                     else {
  519.                         InternalST.Soap(this, "ParseObject String as an object");
  520.                         stack.Pop();
  521.                         RegisterObject(pr.PRnewObj, pr, (ParseRecord)stack.Peek());
  522.                         return;
  523.                     }
  524.                 }
  525.                 else {
  526.                     // xml Doesn't have the value until later
  527.                     return;
  528.                 }
  529.             }
  530.             else {
  531.                 if (pr.PRdtType == null) {
  532.                     ParseRecord objectPr = (ParseRecord)stack.Peek();
  533.                     if (objectPr.PRdtType == Converter.typeofSoapFault) {
  534.                         InternalST.Soap(this, "ParseObject unknown SoapFault detail");
  535.                         throw new ServerException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_SoapFault"), faultString));
  536.                     }
  537.                    
  538.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TypeElement"), pr.PRname));
  539.                 }
  540.                 CheckSerializable(pr.PRdtType);
  541.                 if (IsRemoting && formatterEnums.FEsecurityLevel != TypeFilterLevel.Full)
  542.                     pr.PRnewObj = FormatterServices.GetSafeUninitializedObject(pr.PRdtType);
  543.                 else
  544.                     pr.PRnewObj = FormatterServices.GetUninitializedObject(pr.PRdtType);
  545.                
  546.                 CheckSecurity(pr);
  547.                 // Run the OnDeserializing methods
  548.                 m_objectManager.RaiseOnDeserializingEvent(pr.PRnewObj);
  549.                
  550.             }
  551.            
  552.             if (pr.PRnewObj == null)
  553.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TopObjectInstantiate"), pr.PRdtType));
  554.            
  555.             long genId = pr.PRobjectId;
  556.             if (genId < 1)
  557.                 pr.PRobjectId = GetId("GenId-" + objectIds);
  558.            
  559.            
  560.             if (IsFakeTopObject && pr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  561.                 InternalST.Soap(this, "ParseObject fake Top object resolved ", pr.PRnewObj);
  562.                 isTopObjectResolved = true;
  563.                 topObject = pr.PRnewObj;
  564.             }
  565.            
  566.             if (pr.PRobjectInfo == null)
  567.                 pr.PRobjectInfo = CreateReadObjectInfo(pr.PRdtType, pr.PRassemblyName);
  568.             pr.PRobjectInfo.obj = pr.PRnewObj;
  569.            
  570.             if (IsFakeTopObject && pr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  571.                 InternalST.Soap(this, "ParseObject AddValue to fake object ", pr.PRobjectInfo.obj);
  572.                 // Add the methodName to top object, either InternalSoapMessage or object returned by handler
  573.                 pr.PRobjectInfo.AddValue("__methodName", pr.PRname);
  574.                 pr.PRobjectInfo.AddValue("__keyToNamespaceTable", soapHandler.keyToNamespaceTable);
  575.                 pr.PRobjectInfo.AddValue("__paramNameList", pr.PRobjectInfo.SetFakeObject());
  576.                 if (formatterEnums.FEtopObject != null)
  577.                     pr.PRobjectInfo.AddValue("__xmlNameSpace", pr.PRxmlNameSpace);
  578.             }
  579.            
  580.             InternalST.Soap(this, "ParseObject Exit ");
  581.         }
  582.        
  583.        
  584.         private bool IsWhiteSpace(string value)
  585.         {
  586.             for (int i = 0; i < value.Length; i++) {
  587.                 if (value[i] == ' ' || value[i] == '\n' || value[i] == '\r')
  588.                     continue;
  589.                 else
  590.                     return false;
  591.             }
  592.             return true;
  593.         }
  594.        
  595.         // End of object encountered in stream
  596.        
  597.         private void ParseObjectEnd(ParseRecord pr)
  598.         {
  599.             InternalST.Soap(this, "ParseObjectEnd Entry ", pr.Trace());
  600.             ParseRecord objectPr = (ParseRecord)stack.Peek();
  601.             if (objectPr == null)
  602.                 objectPr = pr;
  603.            
  604.            
  605.             //BCLDebug.Assert(objectPr != null, "[System.Runtime.Serialization.Formatters.ParseObjectEnd]objectPr != null");
  606.            
  607.             InternalST.Soap(this, "ParseObjectEnd objectPr ", objectPr.Trace());
  608.            
  609.             if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  610.                 InternalST.Soap(this, "ParseObjectEnd Top Object dtType ", objectPr.PRdtType);
  611.                 if (objectPr.PRdtType == Converter.typeofString) {
  612.                     InternalST.Soap(this, "ParseObjectEnd Top String");
  613.                     if (objectPr.PRvalue == null)
  614.                         objectPr.PRvalue = String.Empty;
  615.                     // Not a null object, but an empty string
  616.                     objectPr.PRnewObj = objectPr.PRvalue;
  617.                     CheckSecurity(objectPr);
  618.                     isTopObjectResolved = true;
  619.                     topObject = objectPr.PRnewObj;
  620.                     return;
  621.                 }
  622.                 else if (objectPr.PRdtType != null && objectPr.PRvalue != null && !IsWhiteSpace(objectPr.PRvalue) && (objectPr.PRdtType.IsPrimitive || objectPr.PRdtType == Converter.typeofTimeSpan)) {
  623.                     // When an xsd type is transmitted as a top level string <xsd:int>111</xsd:int>
  624.                     objectPr.PRnewObj = Converter.FromString(objectPr.PRvalue, Converter.ToCode(objectPr.PRdtType));
  625.                     CheckSecurity(objectPr);
  626.                     isTopObjectResolved = true;
  627.                     topObject = objectPr.PRnewObj;
  628.                     return;
  629.                    
  630.                 }
  631.                 else if ((!isTopObjectResolved) && (objectPr.PRdtType != Converter.typeofSoapFault)) {
  632.                     InternalST.Soap(this, "ParseObjectEnd Top but not String");
  633.                     // Need to keep top record on object stack until finished building top stack
  634.                     topStack.Push(pr.Copy());
  635.                     // Note this is PRparseRecordId and not objectId
  636.                     if (objectPr.PRparseRecordId == pr.PRparseRecordId) {
  637.                         // This handles the case of top stack containing nested objects and
  638.                         // referenced objects. If nested objects the objects are not placed
  639.                         // on stack, only topstack. If referenced objects they are placed on
  640.                         // stack and need to be popped.
  641.                         stack.Pop();
  642.                     }
  643.                     return;
  644.                 }
  645.             }
  646.            
  647.             stack.Pop();
  648.            
  649.             ParseRecord parentPr = (ParseRecord)stack.Peek();
  650.            
  651.             if (objectPr.PRobjectTypeEnum == InternalObjectTypeE.Array) {
  652.                 if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  653.                     InternalST.Soap(this, "ParseObjectEnd Top Object (Array) Resolved");
  654.                     isTopObjectResolved = true;
  655.                     topObject = objectPr.PRnewObj;
  656.                 }
  657.                
  658.                 InternalST.Soap(this, "ParseArray RegisterObject ", objectPr.PRobjectId, " ", objectPr.PRnewObj.GetType());
  659.                 RegisterObject(objectPr.PRnewObj, objectPr, parentPr);
  660.                
  661.                 return;
  662.             }
  663.            
  664.             if (objectPr.PRobjectInfo != null) {
  665.                 objectPr.PRobjectInfo.PopulateObjectMembers();
  666.             }
  667.            
  668.             if (objectPr.PRnewObj == null) {
  669.                 if (objectPr.PRdtType == Converter.typeofString) {
  670.                     InternalST.Soap(this, "ParseObjectEnd String ");
  671.                     if (objectPr.PRvalue == null)
  672.                         objectPr.PRvalue = String.Empty;
  673.                     // Not a null object, but an empty string
  674.                     objectPr.PRnewObj = objectPr.PRvalue;
  675.                     CheckSecurity(objectPr);
  676.                 }
  677.                 else
  678.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_ObjectMissing"), pr.PRname));
  679.             }
  680.            
  681.             // Registration is after object is populated
  682.             if (!objectPr.PRisRegistered && objectPr.PRobjectId > 0) {
  683.                 InternalST.Soap(this, "ParseObjectEnd Register Object ", objectPr.PRobjectId, " ", objectPr.PRnewObj.GetType());
  684.                 RegisterObject(objectPr.PRnewObj, objectPr, parentPr);
  685.             }
  686.            
  687.             if (objectPr.PRisValueTypeFixup) {
  688.                 InternalST.Soap(this, "ParseObjectEnd ValueTypeFixup ", objectPr.PRnewObj.GetType());
  689.                 ValueFixup fixup = (ValueFixup)valueFixupStack.Pop();
  690.                 //Value fixup
  691.                 fixup.Fixup(objectPr, parentPr);
  692.                 // Value fixup
  693.             }
  694.            
  695.             if (objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  696.                 InternalST.Soap(this, "ParseObjectEnd Top Object Resolved ", objectPr.PRnewObj.GetType());
  697.                 isTopObjectResolved = true;
  698.                 topObject = objectPr.PRnewObj;
  699.             }
  700.            
  701.             if (objectPr.PRnewObj is SoapFault)
  702.                 soapFaultId = objectPr.PRobjectId;
  703.            
  704.             if (objectPr.PRobjectInfo != null) {
  705.                 if (objectPr.PRobjectInfo.bfake && !objectPr.PRobjectInfo.bSoapFault)
  706.                     objectPr.PRobjectInfo.AddValue("__fault", null);
  707.                 // need this because SerializationObjectInfo throws an exception if a name being referenced is missing
  708.                 objectPr.PRobjectInfo.ObjectEnd();
  709.             }
  710.            
  711.             InternalST.Soap(this, "ParseObjectEnd Exit ", objectPr.PRnewObj, " id: ", objectPr.PRobjectId);
  712.         }
  713.        
  714.        
  715.        
  716.         // Array object encountered in stream
  717.         private void ParseArray(ParseRecord pr)
  718.         {
  719.             InternalST.Soap(this, "ParseArray Entry");
  720.             pr.Dump();
  721.            
  722.             long genId = pr.PRobjectId;
  723.             if (genId < 1)
  724.                 pr.PRobjectId = GetId("GenId-" + objectIds);
  725.            
  726.             if ((pr.PRarrayElementType != null) && (pr.PRarrayElementType.IsEnum))
  727.                 pr.PRisEnum = true;
  728.            
  729.             if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64) {
  730.                 if (pr.PRvalue == null) {
  731.                     pr.PRnewObj = new byte[0];
  732.                     CheckSecurity(pr);
  733.                 }
  734.                 else {
  735.                     // Used for arrays of Base64 and also for a parameter of Base64
  736.                     InternalST.Soap(this, "ParseArray bin.base64 ", pr.PRvalue.Length, " ", pr.PRvalue);
  737.                    
  738.                     if (pr.PRdtType == Converter.typeofSoapBase64Binary) {
  739.                         // Parameter - Case where the return type is a SoapENC:base64 but the parameter type is xsd:base64Binary
  740.                         pr.PRnewObj = SoapBase64Binary.Parse(pr.PRvalue);
  741.                         CheckSecurity(pr);
  742.                     }
  743.                     else {
  744.                         // ByteArray
  745.                         if (pr.PRvalue.Length > 0) {
  746.                             pr.PRnewObj = Convert.FromBase64String(FilterBin64(pr.PRvalue));
  747.                             CheckSecurity(pr);
  748.                         }
  749.                         else {
  750.                             pr.PRnewObj = new byte[0];
  751.                             CheckSecurity(pr);
  752.                         }
  753.                     }
  754.                 }
  755.                
  756.                 if (stack.Peek() == pr) {
  757.                     InternalST.Soap(this, "ParseArray, bin.base64 has been stacked");
  758.                     stack.Pop();
  759.                 }
  760.                 if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  761.                     InternalST.Soap(this, "ParseArray, bin.base64 Top Object");
  762.                     topObject = pr.PRnewObj;
  763.                     isTopObjectResolved = true;
  764.                 }
  765.                
  766.                 ParseRecord parentPr = (ParseRecord)stack.Peek();
  767.                
  768.                 // Base64 can be registered at this point because it is populated
  769.                 InternalST.Soap(this, "ParseArray RegisterObject ", pr.PRobjectId, " ", pr.PRnewObj.GetType());
  770.                 RegisterObject(pr.PRnewObj, pr, parentPr);
  771.                
  772.             }
  773.             else if ((pr.PRnewObj != null) && Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode)) {
  774.                 // Primtive typed Array has already been read
  775.                 if (pr.PRobjectPositionEnum == InternalObjectPositionE.Top) {
  776.                     topObject = pr.PRnewObj;
  777.                     isTopObjectResolved = true;
  778.                 }
  779.                
  780.                 ParseRecord parentPr = (ParseRecord)stack.Peek();
  781.                
  782.                 // Primitive typed array can be registered at this point because it is populated
  783.                 InternalST.Soap(this, "ParseArray RegisterObject ", pr.PRobjectId, " ", pr.PRnewObj.GetType());
  784.                 RegisterObject(pr.PRnewObj, pr, parentPr);
  785.             }
  786.             else if ((pr.PRarrayTypeEnum == InternalArrayTypeE.Jagged) || (pr.PRarrayTypeEnum == InternalArrayTypeE.Single)) {
  787.                 // Multidimensional jagged array or single array
  788.                 InternalST.Soap(this, "ParseArray Before Jagged,Simple create ", pr.PRarrayElementType, " ", (pr.PRrank > 0 ? pr.PRlengthA[0].ToString() : "0"));
  789.                 if ((pr.PRlowerBoundA == null) || (pr.PRlowerBoundA[0] == 0)) {
  790.                     pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, (pr.PRrank > 0 ? pr.PRlengthA[0] : 0));
  791.                     pr.PRisLowerBound = false;
  792.                 }
  793.                 else {
  794.                     pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
  795.                     pr.PRisLowerBound = true;
  796.                 }
  797.                
  798.                 if (pr.PRarrayTypeEnum == InternalArrayTypeE.Single) {
  799.                     if (!pr.PRisLowerBound && (Converter.IsWriteAsByteArray(pr.PRarrayElementTypeCode))) {
  800.                         pr.PRprimitiveArray = new PrimitiveArray(pr.PRarrayElementTypeCode, (Array)pr.PRnewObj);
  801.                     }
  802.                     else if (!pr.PRarrayElementType.IsValueType && pr.PRlowerBoundA == null) {
  803.                         pr.PRobjectA = (object[])pr.PRnewObj;
  804.                     }
  805.                 }
  806.                 CheckSecurity(pr);
  807.                
  808.                 InternalST.Soap(this, "ParseArray Jagged,Simple Array ", pr.PRnewObj.GetType());
  809.                
  810.                 // For binary, headers comes in as an array of header objects
  811.                 if (pr.PRobjectPositionEnum == InternalObjectPositionE.Headers) {
  812.                     InternalST.Soap(this, "ParseArray header array");
  813.                     headers = (Header[])pr.PRnewObj;
  814.                 }
  815.                
  816.                 pr.PRindexMap = new int[1];
  817.                
  818.                
  819.             }
  820.             else if (pr.PRarrayTypeEnum == InternalArrayTypeE.Rectangular) {
  821.                 // Rectangle array
  822.                
  823.                 pr.PRisLowerBound = false;
  824.                 if (pr.PRlowerBoundA != null) {
  825.                     for (int i = 0; i < pr.PRrank; i++) {
  826.                         if (pr.PRlowerBoundA[i] != 0)
  827.                             pr.PRisLowerBound = true;
  828.                     }
  829.                 }
  830.                
  831.                
  832.                 if (!pr.PRisLowerBound)
  833.                     pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA);
  834.                 else
  835.                     pr.PRnewObj = Array.CreateInstance(pr.PRarrayElementType, pr.PRlengthA, pr.PRlowerBoundA);
  836.                 CheckSecurity(pr);
  837.                
  838.                 InternalST.Soap(this, "ParseArray Rectangle Array ", pr.PRnewObj.GetType(), " lower Bound ", pr.PRisLowerBound);
  839.                
  840.                 // Calculate number of items
  841.                 int sum = 1;
  842.                 for (int i = 0; i < pr.PRrank; i++) {
  843.                     sum = sum * pr.PRlengthA[i];
  844.                 }
  845.                 pr.PRindexMap = new int[pr.PRrank];
  846.                 pr.PRrectangularMap = new int[pr.PRrank];
  847.                 pr.PRlinearlength = sum;
  848.             }
  849.             else
  850.                 throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_ArrayType"), ((Enum)pr.PRarrayTypeEnum).ToString()));
  851.            
  852.             InternalST.Soap(this, "ParseArray Exit");
  853.         }
  854.        
  855.        
  856.         // Builds a map for each item in an incoming rectangle array. The map specifies where the item is placed in the output Array Object
  857.        
  858.         private void NextRectangleMap(ParseRecord pr)
  859.         {
  860.             // For each invocation, calculate the next rectangular array position
  861.             // example
  862.             // indexMap 0 [0,0,0]
  863.             // indexMap 1 [0,0,1]
  864.             // indexMap 2 [0,0,2]
  865.             // indexMap 3 [0,0,3]
  866.             // indexMap 4 [0,1,0]
  867.             for (int irank = pr.PRrank - 1; irank > -1; irank--) {
  868.                 // Find the current or lower dimension which can be incremented.
  869.                 if (pr.PRrectangularMap[irank] < pr.PRlengthA[irank] - 1) {
  870.                     // The current dimension is at maximum. Increase the next lower dimension by 1
  871.                     pr.PRrectangularMap[irank]++;
  872.                     if (irank < pr.PRrank - 1) {
  873.                         // The current dimension and higher dimensions are zeroed.
  874.                         for (int i = irank + 1; i < pr.PRrank; i++)
  875.                             pr.PRrectangularMap[i] = 0;
  876.                     }
  877.                     Array.Copy(pr.PRrectangularMap, pr.PRindexMap, pr.PRrank);
  878.                     break;
  879.                 }
  880.                
  881.             }
  882.         }
  883.        
  884.        
  885.         // Array object item encountered in stream
  886.         private void ParseArrayMember(ParseRecord pr)
  887.         {
  888.             InternalST.Soap(this, "ParseArrayMember Entry");
  889.             ParseRecord objectPr = (ParseRecord)stack.Peek();
  890.            
  891.             // Set up for inserting value into correct array position
  892.             // cli metadata, offset can appear on the array type to represent lowerbound.
  893.             // Position can appear only on the member.
  894.             // If the position appears, it specifies the absolute position of the item in the array. The next array member
  895.             // continues after the position.
  896.            
  897.             if (objectPr.PRarrayTypeEnum == InternalArrayTypeE.Rectangular) {
  898.                 if (pr.PRpositionA != null) {
  899.                     Array.Copy(pr.PRpositionA, objectPr.PRindexMap, objectPr.PRindexMap.Length);
  900.                     if (objectPr.PRlowerBoundA == null)
  901.                         Array.Copy(pr.PRpositionA, objectPr.PRrectangularMap, objectPr.PRrectangularMap.Length);
  902.                     else {
  903.                         // have to subtract away the offset form the position, since the position includes the offset
  904.                         // but the PRrectangularMap is the index position without the offset
  905.                         for (int i = 0; i < objectPr.PRrectangularMap.Length; i++) {
  906.                             objectPr.PRrectangularMap[i] = pr.PRpositionA[i] - objectPr.PRlowerBoundA[i];
  907.                         }
  908.                     }
  909.                 }
  910.                 else {
  911.                     if (objectPr.PRmemberIndex > 0)
  912.                         NextRectangleMap(objectPr);
  913.                     // Rectangle array, calculate position in array
  914.                     for (int i = 0; i < objectPr.PRrank; i++) {
  915.                         int objectOffset = 0;
  916.                         if (objectPr.PRlowerBoundA != null)
  917.                             objectOffset = objectPr.PRlowerBoundA[i];
  918.                         objectPr.PRindexMap[i] = objectPr.PRrectangularMap[i] + objectOffset;
  919.                     }
  920.                 }
  921.             }
  922.             else {
  923.                 if (!objectPr.PRisLowerBound) {
  924.                     if (pr.PRpositionA == null)
  925.                         objectPr.PRindexMap[0] = objectPr.PRmemberIndex;
  926.                     else
  927.                         // Zero based array
  928.                         objectPr.PRindexMap[0] = objectPr.PRmemberIndex = pr.PRpositionA[0];
  929.                     // item position specified in SOAP stream
  930.                 }
  931.                 else {
  932.                     if (pr.PRpositionA == null)
  933.                         objectPr.PRindexMap[0] = objectPr.PRmemberIndex + objectPr.PRlowerBoundA[0];
  934.                     //item position specifed by SoapEnc.Offset
  935.                     else {
  936.                         objectPr.PRindexMap[0] = pr.PRpositionA[0];
  937.                         // item position specified in SOAP stream
  938.                         objectPr.PRmemberIndex = pr.PRpositionA[0] - objectPr.PRlowerBoundA[0];
  939.                         //memberIndex does not contain offset, but position does.
  940.                     }
  941.                 }
  942.             }
  943.             IndexTraceMessage("ParseArrayMember isLowerBound " + objectPr.PRisLowerBound + " indexMap ", objectPr.PRindexMap);
  944.            
  945.             // Set Array element according to type of element
  946.            
  947.             if (pr.PRmemberValueEnum == InternalMemberValueE.Reference) {
  948.                 // Object Reference
  949.                
  950.                 // See if object has already been instantiated
  951.                 object refObj = m_objectManager.GetObject(pr.PRidRef);
  952.                 if (refObj == null) {
  953.                     // Object not instantiated
  954.                     // Array fixup manager
  955.                     IndexTraceMessage("ParseArrayMember Record Fixup " + objectPr.PRnewObj.GetType(), objectPr.PRindexMap);
  956.                     int[] fixupIndex = new int[objectPr.PRrank];
  957.                     Array.Copy(objectPr.PRindexMap, 0, fixupIndex, 0, objectPr.PRrank);
  958.                    
  959.                     InternalST.Soap(this, "ParseArrayMember RecordArrayElementFixup objectId ", objectPr.PRobjectId, " idRef ", pr.PRidRef);
  960.                     m_objectManager.RecordArrayElementFixup(objectPr.PRobjectId, fixupIndex, pr.PRidRef);
  961.                 }
  962.                 else {
  963.                     IndexTraceMessage("ParseArrayMember SetValue ObjectReference " + objectPr.PRnewObj.GetType() + " " + refObj, objectPr.PRindexMap);
  964.                     if (objectPr.PRobjectA != null)
  965.                         objectPr.PRobjectA[objectPr.PRindexMap[0]] = refObj;
  966.                     else
  967.                         ((Array)objectPr.PRnewObj).SetValue(refObj, objectPr.PRindexMap);
  968.                     // Object has been instantiated
  969.                 }
  970.             }
  971.             else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested) {
  972.                 //Set up dtType for ParseObject
  973.                 InternalST.Soap(this, "ParseArrayMember Nested ");
  974.                 if (pr.PRdtType == null) {
  975.                     pr.PRdtType = objectPr.PRarrayElementType;
  976.                 }
  977.                
  978.                 ParseObject(pr);
  979.                
  980.                 InternalST.Soap("ParseArrayMember Push object " + pr.PRname);
  981.                 stack.Push(pr);
  982.                
  983.                 if ((objectPr.PRarrayElementType.IsValueType) && (pr.PRarrayElementTypeCode == InternalPrimitiveTypeE.Invalid)) {
  984.                     InternalST.Soap("ParseArrayMember ValueType ObjectPr ", objectPr.PRnewObj, " index ", objectPr.PRmemberIndex);
  985.                     pr.PRisValueTypeFixup = true;
  986.                     //Valuefixup
  987.                     valueFixupStack.Push(new ValueFixup((Array)objectPr.PRnewObj, objectPr.PRindexMap));
  988.                     //valuefixup
  989.                 }
  990.                 else {
  991.                     InternalST.Soap("ParseArrayMember SetValue Nested, memberIndex ", objectPr.PRmemberIndex);
  992.                     IndexTraceMessage("ParseArrayMember SetValue Nested ContainerObject " + objectPr.PRnewObj.GetType() + " " + objectPr.PRnewObj + " item Object " + pr.PRnewObj + " index ", objectPr.PRindexMap);
  993.                    
  994.                     stack.Dump();
  995.                     InternalST.Soap("ParseArrayMember SetValue Nested ContainerObject objectPr ", objectPr.Trace());
  996.                     InternalST.Soap("ParseArrayMember SetValue Nested ContainerObject pr ", pr.Trace());
  997.                    
  998.                     if (objectPr.PRobjectA != null)
  999.                         objectPr.PRobjectA[objectPr.PRindexMap[0]] = pr.PRnewObj;
  1000.                     else
  1001.                         ((Array)objectPr.PRnewObj).SetValue(pr.PRnewObj, objectPr.PRindexMap);
  1002.                 }
  1003.             }
  1004.             else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue) {
  1005.                 if (objectPr.PRarrayElementType == Converter.typeofString) {
  1006.                     // String
  1007.                     ParseString(pr, objectPr);
  1008.                     IndexTraceMessage("ParseArrayMember SetValue String " + objectPr.PRnewObj.GetType() + " " + pr.PRvalue, objectPr.PRindexMap);
  1009.                     if (objectPr.PRobjectA != null)
  1010.                         objectPr.PRobjectA[objectPr.PRindexMap[0]] = (object)pr.PRvalue;
  1011.                     else
  1012.                         ((Array)objectPr.PRnewObj).SetValue((object)pr.PRvalue, objectPr.PRindexMap);
  1013.                 }
  1014.                 else if (objectPr.PRisEnum) {
  1015.                     // Soap sends Enums as strings
  1016.                     object var = Enum.Parse(objectPr.PRarrayElementType, pr.PRvalue);
  1017.                     if (objectPr.PRobjectA != null)
  1018.                         objectPr.PRobjectA[objectPr.PRindexMap[0]] = (Enum)var;
  1019.                     else
  1020.                         ((Array)objectPr.PRnewObj).SetValue((Enum)var, objectPr.PRindexMap);
  1021.                     InternalST.Soap(this, "ParseArrayMember Enum 1");
  1022.                 }
  1023.                 else if (objectPr.PRisArrayVariant) {
  1024.                     // Array of type object
  1025.                     if (pr.PRdtType == null && pr.PRkeyDt == null)
  1026.                         throw new SerializationException(SoapUtil.GetResourceString("Serialization_ArrayTypeObject"));
  1027.                    
  1028.                     object var = null;
  1029.                    
  1030.                     if (pr.PRdtType == Converter.typeofString) {
  1031.                         ParseString(pr, objectPr);
  1032.                         var = pr.PRvalue;
  1033.                     }
  1034.                     else if (pr.PRdtType.IsEnum) {
  1035.                         // Soap sends Enums as strings
  1036.                         var = Enum.Parse(pr.PRdtType, pr.PRvalue);
  1037.                         InternalST.Soap(this, "ParseArrayMember Enum 2");
  1038.                     }
  1039.                     else if (pr.PRdtTypeCode == InternalPrimitiveTypeE.Invalid) {
  1040.                         CheckSerializable(pr.PRdtType);
  1041.                         // Not nested and invalid, so it is an empty object
  1042.                         if (IsRemoting && formatterEnums.FEsecurityLevel != TypeFilterLevel.Full)
  1043.                             var = FormatterServices.GetSafeUninitializedObject(pr.PRdtType);
  1044.                         else
  1045.                             var = FormatterServices.GetUninitializedObject(pr.PRdtType);
  1046.                     }
  1047.                     else {
  1048.                         if (pr.PRvarValue != null)
  1049.                             var = pr.PRvarValue;
  1050.                         else
  1051.                             var = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
  1052.                     }
  1053.                     IndexTraceMessage("ParseArrayMember SetValue variant or Object " + objectPr.PRnewObj.GetType() + " var " + var + " indexMap ", objectPr.PRindexMap);
  1054.                     if (objectPr.PRobjectA != null)
  1055.                         objectPr.PRobjectA[objectPr.PRindexMap[0]] = var;
  1056.                     else
  1057.                         ((Array)objectPr.PRnewObj).SetValue(var, objectPr.PRindexMap);
  1058.                     // Primitive type
  1059.                 }
  1060.                 else {
  1061.                     // Primitive type
  1062.                     if (objectPr.PRprimitiveArray != null) {
  1063.                         // Fast path for Soap primitive arrays. Binary was handled in the BinaryParser
  1064.                         objectPr.PRprimitiveArray.SetValue(pr.PRvalue, objectPr.PRindexMap[0]);
  1065.                     }
  1066.                     else {
  1067.                        
  1068.                         object var = null;
  1069.                         if (pr.PRvarValue != null)
  1070.                             var = pr.PRvarValue;
  1071.                         else
  1072.                             var = Converter.FromString(pr.PRvalue, objectPr.PRarrayElementTypeCode);
  1073.                        
  1074.                         if (objectPr.PRarrayElementTypeCode == InternalPrimitiveTypeE.QName) {
  1075.                             InternalST.Soap(this, "ParseArrayMember Primitive QName");
  1076.                             SoapQName soapQName = (SoapQName)var;
  1077.                             if (soapQName.Key.Length == 0)
  1078.                                 soapQName.Namespace = (string)soapHandler.keyToNamespaceTable["xmlns"];
  1079.                             else
  1080.                                 soapQName.Namespace = (string)soapHandler.keyToNamespaceTable["xmlns" + ":" + soapQName.Key];
  1081.                         }
  1082.                        
  1083.                         InternalST.Soap(this, "ParseArrayMember SetValue Primitive pr.PRvalue " + var, " elementTypeCode ", ((Enum)objectPr.PRdtTypeCode).ToString());
  1084.                         IndexTraceMessage("ParseArrayMember SetValue Primitive " + objectPr.PRnewObj.GetType() + " var: " + var + " varType " + var.GetType(), objectPr.PRindexMap);
  1085.                         if (objectPr.PRobjectA != null)
  1086.                             objectPr.PRobjectA[objectPr.PRindexMap[0]] = var;
  1087.                         else
  1088.                             ((Array)objectPr.PRnewObj).SetValue(var, objectPr.PRindexMap);
  1089.                         // Primitive type
  1090.                         InternalST.Soap(this, "ParseArrayMember SetValue Primitive after");
  1091.                     }
  1092.                 }
  1093.             }
  1094.             else if (pr.PRmemberValueEnum == InternalMemberValueE.Null) {
  1095.                 InternalST.Soap("ParseArrayMember Null item ", pr.PRmemberIndex);
  1096.             }
  1097.             else
  1098.                 ParseError(pr, objectPr);
  1099.            
  1100.             InternalST.Soap("ParseArrayMember increment memberIndex ", objectPr.PRmemberIndex, " ", objectPr.Trace());
  1101.             objectPr.PRmemberIndex++;
  1102.             InternalST.Soap("ParseArrayMember Exit");
  1103.         }
  1104.        
  1105.         private void ParseArrayMemberEnd(ParseRecord pr)
  1106.         {
  1107.             InternalST.Soap(this, "ParseArrayMemberEnd");
  1108.             // If this is a nested array object, then pop the stack
  1109.             if (pr.PRmemberValueEnum == InternalMemberValueE.Nested) {
  1110.                 ParseObjectEnd(pr);
  1111.             }
  1112.         }
  1113.        
  1114.        
  1115.         // Object member encountered in stream
  1116.         private void ParseMember(ParseRecord pr)
  1117.         {
  1118.             InternalST.Soap(this, "ParseMember Entry ");
  1119.            
  1120.            
  1121.             ParseRecord objectPr = (ParseRecord)stack.Peek();
  1122.             string objName = null;
  1123.             if (objectPr != null)
  1124.                 objName = objectPr.PRname;
  1125.            
  1126.             InternalST.Soap(this, "ParseMember ", objectPr.PRobjectId, " ", pr.PRname);
  1127.             InternalST.Soap(this, "ParseMember objectPr ", objectPr.Trace());
  1128.             InternalST.Soap(this, "ParseMember pr ", pr.Trace());
  1129.            
  1130.             if (objectPr.PRdtType == Converter.typeofSoapFault && pr.PRname.ToLower(CultureInfo.InvariantCulture) == "faultstring")
  1131.                 faultString = pr.PRvalue;
  1132.             // Save fault string in case rest of SoapFault cannot be parsed
  1133.            
  1134.             if ((objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top) && !isTopObjectResolved) {
  1135.                 InternalST.Soap(this, "ParseMember Top not resolved");
  1136.                 if (pr.PRdtType == Converter.typeofString) {
  1137.                     ParseString(pr, objectPr);
  1138.                 }
  1139.                 topStack.Push(pr.Copy());
  1140.                 return;
  1141.             }
  1142.            
  1143.             switch (pr.PRmemberTypeEnum) {
  1144.                 case InternalMemberTypeE.Item:
  1145.                     ParseArrayMember(pr);
  1146.                     return;
  1147.                 case InternalMemberTypeE.Field:
  1148.                     break;
  1149.             }
  1150.            
  1151.            
  1152.             if (objectPr.PRobjectInfo != null)
  1153.                 objectPr.PRobjectInfo.AddMemberSeen();
  1154.            
  1155.             bool bParams = (IsFakeTopObject && objectPr.PRobjectPositionEnum == InternalObjectPositionE.Top && objectPr.PRobjectInfo != null && objectPr.PRdtType != Converter.typeofSoapFault);
  1156.            
  1157.             if ((pr.PRdtType == null) && objectPr.PRobjectInfo.isTyped) {
  1158.                 InternalST.Soap(this, "ParseMember pr.PRdtType null and not isSi");
  1159.                
  1160.                 if (bParams) {
  1161.                     // Get type of parameters
  1162.                     InternalST.Soap(this, "ParseMember pr.PRdtType Get Param Type position " + paramPosition + " name " + pr.PRname);
  1163.                     pr.PRdtType = objectPr.PRobjectInfo.GetType(paramPosition++);
  1164.                     InternalST.Soap(this, "ParseMember pr.PRdtType Get Param Type Type " + pr.PRdtType);
  1165.                 }
  1166.                 else
  1167.                     pr.PRdtType = objectPr.PRobjectInfo.GetType(pr.PRname);
  1168.                
  1169.                 if (pr.PRdtType == null)
  1170.                     throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TypeResolved"), objectPr.PRnewObj + " " + pr.PRname));
  1171.                
  1172.                 pr.PRdtTypeCode = Converter.ToCode(pr.PRdtType);
  1173.             }
  1174.             else {
  1175.                 if (bParams) {
  1176.                     paramPosition++;
  1177.                 }
  1178.             }
  1179.            
  1180.            
  1181.             if (pr.PRmemberValueEnum == InternalMemberValueE.Null) {
  1182.                 // Value is Null
  1183.                 InternalST.Soap(this, "ParseMember null member: ", pr.PRname);
  1184.                 InternalST.Soap(this, "AddValue 1");
  1185.                 objectPr.PRobjectInfo.AddValue(pr.PRname, null);
  1186.             }
  1187.             else if (pr.PRmemberValueEnum == InternalMemberValueE.Nested) {
  1188.                 InternalST.Soap(this, "ParseMember Nested Type member: ", pr.PRname, " objectPr.PRnewObj ", objectPr.PRnewObj);
  1189.                 ParseObject(pr);
  1190.                 InternalST.Soap("ParseMember Push object " + pr.PRname);
  1191.                 stack.Push(pr);
  1192.                 InternalST.Soap(this, "AddValue 2 ", pr.PRnewObj, " is value type ", pr.PRnewObj.GetType().IsValueType);
  1193.                
  1194.                 if ((pr.PRobjectInfo != null) && (pr.PRobjectInfo.objectType.IsValueType)) {
  1195.                     InternalST.Soap("ParseMember ValueType ObjectPr ", objectPr.PRnewObj, " memberName ", pr.PRname, " nested object ", pr.PRnewObj);
  1196.                     if (IsFakeTopObject)
  1197.                         objectPr.PRobjectInfo.AddParamName(pr.PRname);
  1198.                    
  1199.                     pr.PRisValueTypeFixup = true;
  1200.                     //Valuefixup
  1201.                     valueFixupStack.Push(new ValueFixup(objectPr.PRnewObj, pr.PRname, objectPr.PRobjectInfo));
  1202.                     //valuefixup
  1203.                 }
  1204.                 else {
  1205.                     InternalST.Soap(this, "AddValue 2A ");
  1206.                     objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRnewObj);
  1207.                 }
  1208.             }
  1209.             else if (pr.PRmemberValueEnum == InternalMemberValueE.Reference) {
  1210.                 InternalST.Soap(this, "ParseMember Reference Type member: ", pr.PRname);
  1211.                 // See if object has already been instantiated
  1212.                 object refObj = m_objectManager.GetObject(pr.PRidRef);
  1213.                 if (refObj == null) {
  1214.                     InternalST.Soap(this, "ParseMember RecordFixup: ", pr.PRname);
  1215.                     InternalST.Soap(this, "AddValue 3");
  1216.                     objectPr.PRobjectInfo.AddValue(pr.PRname, null);
  1217.                     objectPr.PRobjectInfo.RecordFixup(objectPr.PRobjectId, pr.PRname, pr.PRidRef);
  1218.                     // Object not instantiated
  1219.                 }
  1220.                 else {
  1221.                     InternalST.Soap(this, "ParseMember Referenced Object Known ", pr.PRname, " ", refObj);
  1222.                     InternalST.Soap(this, "AddValue 5");
  1223.                     objectPr.PRobjectInfo.AddValue(pr.PRname, refObj);
  1224.                 }
  1225.             }
  1226.            
  1227.             else if (pr.PRmemberValueEnum == InternalMemberValueE.InlineValue) {
  1228.                 // Primitive type or String
  1229.                 InternalST.Soap(this, "ParseMember primitive or String member: ", pr.PRname);
  1230.                
  1231.                 if (pr.PRdtType == Converter.typeofString) {
  1232.                     ParseString(pr, objectPr);
  1233.                     InternalST.Soap(this, "AddValue 6");
  1234.                     objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);
  1235.                 }
  1236.                 else if (pr.PRdtTypeCode == InternalPrimitiveTypeE.Invalid) {
  1237.                     // The member field was an object put the value is Inline either bin.Base64 or invalid
  1238.                     if (pr.PRarrayTypeEnum == InternalArrayTypeE.Base64) {
  1239.                         InternalST.Soap(this, "AddValue 7");
  1240.                         objectPr.PRobjectInfo.AddValue(pr.PRname, Convert.FromBase64String(FilterBin64(pr.PRvalue)));
  1241.                     }
  1242.                     else if (pr.PRdtType == Converter.typeofObject && pr.PRvalue != null) {
  1243.                         if (objectPr != null && objectPr.PRdtType == Converter.typeofHeader) {
  1244.                             // assume the type is a string for a header
  1245.                             pr.PRdtType = Converter.typeofString;
  1246.                             ParseString(pr, objectPr);
  1247.                             InternalST.Soap(this, "AddValue 6");
  1248.                             objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);
  1249.                         }
  1250.                         //else
  1251.                         // throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_TypeMissing"), pr.PRname));
  1252.                     }
  1253.                     else {
  1254.                         InternalST.Soap(this, "Object Class with no memberInfo data Member " + pr.PRname + " type " + pr.PRdtType);
  1255.                        
  1256.                         if (pr.PRdtType != null && pr.PRdtType.IsEnum) {
  1257.                             // Soap sends Enums as strings
  1258.                             object obj = Enum.Parse(pr.PRdtType, pr.PRvalue);
  1259.                             InternalST.Soap(this, "AddValue 8");
  1260.                             objectPr.PRobjectInfo.AddValue(pr.PRname, obj);
  1261.                         }
  1262.                         else if (pr.PRdtType != null && pr.PRdtType == Converter.typeofTypeArray) {
  1263.                             // Soap sends MethodSignature as an array of types
  1264.                             InternalST.Soap(this, "AddValue 8A");
  1265.                             objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvarValue);
  1266.                         }
  1267.                         else {
  1268.                             if ((!pr.PRisRegistered) && (pr.PRobjectId > 0)) {
  1269.                                 if (pr.PRvalue == null)
  1270.                                     pr.PRvalue = "";
  1271.                                 //can't register null value, this must be a string so set to empty string.
  1272.                                 InternalST.Soap(this, "ParseMember RegisterObject ", pr.PRvalue, " ", pr.PRobjectId);
  1273.                                 RegisterObject(pr.PRvalue, pr, objectPr);
  1274.                             }
  1275.                            
  1276.                             // Object Class with no memberInfo data
  1277.                             if (pr.PRdtType == Converter.typeofSystemVoid) {
  1278.                                 InternalST.Soap(this, "AddValue 9");
  1279.                                 objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRdtType);
  1280.                             }
  1281.                             else if (objectPr.PRobjectInfo.isSi) {
  1282.                                 // ISerializable are added as strings, the conversion to type is done by the
  1283.                                 // ISerializable object
  1284.                                 InternalST.Soap(this, "AddValue 10");
  1285.                                 objectPr.PRobjectInfo.AddValue(pr.PRname, pr.PRvalue);
  1286.                             }
  1287.                         }
  1288.                     }
  1289.                 }
  1290.                 else {
  1291.                     object var = null;
  1292.                     if (pr.PRvarValue != null)
  1293.                         var = pr.PRvarValue;
  1294.                     else
  1295.                         var = Converter.FromString(pr.PRvalue, pr.PRdtTypeCode);
  1296.                     // Not a string, convert the value
  1297.                     InternalST.Soap(this, "ParseMember Converting primitive and storing");
  1298.                     stack.Dump();
  1299.                     InternalST.Soap(this, "ParseMember pr " + pr.Trace());
  1300.                     InternalST.Soap(this, "ParseMember objectPr ", objectPr.Trace());
  1301.                    
  1302.                     InternalST.Soap(this, "AddValue 11");
  1303.                     if (pr.PRdtTypeCode == InternalPrimitiveTypeE.QName && var != null) {
  1304.                         SoapQName soapQName = (SoapQName)var;
  1305.                         if (soapQName.Key != null) {
  1306.                             if (soapQName.Key.Length == 0)
  1307.                                 soapQName.Namespace = (string)soapHandler.keyToNamespaceTable["xmlns"];
  1308.                             else
  1309.                                 soapQName.Namespace = (string)soapHandler.keyToNamespaceTable["xmlns" + ":" + soapQName.Key];
  1310.                         }
  1311.                     }
  1312.                     objectPr.PRobjectInfo.AddValue(pr.PRname, var);
  1313.                 }
  1314.             }
  1315.             else
  1316.                 ParseError(pr, objectPr);
  1317.         }
  1318.        
  1319.         // Object member end encountered in stream
  1320.         private void ParseMemberEnd(ParseRecord pr)
  1321.         {
  1322.             InternalST.Soap(this, "ParseMemberEnd");
  1323.             switch (pr.PRmemberTypeEnum) {
  1324.                 case InternalMemberTypeE.Item:
  1325.                     ParseArrayMemberEnd(pr);
  1326.                     return;
  1327.                 case InternalMemberTypeE.Field:
  1328.                     if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
  1329.                         ParseObjectEnd(pr);
  1330.                     break;
  1331.                 default:
  1332.                     if (pr.PRmemberValueEnum == InternalMemberValueE.Nested)
  1333.                         ParseObjectEnd(pr);
  1334.                     else
  1335.                         ParseError(pr, (ParseRecord)stack.Peek());
  1336.                     break;
  1337.             }
  1338.         }
  1339.        
  1340.         // Processes a string object by getting an internal ID for it and registering it with the objectManager
  1341.         private void ParseString(ParseRecord pr, ParseRecord parentPr)
  1342.         {
  1343.             InternalST.Soap(this, "ParseString Entry ", pr.PRobjectId, " ", pr.PRvalue, " ", pr.PRisRegistered);
  1344.            
  1345.             // If there is a string and it wasn't marked as a null object, then it is an empty string
  1346.             if (pr.PRvalue == null)
  1347.                 pr.PRvalue = "";
  1348.            
  1349.             // Process String class
  1350.             if ((!pr.PRisRegistered) && (pr.PRobjectId > 0)) {
  1351.                 InternalST.Soap(this, "ParseString RegisterObject ", pr.PRvalue, " ", pr.PRobjectId);
  1352.                 // String is treated as an object if it has an id
  1353.                 //m_objectManager.RegisterObject(pr.PRvalue, pr.PRobjectId);
  1354.                 RegisterObject(pr.PRvalue, pr, parentPr);
  1355.             }
  1356.         }
  1357.        
  1358.        
  1359.         private void RegisterObject(object obj, ParseRecord pr, ParseRecord objectPr)
  1360.         {
  1361.             if (!pr.PRisRegistered) {
  1362.                 pr.PRisRegistered = true;
  1363.                
  1364.                 SerializationInfo si = null;
  1365.                 long parentId = 0;
  1366.                 MemberInfo memberInfo = null;
  1367.                 int[] indexMap = null;
  1368.                
  1369.                 if (objectPr != null) {
  1370.                     indexMap = objectPr.PRindexMap;
  1371.                     parentId = objectPr.PRobjectId;
  1372.                    
  1373.                     if (objectPr.PRobjectInfo != null) {
  1374.                         if (!objectPr.PRobjectInfo.isSi) {
  1375.                             // ParentId is only used if there is a memberInfo
  1376.                             InternalST.Soap(this, "RegisterObject GetMemberInfo parent ", objectPr.PRobjectInfo.objectType, " name looking for ", pr.PRname, " field obj " + obj);
  1377.                             memberInfo = objectPr.PRobjectInfo.GetMemberInfo(pr.PRname);
  1378.                         }
  1379.                     }
  1380.                 }
  1381.                 if (pr.PRobjectInfo != null) {
  1382.                     // SerializationInfo is always needed for ISerialization
  1383.                     si = pr.PRobjectInfo.si;
  1384.                 }
  1385.                
  1386.                 InternalST.Soap(this, "RegisterObject 0bj ", obj, " objectId ", pr.PRobjectId, " si ", si, " parentId ", parentId, " memberInfo ",
  1387.                 memberInfo, " indexMap " + indexMap);
  1388.                 m_objectManager.RegisterObject(obj, pr.PRobjectId, si, parentId, memberInfo, indexMap);
  1389.             }
  1390.         }
  1391.        
  1392.        
  1393.         internal void SetVersion(int major, int minor)
  1394.         {
  1395.             // Don't do version checking if property is set to Simple
  1396.             if (formatterEnums.FEassemblyFormat != FormatterAssemblyStyle.Simple) {
  1397.                 this.majorVersion = major;
  1398.                 this.minorVersion = minor;
  1399.             }
  1400.         }
  1401.        
  1402.        
  1403.         // Assigns an internal ID associated with the xml id attribute
  1404.        
  1405.         string inKeyId = null;
  1406.         long outKeyId = 0;
  1407.         internal long GetId(string keyId)
  1408.         {
  1409.             if (keyId == null)
  1410.                 throw new ArgumentNullException("keyId", String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("ArgumentNull_WithParamName"), "keyId"));
  1411.            
  1412.             if (keyId != inKeyId) {
  1413.                 inKeyId = keyId;
  1414.                 string idString = null;
  1415.                 InternalST.Soap(this, "GetId Entry ", keyId);
  1416.                 if (keyId[0] == '#')
  1417.                     idString = keyId.Substring(1);
  1418.                 else
  1419.                     idString = keyId;
  1420.                
  1421.                 object idObj = objectIdTable[idString];
  1422.                 if (idObj == null) {
  1423.                     outKeyId = ++objectIds;
  1424.                     objectIdTable[idString] = outKeyId;
  1425.                     InternalST.Soap(this, "GetId Exit new ID ", outKeyId);
  1426.                 }
  1427.                 else {
  1428.                     InternalST.Soap(this, "GetId Exit oldId ", (Int64)idObj);
  1429.                     outKeyId = (Int64)idObj;
  1430.                 }
  1431.             }
  1432.             InternalST.Soap(this, "GetId in id ", keyId, " out id ", outKeyId);
  1433.             return outKeyId;
  1434.         }
  1435.        
  1436.         // Trace which includes a single dimensional int array
  1437.         [Conditional("SER_LOGGING")]
  1438.         private void IndexTraceMessage(string message, int[] index)
  1439.         {
  1440.             StringBuilder sb = new StringBuilder(10);
  1441.             sb.Append("[");
  1442.             for (int i = 0; i < index.Length; i++) {
  1443.                 sb.Append(index[i]);
  1444.                 if (i != index.Length - 1)
  1445.                     sb.Append(",");
  1446.             }
  1447.             sb.Append("]");
  1448.             InternalST.Soap(this, message, " ", sb.ToString());
  1449.         }
  1450.        
  1451.         internal Assembly LoadAssemblyFromString(string assemblyString)
  1452.         {
  1453.             Assembly assm = null;
  1454.             if (formatterEnums.FEassemblyFormat == FormatterAssemblyStyle.Simple) {
  1455.                 try {
  1456.                     sfileIOPermission.Assert();
  1457.                     try {
  1458.                         #pragma warning disable 618
  1459.                         assm = Assembly.LoadWithPartialName(assemblyString, null);
  1460.                         #pragma warning restore 618
  1461.                     }
  1462.                     finally {
  1463.                         CodeAccessPermission.RevertAssert();
  1464.                     }
  1465.                 }
  1466.                 catch (Exception e) {
  1467.                     InternalST.Soap(this, "Error loading ", assemblyString, e.ToString());
  1468.                 }
  1469.                 catch {
  1470.                     InternalST.Soap(this, "Error loading ", assemblyString, "Non-CLS Compliant Exception");
  1471.                 }
  1472.             }
  1473.             else {
  1474.                 try {
  1475.                     sfileIOPermission.Assert();
  1476.                     try {
  1477.                         assm = Assembly.Load(assemblyString);
  1478.                     }
  1479.                     finally {
  1480.                         CodeAccessPermission.RevertAssert();
  1481.                     }
  1482.                 }
  1483.                 catch (Exception e) {
  1484.                     InternalST.Soap(this, "Error loading ", assemblyString, e.ToString());
  1485.                 }
  1486.                 catch {
  1487.                     InternalST.Soap(this, "Error loading ", assemblyString, "Non-CLS Compliant Exception");
  1488.                 }
  1489.             }
  1490.            
  1491.             return assm;
  1492.         }
  1493.        
  1494.         internal Type Bind(string assemblyString, string typeString)
  1495.         {
  1496.             Type type = null;
  1497.             if (m_binder != null && !IsInternalType(assemblyString, typeString))
  1498.                 type = m_binder.BindToType(assemblyString, typeString);
  1499.             return type;
  1500.         }
  1501.        
  1502.         private bool IsInternalType(string assemblyString, string typeString)
  1503.         {
  1504.             return (assemblyString == Converter.urtAssemblyString) && ((typeString == "System.DelegateSerializationHolder") || (typeString == "System.UnitySerializationHolder") || (typeString == "System.MemberInfoSerializationHolder"));
  1505.         }
  1506.        
  1507.         internal class TypeNAssembly
  1508.         {
  1509.             public Type type;
  1510.             public string assemblyName;
  1511.         }
  1512.        
  1513.         NameCache typeCache = new NameCache();
  1514.         internal Type FastBindToType(string assemblyName, string typeName)
  1515.         {
  1516.             Type type = null;
  1517.            
  1518.             TypeNAssembly entry = typeCache.GetCachedValue(typeName) as TypeNAssembly;
  1519.            
  1520.             if (entry == null || entry.assemblyName != assemblyName) {
  1521.                 Assembly assm = LoadAssemblyFromString(assemblyName);
  1522.                 if (assm == null)
  1523.                     return null;
  1524.                
  1525.                 type = FormatterServices.GetTypeFromAssembly(assm, typeName);
  1526.                
  1527.                 if (type == null)
  1528.                     return null;
  1529.                
  1530.                 entry = new TypeNAssembly();
  1531.                 entry.type = type;
  1532.                 entry.assemblyName = assemblyName;
  1533.                 typeCache.SetCachedValue(entry);
  1534.             }
  1535.             return entry.type;
  1536.         }
  1537.        
  1538.         StringBuilder sbf = new StringBuilder();
  1539.         internal string FilterBin64(string value)
  1540.         {
  1541.             sbf.Length = 0;
  1542.             for (int i = 0; i < value.Length; i++) {
  1543.                 if (!(value[i] == ' ' || value[i] == '\n' || value[i] == '\r'))
  1544.                     sbf.Append(value[i]);
  1545.             }
  1546.             return sbf.ToString();
  1547.         }
  1548.        
  1549.     }
  1550. }

Developer Fusion