mcs/class/System.Runtime.Serialization.Formatters.Soap/System.Runtime.Serialization.Formatters.Soap/SoapReader.cs

   1 // created on 24/04/2003 at 15:35\r
   2 //\r
   3 //      System.Runtime.Serialization.Formatters.Soap.SoapReader\r
   4 //\r
   5 //      Authors:\r
   6 //              Jean-Marc Andre (jean-marc.andre@polymtl.ca)\r
   7 //\r
   8
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29 \r
  30 using System;\r
  31 using System.IO;\r
  32 using System.Xml;\r
  33 using System.Xml.Schema;\r
  34 using System.Reflection;\r
  35 using System.Collections;\r
  36 using System.Runtime.Remoting;\r
  37 using System.Runtime.Serialization;\r
  38 using System.Runtime.Remoting.Messaging;\r
  39 \r
  40 namespace System.Runtime.Serialization.Formatters.Soap {\r
  41         internal sealed class SoapReader {\r
  42 \r
  43                 #region Fields\r
  44 \r
  45                 private SerializationBinder _binder;\r
  46                 private SoapTypeMapper mapper;\r
  47                 private ObjectManager objMgr;\r
  48                 private StreamingContext _context;\r
  49                 private long _nextAvailableId = long.MaxValue;\r
  50                 private ISurrogateSelector _surrogateSelector;\r
  51                 private XmlTextReader xmlReader;\r
  52                 private Hashtable _fieldIndices;\r
  53                 private long _topObjectId = 1;\r
  54                 \r
  55                 class TypeMetadata\r
  56                 {\r
  57                         public MemberInfo[] MemberInfos;\r
  58                         public Hashtable Indices;\r
  59                 }\r
  60 \r
  61                 #endregion\r
  62 \r
  63                 #region Properties\r
  64 \r
  65                 private long NextAvailableId\r
  66                 {\r
  67                         get \r
  68                         {\r
  69                                 _nextAvailableId--;\r
  70                                 return _nextAvailableId;\r
  71                         }\r
  72                 }\r
  73 \r
  74                 #endregion\r
  75 \r
  76                 #region Constructors\r
  77                 \r
  78                 public SoapReader(SerializationBinder binder, ISurrogateSelector selector, StreamingContext context) \r
  79                 {\r
  80                         _binder = binder;\r
  81                         objMgr = new ObjectManager(selector, context);\r
  82                         _context = context;\r
  83                         _surrogateSelector = selector;\r
  84                         _fieldIndices = new Hashtable();\r
  85                 }\r
  86 \r
  87                 #endregion\r
  88 \r
  89                 #region Public Methods\r
  90 \r
  91                 public object Deserialize(Stream inStream, ISoapMessage soapMessage) \r
  92                 {
  93                         ArrayList headers = null;\r
  94                         xmlReader = new XmlTextReader(inStream);\r
  95                         xmlReader.WhitespaceHandling = WhitespaceHandling.None;\r
  96                         mapper = new SoapTypeMapper(_binder);\r
  97 \r
  98                         try\r
  99                         {\r
 100                                 // SOAP-ENV:Envelope\r
 101                                 xmlReader.MoveToContent();\r
 102                                 xmlReader.ReadStartElement ();
 103                                 xmlReader.MoveToContent();
 104
 105                                 // Read headers
 106                                 while (!(xmlReader.NodeType == XmlNodeType.Element && xmlReader.LocalName == "Body" && xmlReader.NamespaceURI == SoapTypeMapper.SoapEnvelopeNamespace))
 107                                 {\r
 108                                         if (xmlReader.NodeType == XmlNodeType.Element && xmlReader.LocalName == "Header" && xmlReader.NamespaceURI == SoapTypeMapper.SoapEnvelopeNamespace)\r
 109                                         {\r
 110                                                 if (headers == null) headers = new ArrayList ();\r
 111                                                 DeserializeHeaders (headers);\r
 112                                         }\r
 113                                         else
 114                                                 xmlReader.Skip ();\r
 115                                         xmlReader.MoveToContent();\r
 116                                 }
 117                                 \r
 118                                 // SOAP-ENV:Body\r
 119                                 xmlReader.ReadStartElement();\r
 120                                 xmlReader.MoveToContent();\r
 121 \r
 122                                 // The root object\r
 123                                 if (soapMessage != null)\r
 124                                 {\r
 125                                         if (DeserializeMessage (soapMessage)) {\r
 126                                                 _topObjectId = NextAvailableId;\r
 127                                                 RegisterObject (_topObjectId, soapMessage, null, 0, null, null);\r
 128                                         }\r
 129                                         xmlReader.MoveToContent();\r
 130                                         \r
 131                                         if (headers != null)\r
 132                                                 soapMessage.Headers = (Header[]) headers.ToArray (typeof(Header));\r
 133                                 }\r
 134                                 \r
 135                                 while (xmlReader.NodeType != XmlNodeType.EndElement)\r
 136                                         Deserialize();\r
 137                                         \r
 138                                 // SOAP-ENV:Body\r
 139                                 xmlReader.ReadEndElement ();\r
 140                                 xmlReader.MoveToContent();\r
 141 \r
 142                                 // SOAP-ENV:Envelope\r
 143                                 xmlReader.ReadEndElement ();\r
 144                         }\r
 145                         finally \r
 146                         {\r
 147                                 if(xmlReader != null) xmlReader.Close();\r
 148                         }\r
 149 \r
 150                         return TopObject;\r
 151                 }\r
 152                 \r
 153                 #endregion\r
 154 \r
 155                 #region Private Methods\r
 156 \r
 157                 private object TopObject \r
 158                 {\r
 159                         get \r
 160                         {\r
 161                                 objMgr.DoFixups();\r
 162                                 objMgr.RaiseDeserializationEvent();\r
 163                                 return objMgr.GetObject(_topObjectId);\r
 164                         }\r
 165                 }\r
 166 \r
 167                 private bool IsNull()\r
 168                 {\r
 169                         string tmp = xmlReader["null", XmlSchema.InstanceNamespace];\r
 170                         return (tmp == null || tmp == string.Empty)?false:true;\r
 171                 }\r
 172 \r
 173                 private long GetId()\r
 174                 {\r
 175                         long id = 0;\r
 176 \r
 177                         string strId = xmlReader["id"];\r
 178                         if(strId == null || strId == String.Empty) return 0;\r
 179                         id = Convert.ToInt64(strId.Substring(4));\r
 180                         return id;\r
 181                 }\r
 182 \r
 183                 private long GetHref()\r
 184                 {\r
 185                         long href = 0;\r
 186                         \r
 187                         string strHref = xmlReader["href"];\r
 188                         if(strHref == null || strHref == string.Empty) return 0;\r
 189                         href = Convert.ToInt64(strHref.Substring(5));\r
 190                         return href;\r
 191                 }\r
 192 \r
 193                 private Type GetComponentType()\r
 194                 {\r
 195                         Type type = null;\r
 196                         if(GetId() != 0) return typeof(string);\r
 197                         \r
 198                         string strValue = xmlReader["type", XmlSchema.InstanceNamespace];\r
 199                         if(strValue == null) return null;\r
 200                         string[] strName = strValue.Split(':');\r
 201                         string namespaceURI = xmlReader.LookupNamespace(strName[0]);\r
 202                         type = mapper[new Element(string.Empty, strName[1], namespaceURI)];\r
 203 \r
 204                         return type;\r
 205                 }\r
 206 \r
 207                 private bool DeserializeMessage(ISoapMessage message) \r
 208                 {\r
 209                         string typeNamespace, assemblyName;\r
 210 \r
 211                         if(xmlReader.Name == SoapTypeMapper.SoapEnvelopePrefix + ":Fault")\r
 212                         {\r
 213                                 Deserialize();\r
 214                                 return false;\r
 215                         }\r
 216 \r
 217                         SoapServices.DecodeXmlNamespaceForClrTypeNamespace(\r
 218                                 xmlReader.NamespaceURI,\r
 219                                 out typeNamespace,\r
 220                                 out assemblyName);\r
 221                         message.MethodName = xmlReader.LocalName;\r
 222                         message.XmlNameSpace = xmlReader.NamespaceURI;\r
 223 \r
 224                         ArrayList paramNames = new ArrayList();\r
 225                         ArrayList paramValues = new ArrayList();\r
 226                         long paramValuesId = NextAvailableId;\r
 227                         int[] indices = new int[1];\r
 228 \r
 229                         int initialDepth = xmlReader.Depth;\r
 230                         xmlReader.Read();\r
 231                         int i = 0;\r
 232                         while(xmlReader.Depth > initialDepth) \r
 233                         {\r
 234                                 long paramId, paramHref;\r
 235                                 object objParam = null;\r
 236                                 paramNames.Add (xmlReader.Name);\r
 237                                 Type paramType = null;\r
 238                                 \r
 239                                 if (message.ParamTypes != null) {\r
 240                                         if (i >= message.ParamTypes.Length)\r
 241                                                 throw new SerializationException ("Not enough parameter types in SoapMessages");\r
 242                                         paramType = message.ParamTypes [i];\r
 243                                 }\r
 244                                 \r
 245                                 indices[0] = i;\r
 246                                 objParam = DeserializeComponent(\r
 247                                         paramType,\r
 248                                         out paramId,\r
 249                                         out paramHref,\r
 250                                         paramValuesId,\r
 251                                         null,\r
 252                                         indices);\r
 253                                 indices[0] = paramValues.Add(objParam);\r
 254                                 if(paramHref != 0) \r
 255                                 {\r
 256                                         RecordFixup(paramValuesId, paramHref, paramValues.ToArray(), null, null, null, indices);\r
 257                                 }\r
 258                                 else if(paramId != 0) \r
 259                                 {\r
 260 //                                      RegisterObject(paramId, objParam, null, paramValuesId, null, indices);\r
 261                                 }\r
 262                                 else \r
 263                                 {\r
 264                                 }\r
 265                                 i++;\r
 266                         }\r
 267 \r
 268                         message.ParamNames = (string[]) paramNames.ToArray(typeof(string));\r
 269                         message.ParamValues = paramValues.ToArray();\r
 270                         xmlReader.ReadEndElement();\r
 271                         RegisterObject(paramValuesId, message.ParamValues, null, 0, null, null);\r
 272                         return true;\r
 273                 }
 274 \r
 275                 void DeserializeHeaders (ArrayList headers)\r
 276                 {\r
 277                         xmlReader.ReadStartElement ();\r
 278                         xmlReader.MoveToContent ();\r
 279                         \r
 280                         while (xmlReader.NodeType != XmlNodeType.EndElement) \r
 281                         {\r
 282                                 if (xmlReader.NodeType != XmlNodeType.Element) { xmlReader.Skip(); continue; }\r
 283                                 \r
 284                                 if (xmlReader.GetAttribute ("root", SoapTypeMapper.SoapEncodingNamespace) == "1")\r
 285                                         headers.Add (DeserializeHeader ());\r
 286                                 else\r
 287                                         Deserialize ();\r
 288 \r
 289                                 xmlReader.MoveToContent ();\r
 290                         }\r
 291                         \r
 292                         xmlReader.ReadEndElement ();\r
 293                 }
 294                 \r               Header DeserializeHeader ()
 295                 {
 296                         Header h = new Header (xmlReader.LocalName, null);
 297                         h.HeaderNamespace = xmlReader.NamespaceURI;\r
 298                         h.MustUnderstand = xmlReader.GetAttribute ("mustUnderstand", SoapTypeMapper.SoapEnvelopeNamespace) == "1";\r
 299                         \r
 300                         object value;\r
 301                         long fieldId, fieldHref;\r
 302                         long idHeader = NextAvailableId;\r
 303                         FieldInfo fieldInfo = typeof(Header).GetField ("Value");\r
 304 \r
 305                         value = DeserializeComponent (null, out fieldId, out fieldHref, idHeader, fieldInfo, null);\r
 306                         h.Value = value;\r
 307 \r
 308                         if(fieldHref != 0 && value == null)\r
 309                         {\r
 310                                 RecordFixup (idHeader, fieldHref, h, null, null, fieldInfo, null);\r
 311                         }\r
 312                         else if(value != null && value.GetType().IsValueType && fieldId != 0)\r
 313                         {\r
 314                                 RecordFixup (idHeader, fieldId, h, null, null, fieldInfo, null);\r
 315                         }\r
 316                         else if(fieldId != 0)\r
 317                         {\r
 318                                 RegisterObject (fieldId, value, null, idHeader, fieldInfo, null);\r
 319                         }\r
 320                         \r
 321                         RegisterObject (idHeader, h, null, 0, null, null);\r
 322                         return h;\r
 323                 }\r
 324 \r
 325                 \r
 326                 private object DeserializeArray(long id)\r
 327                 {\r
 328                         // Get the array properties\r
 329                         string strArrayType = xmlReader["arrayType", SoapTypeMapper.SoapEncodingNamespace];\r
 330                         string[] arrayInfo = strArrayType.Split(':','[',',',']');\r
 331                         int numberOfDims = arrayInfo.Length - 3;\r
 332                         int[] lengths = new int[numberOfDims];\r
 333                         string[] arrayDims = new String[numberOfDims];\r
 334                         Array.Copy(arrayInfo, 2, arrayDims, 0, numberOfDims);\r
 335                         for (int i=0; i < numberOfDims; i++)\r
 336                         {\r
 337                                 lengths[i] = Convert.ToInt32(arrayDims[i]);\r
 338                         }\r
 339 \r
 340                         int[] indices = new int[numberOfDims];\r
 341 \r
 342                         // Create the array\r
 343                         Type arrayType = mapper[new Element(arrayInfo[0], arrayInfo[1], xmlReader.LookupNamespace(arrayInfo[0]))];\r
 344                         Array array = Array.CreateInstance(\r
 345                                 arrayType,\r
 346                                 lengths);\r
 347 \r
 348                         for(int i = 0; i < numberOfDims; i++) \r
 349                         {\r
 350                                 indices[i] = array.GetLowerBound(i);\r
 351                         }\r
 352 \r
 353 \r
 354                         // Deserialize the array items\r
 355                         int arrayDepth = xmlReader.Depth;\r
 356                         xmlReader.Read();\r
 357                         while(xmlReader.Depth > arrayDepth)\r
 358                         {\r
 359 \r
 360                                 Type itemType = GetComponentType();\r
 361                                 if(itemType == null) \r
 362                                         itemType = array.GetType().GetElementType();\r
 363                                 long itemId, itemHref;\r
 364 \r
 365                                 object objItem = DeserializeComponent(itemType,\r
 366                                         out itemId,\r
 367                                         out itemHref,\r
 368                                         id,\r
 369                                         null,\r
 370                                         indices);\r
 371                                 if(itemHref != 0)\r
 372                                 {\r
 373                                         object obj = objMgr.GetObject(itemHref);\r
 374                                         if(obj != null)\r
 375                                                 array.SetValue(obj, indices);\r
 376                                         else\r
 377                                                 RecordFixup(id, itemHref, array, null, null, null, indices);\r
 378                                 }\r
 379                                 else if(objItem != null && objItem.GetType().IsValueType && itemId != 0)\r
 380                                 {\r
 381                                         RecordFixup(id, itemId, array, null, null, null, indices);\r
 382                                 }\r
 383                                 else if(itemId != 0)\r
 384                                 {\r
 385                                         RegisterObject(itemId, objItem, null, id, null, indices);\r
 386                                         array.SetValue(objItem, indices);\r
 387                                 }\r
 388                                 else \r
 389                                 {\r
 390                                         array.SetValue(objItem, indices);\r
 391                                 }\r
 392 \r
 393                                 // Get the next indice\r
 394                                 for(int dim = array.Rank - 1; dim >= 0; dim--)\r
 395                                 {\r
 396                                         indices[dim]++;\r
 397                                         if(indices[dim] > array.GetUpperBound(dim))\r
 398                                         {\r
 399                                                 if(dim > 0)\r
 400                                                 {\r
 401                                                         indices[dim] = array.GetLowerBound(dim);\r
 402                                                         continue;\r
 403                                                 }\r
 404                                                 \r
 405                                         }\r
 406                                         break;\r
 407                                 }\r
 408                         }\r
 409 \r
 410                         RegisterObject(id, array, null, 0, null, null);\r
 411                         xmlReader.ReadEndElement();\r
 412                         return array;\r
 413 \r
 414                 }\r
 415 \r
 416 \r
 417                 private object Deserialize()\r
 418                 {\r
 419                         object objReturn = null;\r
 420                         Element element = new Element(\r
 421                                 xmlReader.Prefix,\r
 422                                 xmlReader.LocalName,\r
 423                                 xmlReader.NamespaceURI);\r
 424 \r
 425 \r
 426                         Type type = mapper[element];\r
 427 \r
 428                         // Get the Id\r
 429                         long id = GetId();\r
 430                         id = (id == 0)?1:id;\r
 431 \r
 432                         if(type == typeof(Array))\r
 433                         {\r
 434                                 objReturn = DeserializeArray(id);\r
 435                         }\r
 436                         else\r
 437                         {\r
 438                                 objReturn = DeserializeObject(type, id, 0, null, null);\r
 439 \r
 440                         }\r
 441 \r
 442                         return objReturn;\r
 443                 }\r
 444 \r
 445 \r
 446                 private object DeserializeObject(\r
 447                         Type type, \r
 448                         long id, \r
 449                         long parentId, \r
 450                         MemberInfo parentMemberInfo,\r
 451                         int[] indices)\r
 452                 {\r
 453                         SerializationInfo info = null;\r
 454                         bool NeedsSerializationInfo = false;\r
 455                         bool hasFixup;\r
 456 \r
 457                         if(SoapTypeMapper.CanBeValue(type)) \r
 458                         {\r
 459                                 string elementString = xmlReader.ReadElementString();\r
 460                                 object obj = SoapTypeMapper.ParseXsdValue (elementString, type);\r
 461                                 \r
 462                                 if(id != 0) \r
 463                                         RegisterObject(id, obj, info, parentId, parentMemberInfo, indices);\r
 464 \r
 465                                 return obj;\r
 466                         }\r
 467                         object objReturn = \r
 468                                 FormatterServices.GetUninitializedObject(type);\r
 469                         if(objReturn is ISerializable)\r
 470                                 NeedsSerializationInfo = true;\r
 471 \r
 472                         if(_surrogateSelector != null && NeedsSerializationInfo == false)\r
 473                         {\r
 474                                 ISurrogateSelector selector;\r
 475                                 ISerializationSurrogate surrogate = _surrogateSelector.GetSurrogate(\r
 476                                         type,\r
 477                                         _context,\r
 478                                         out selector);\r
 479                                 NeedsSerializationInfo |= (surrogate != null);\r
 480                         }\r
 481 \r
 482                         if(NeedsSerializationInfo)\r
 483                         {\r
 484                                 objReturn = \r
 485                                         DeserializeISerializableObject(objReturn, id, out info, out hasFixup);\r
 486                         }\r
 487                         else\r
 488                         {\r
 489                                 objReturn = \r
 490                                         DeserializeSimpleObject(objReturn, id, out hasFixup);\r
 491                                 if(!hasFixup && objReturn is IObjectReference)\r
 492                                         objReturn = ((IObjectReference)objReturn).GetRealObject(_context);\r
 493                         }\r
 494 \r
 495                         RegisterObject(id, objReturn, info, parentId, parentMemberInfo, indices);\r
 496                         xmlReader.ReadEndElement();\r
 497                         return objReturn;\r
 498                 }\r
 499 \r
 500 \r
 501                 private object DeserializeSimpleObject(\r
 502                         object obj,\r
 503                         long id,\r
 504                         out bool hasFixup\r
 505                         )\r
 506                 {\r
 507                         hasFixup = false;\r
 508                         Type currentType = obj.GetType();\r
 509                         TypeMetadata tm = GetTypeMetadata (currentType);\r
 510 \r
 511                         int objDepth = xmlReader.Depth;\r
 512                         object[] data = new object[tm.MemberInfos.Length];\r
 513                         xmlReader.Read();\r
 514                         for(int i = 0; i < tm.MemberInfos.Length; i++)\r
 515                         {\r
 516                                 object fieldObject;\r
 517                                 long fieldId, fieldHref;\r
 518                                 int index = (int) tm.Indices[xmlReader.LocalName];\r
 519                                 FieldInfo fieldInfo = (tm.MemberInfos[index]) as FieldInfo;\r
 520                                 if(fieldInfo == null) continue;\r
 521 \r
 522                                 fieldObject = \r
 523                                         DeserializeComponent(fieldInfo.FieldType,\r
 524                                         out fieldId,\r
 525                                         out fieldHref,\r
 526                                         id,\r
 527                                         fieldInfo,\r
 528                                         null);\r
 529 \r
 530                                 data[index] = fieldObject;\r
 531 \r
 532                                 if(fieldHref != 0 && fieldObject == null)\r
 533                                 {\r
 534                                         RecordFixup(id, fieldHref, obj, null, null, fieldInfo, null);\r
 535                                         hasFixup = true;\r
 536                                         continue;\r
 537                                 }\r
 538                                 if(fieldObject != null && fieldObject.GetType().IsValueType && fieldId != 0)\r
 539                                 {\r
 540                                         RecordFixup(id, fieldId, obj, null, null, fieldInfo, null);\r
 541                                         hasFixup = true;\r
 542                                         continue;\r
 543                                 }\r
 544 \r
 545                                 if(fieldId != 0)\r
 546                                 {\r
 547                                         RegisterObject(fieldId, fieldObject, null, id, fieldInfo, null);\r
 548                                 }\r
 549                         }\r
 550 \r
 551                         FormatterServices.PopulateObjectMembers (obj, tm.MemberInfos, data);\r
 552                         return obj;\r
 553                 }\r
 554 \r
 555 \r
 556                 private object DeserializeISerializableObject(\r
 557                         object obj, \r
 558                         long id, \r
 559                         out SerializationInfo info,\r
 560                         out bool hasFixup\r
 561                         )\r
 562                 {\r
 563                         long fieldId, fieldHref;\r
 564                         info = new SerializationInfo(obj.GetType(), new FormatterConverter());\r
 565                         hasFixup = false;\r
 566                         \r
 567                         int initialDepth = xmlReader.Depth;\r
 568                         xmlReader.Read();\r
 569                         while(xmlReader.Depth > initialDepth) \r
 570                         {\r
 571                                 Type fieldType = GetComponentType();\r
 572                                 string fieldName = xmlReader.LocalName;\r
 573                                 object objField = DeserializeComponent(\r
 574                                         fieldType,\r
 575                                         out fieldId,\r
 576                                         out fieldHref,\r
 577                                         id,\r
 578                                         null,\r
 579                                         null);\r
 580                                 if(fieldHref != 0 && objField == null) \r
 581                                 {\r
 582                                         RecordFixup(id, fieldHref, obj, info, fieldName, null, null);\r
 583                                         hasFixup = true;\r
 584                                         continue;\r
 585                                 }\r
 586                                 else if(fieldId != 0 && objField.GetType().IsValueType)\r
 587                                 {\r
 588                                         RecordFixup(id, fieldId, obj, info, fieldName, null, null);\r
 589                                         hasFixup = true;\r
 590                                         continue;\r
 591                                 }\r
 592                                 \r
 593                                 if(fieldId != 0) \r
 594                                 {\r
 595                                         RegisterObject(fieldId, objField, null, id, null, null);\r
 596                                 }\r
 597 \r
 598                                 info.AddValue(fieldName, objField, (fieldType != null)?fieldType:typeof(object));\r
 599                         }\r
 600 \r
 601                         return obj;\r
 602                 }\r
 603 \r
 604 \r
 605                 private object DeserializeComponent(\r
 606                         Type componentType, \r
 607                         out long componentId,\r
 608                         out long componentHref,\r
 609                         long parentId,\r
 610                         MemberInfo parentMemberInfo,\r
 611                         int[] indices)\r
 612                 {\r
 613                         object objReturn;\r
 614                         componentId = 0;\r
 615                         componentHref = 0;\r
 616 \r
 617                         if(IsNull())\r
 618                         {\r
 619                                 xmlReader.Read();\r
 620                                 return null;\r
 621                         }\r
 622 \r
 623                         Type xsiType = GetComponentType();\r
 624                         if(xsiType != null) componentType = xsiType;\r
 625 \r
 626                         if(xmlReader.HasAttributes)\r
 627                         {\r
 628                                 componentId = GetId();\r
 629                                 componentHref = GetHref();\r
 630                         }\r
 631 \r
 632                         if(componentId != 0)\r
 633                         {\r
 634                                 // It's a string\r
 635                                 return xmlReader.ReadElementString();\r
 636                         }\r
 637                         if(componentHref != 0)\r
 638                         {\r
 639                                 // Move the cursor to the next node\r
 640                                 xmlReader.Read();\r
 641                                 return objMgr.GetObject(componentHref);\r
 642                         }\r
 643 \r
 644                         if(componentType == null)\r
 645                                 return xmlReader.ReadElementString();\r
 646 \r
 647                         componentId = NextAvailableId;\r
 648                         objReturn = DeserializeObject(\r
 649                                 componentType,\r
 650                                 componentId,\r
 651                                 parentId,\r
 652                                 parentMemberInfo,\r
 653                                 indices);\r
 654                         return objReturn;\r
 655                 }\r
 656 \r
 657                 public void RecordFixup(\r
 658                         long parentObjectId, \r
 659                         long childObjectId,\r
 660                         object parentObject,\r
 661                         SerializationInfo info,\r
 662                         string fieldName,\r
 663                         MemberInfo memberInfo,\r
 664                         int[] indices)\r
 665                 {\r
 666                         if(info != null)\r
 667                         {\r
 668                                 objMgr.RecordDelayedFixup(parentObjectId, fieldName, childObjectId);\r
 669                         }\r
 670                         else if (parentObject is Array) \r
 671                         {\r
 672                                 if (indices.Length == 1)\r
 673                                         objMgr.RecordArrayElementFixup (parentObjectId, indices[0], childObjectId);\r
 674                                 else\r
 675                                         objMgr.RecordArrayElementFixup (parentObjectId, (int[])indices.Clone(), childObjectId);\r
 676                         }\r
 677                         else \r
 678                         {\r
 679                                 objMgr.RecordFixup (parentObjectId, memberInfo, childObjectId);\r
 680                         }\r
 681                 }\r
 682 \r
 683                 private void RegisterObject (\r
 684                         long objectId, \r
 685                         object objectInstance, \r
 686                         SerializationInfo info, \r
 687                         long parentObjectId, \r
 688                         MemberInfo parentObjectMember, \r
 689                         int[] indices)\r
 690                 {\r
 691                         if (parentObjectId == 0) indices = null;\r
 692 \r
 693                         if (!objectInstance.GetType().IsValueType || parentObjectId == 0)\r
 694                                 objMgr.RegisterObject (objectInstance, objectId, info, 0, null, null);\r
 695                         else\r
 696                         {\r
 697                                 if(objMgr.GetObject(objectId) != null)\r
 698                                         throw new SerializationException("Object already registered");\r
 699                                 if (indices != null) indices = (int[])indices.Clone();\r
 700                                 objMgr.RegisterObject (\r
 701                                         objectInstance, \r
 702                                         objectId, \r
 703                                         info, \r
 704                                         parentObjectId, \r
 705                                         parentObjectMember, \r
 706                                         indices);\r
 707                         }\r
 708                 }\r
 709 \r
 710                 TypeMetadata GetTypeMetadata (Type type)\r
 711                 {\r
 712                         TypeMetadata tm = _fieldIndices[type] as TypeMetadata;\r
 713                         if (tm != null) return tm;\r
 714                         \r
 715                         tm = new TypeMetadata ();\r
 716                         tm.MemberInfos = FormatterServices.GetSerializableMembers (type, _context);\r
 717                         \r
 718                         tm.Indices      = new Hashtable();\r
 719                         for(int i = 0; i < tm.MemberInfos.Length; i++) \r
 720                                 tm.Indices.Add (tm.MemberInfos[i].Name, i);\r
 721                         \r
 722                         _fieldIndices[type] = tm;\r
 723                         return tm;\r
 724                 }\r
 725                 \r
 726                 #endregion\r
 727         }\r
 728 }\r