mcs/class/corlib/System.Runtime.Serialization.Formatters.Binary/ObjectWriter.cs

   1 // ObjectWriter.cs
   2 //
   3 // Author:
   4 //   Lluis Sanchez Gual (lluis@ideary.com)
   5 //
   6 // (C) 2003 Lluis Sanchez Gual
   7 \r
   8 // FIXME: Implement the missing binary elements\r
   9 \r
  10 using System;\r
  11 using System.IO;\r
  12 using System.Collections;\r
  13 using System.Runtime.Serialization;\r
  14 using System.Runtime.Remoting.Messaging;\r
  15 using System.Reflection;\r
  16 \r
  17 namespace System.Runtime.Serialization.Formatters.Binary\r
  18 {\r
  19         internal class ObjectWriter\r
  20         {\r
  21                 ObjectIDGenerator _idGenerator = new ObjectIDGenerator();\r
  22                 Hashtable _cachedTypes = new Hashtable();\r
  23                 Queue _pendingObjects = new Queue();\r
  24                 Hashtable _assemblyCache = new Hashtable();\r
  25 \r
  26                 static Assembly _corlibAssembly = typeof(string).Assembly;\r
  27 \r
  28                 ISurrogateSelector _surrogateSelector;\r
  29                 StreamingContext _context;\r
  30 \r
  31                 class TypeMetadata\r
  32                 {\r
  33                         public Type[] Types;\r
  34                         public string[] Names;\r
  35                         public Assembly TypeAssembly;\r
  36                         public Type InstanceType;\r
  37                         public long ObjectID;\r
  38                         public bool CustomSerialization;\r
  39 \r
  40                         public bool Equals (TypeMetadata other)\r
  41                         {\r
  42                                 if (!CustomSerialization) return true;\r
  43 \r
  44                                 TypeMetadata tm = (TypeMetadata)other;\r
  45                                 if (Types.Length != tm.Types.Length) return false;\r
  46                                 if (TypeAssembly != other.TypeAssembly) return false;\r
  47                                 if (InstanceType != other.InstanceType) return false;\r
  48                                 for (int n=0; n<Types.Length; n++)\r
  49                                 {\r
  50                                         if (Types[n] != tm.Types[n]) return false;\r
  51                                         if (Names[n] != tm.Names[n]) return false;\r
  52                                 }\r
  53                                 return true;\r
  54                         }\r
  55                 }\r
  56 \r
  57                 public ObjectWriter(ISurrogateSelector surrogateSelector, StreamingContext context)\r
  58                 {\r
  59                         _surrogateSelector = surrogateSelector;\r
  60                         _context = context;\r
  61                 }\r
  62 \r
  63                 public void WriteObjectGraph (BinaryWriter writer, object obj, Header[] headers)\r
  64                 {\r
  65                         _pendingObjects.Clear();\r
  66                         if (headers != null) QueueObject (headers);\r
  67                         QueueObject (obj);\r
  68                         WriteQueuedObjects (writer);\r
  69                         WriteSerializationEnd (writer);\r
  70                 }\r
  71 \r
  72                 public void QueueObject (object obj)\r
  73                 {\r
  74                         _pendingObjects.Enqueue (obj);\r
  75                 }\r
  76 \r
  77                 public void WriteQueuedObjects (BinaryWriter writer)\r
  78                 {\r
  79                         while (_pendingObjects.Count > 0)\r
  80                                 WriteObjectInstance (writer, _pendingObjects.Dequeue());\r
  81                 }\r
  82 \r
  83                 public void WriteObjectInstance (BinaryWriter writer, object obj)\r
  84                 {\r
  85                         bool firstTime;\r
  86                         long id = _idGenerator.GetId (obj, out firstTime);\r
  87 \r
  88                         if (obj.GetType() == typeof(string)) {\r
  89                                 WriteString (writer, id, (string)obj);\r
  90                         }\r
  91                         else if (obj.GetType().IsArray) {\r
  92                                 WriteArray (writer, id, (Array)obj);\r
  93                         }\r
  94                         else\r
  95                                 WriteObject (writer, id, obj);\r
  96                 }\r
  97 \r
  98                 public static void WriteSerializationEnd (BinaryWriter writer)\r
  99                 {\r
 100                         writer.Write ((byte) BinaryElement.End);\r
 101                 }\r
 102 \r
 103                 private void WriteObject (BinaryWriter writer, long id, object obj)\r
 104                 {\r
 105                         object[] values;\r
 106                         TypeMetadata metadata;\r
 107 \r
 108                         GetObjectData (obj, out metadata, out values);\r
 109 \r
 110                         TypeMetadata chachedMetadata = (TypeMetadata)_cachedTypes[metadata.InstanceType];\r
 111 \r
 112                         if (chachedMetadata != null && metadata.Equals(chachedMetadata))\r
 113                         {\r
 114                                 // An object of the same type has already been serialized\r
 115                                 // It is not necessary to write again type metadata\r
 116 \r
 117                                 writer.Write ((byte) BinaryElement.RefTypeObject);\r
 118                                 writer.Write ((int)id);\r
 119 \r
 120                                 // Get the id of the object that has the same type as this\r
 121                                 long refId = chachedMetadata.ObjectID;\r
 122 \r
 123                                 writer.Write ((int)refId);\r
 124                                 WriteObjectContent (writer, metadata.Types, values);\r
 125                                 return;\r
 126                         }\r
 127 \r
 128                         if (chachedMetadata == null)\r
 129                         {\r
 130                                 metadata.ObjectID = id;\r
 131                                 _cachedTypes [metadata.InstanceType] = metadata;\r
 132                         }\r
 133 \r
 134                         BinaryElement objectTag;\r
 135 \r
 136                         int assemblyId;\r
 137                         if (metadata.TypeAssembly == _corlibAssembly)\r
 138                         {\r
 139                                 // A corlib type\r
 140                                 objectTag = BinaryElement.RuntimeObject;\r
 141                                 assemblyId = -1;\r
 142                         }\r
 143                         else\r
 144                         {\r
 145                                 objectTag = BinaryElement.ExternalObject;\r
 146 \r
 147                                 bool firstTime;\r
 148                                 assemblyId = RegisterAssembly (metadata.TypeAssembly, out firstTime);\r
 149                                 if (firstTime) WriteAssembly (writer, assemblyId, metadata.TypeAssembly);\r
 150                         }\r
 151 \r
 152                         // Registers the assemblies needed for each field\r
 153                         // If there are assemblies that where not registered before this object,\r
 154                         // write them now\r
 155 \r
 156                         foreach (object value in values)\r
 157                         {\r
 158                                 if (value == null) continue;\r
 159 \r
 160                                 Type memberType = value.GetType();\r
 161                                 while (memberType.IsArray) \r
 162                                         memberType = memberType.GetElementType();\r
 163 \r
 164                                 if (memberType.Assembly != _corlibAssembly)\r
 165                                 {\r
 166                                         bool firstTime;\r
 167                                         int aid = RegisterAssembly (memberType.Assembly, out firstTime);\r
 168                                         if (firstTime) WriteAssembly (writer, aid, memberType.Assembly);\r
 169                                 }\r
 170                         }\r
 171 \r
 172                         // Writes the object\r
 173 \r
 174                         writer.Write ((byte) objectTag);\r
 175                         writer.Write ((int)id);\r
 176                         writer.Write (metadata.InstanceType.FullName);\r
 177                         WriteObjectMetadata (writer, metadata, assemblyId);\r
 178                         WriteObjectContent (writer, metadata.Types, values);\r
 179                 }\r
 180 \r
 181                 private void WriteObjectMetadata (BinaryWriter writer, TypeMetadata metadata, int assemblyId)\r
 182                 {\r
 183                         Type[] types = metadata.Types;\r
 184                         string[] names = metadata.Names;\r
 185 \r
 186                         writer.Write (types.Length);\r
 187 \r
 188                         // Names of fields\r
 189                         foreach (string name in names)\r
 190                                 writer.Write (name);\r
 191 \r
 192                         // Types of fields\r
 193                         foreach (Type type in types)\r
 194                                 WriteTypeCode (writer, type);\r
 195 \r
 196                         // Type specs of fields\r
 197                         foreach (Type type in types)\r
 198                                 WriteTypeSpec (writer, type);\r
 199 \r
 200                         if (assemblyId != -1) writer.Write (assemblyId);\r
 201                 }\r
 202 \r
 203                 private void WriteObjectContent (BinaryWriter writer, Type[] types, object[] values)\r
 204                 {\r
 205                         for (int n=0; n<values.Length; n++)\r
 206                                 WriteValue (writer, types[n], values[n]);\r
 207                 }\r
 208 \r
 209                 private void GetObjectData (object obj, out TypeMetadata metadata, out object[] values)\r
 210                 {\r
 211                         metadata = new TypeMetadata();\r
 212                         metadata.InstanceType = obj.GetType();\r
 213                         metadata.TypeAssembly = metadata.InstanceType.Assembly;\r
 214 \r
 215                         // Check if the formatter has a surrogate selector \96 if it does, \r
 216                         // check if the surrogate selector handles objects of the given type. \r
 217 \r
 218                         if (_surrogateSelector != null)\r
 219                         {\r
 220                                 ISurrogateSelector selector;\r
 221                                 ISerializationSurrogate surrogate = _surrogateSelector.GetSurrogate (metadata.InstanceType, _context, out selector);\r
 222                                 if (surrogate != null)\r
 223                                 {\r
 224                                         SerializationInfo info = new SerializationInfo (metadata.InstanceType, new FormatterConverter ());\r
 225                                         surrogate.GetObjectData(obj, info, _context);\r
 226                                         GetDataFromSerializationInfo (info, ref metadata, out values);\r
 227                                         return;\r
 228                                 }\r
 229                         }\r
 230 \r
 231                         // Check if the object is marked with the Serializable attribute\r
 232 \r
 233                         if (!metadata.InstanceType.IsSerializable)\r
 234                                 throw new SerializationException ("Type " + metadata.InstanceType +
 235                                                                   " is not marked as Serializable " +
 236                                                                   "and does not implement ISerializable.");
 237 \r
 238                         ISerializable ser = obj as ISerializable;\r
 239 \r
 240                         if (ser != null) \r
 241                         {\r
 242                                 SerializationInfo info = new SerializationInfo (metadata.InstanceType, new FormatterConverter ());\r
 243                                 ser.GetObjectData (info, _context);\r
 244                                 GetDataFromSerializationInfo (info, ref metadata, out values);\r
 245                         } \r
 246                         else \r
 247                                 GetDataFromObjectFields (obj, ref metadata, out values);\r
 248                 }\r
 249 \r
 250                 private void GetDataFromSerializationInfo (SerializationInfo info, ref TypeMetadata metadata, out object[] values)\r
 251                 {\r
 252                         Type[] types = types = new Type [info.MemberCount];\r
 253                         string[] names = new string [info.MemberCount];\r
 254                         values = new object [info.MemberCount];\r
 255 \r
 256                         SerializationInfoEnumerator e = info.GetEnumerator ();\r
 257 \r
 258                         int n = 0;\r
 259                         while (e.MoveNext ())\r
 260                         {\r
 261                                 values[n] = e.Value;\r
 262                                 types[n] = e.ObjectType;\r
 263                                 names[n] = e.Name;\r
 264                                 n++;\r
 265                         }\r
 266 \r
 267                         if (info.FullTypeName != metadata.InstanceType.FullName || info.AssemblyName != metadata.TypeAssembly.FullName) \r
 268                         {\r
 269                                 metadata.TypeAssembly = Assembly.Load (info.AssemblyName);\r
 270                                 metadata.InstanceType = metadata.TypeAssembly.GetType (info.FullTypeName);\r
 271                         }\r
 272 \r
 273                         metadata.Types = types;\r
 274                         metadata.Names = names;\r
 275                         metadata.CustomSerialization = true;\r
 276                 }\r
 277 \r
 278                 private void GetDataFromObjectFields (object obj, ref TypeMetadata metadata, out object[] values)\r
 279                 {\r
 280                         MemberInfo[] members = FormatterServices.GetSerializableMembers (obj.GetType(), _context);\r
 281                         values = FormatterServices.GetObjectData (obj, members);\r
 282 \r
 283                         Type[] types = new Type [members.Length];\r
 284                         string[] names = new string [members.Length];\r
 285 \r
 286                         for (int n=0; n<members.Length; n++)\r
 287                         {\r
 288                                 MemberInfo member = members[n];\r
 289                                 names[n] = member.Name;\r
 290                                 if (member is FieldInfo)\r
 291                                         types[n] = ((FieldInfo)member).FieldType;\r
 292                                 else if (member is PropertyInfo)\r
 293                                         types[n] = ((PropertyInfo)member).PropertyType;\r
 294                         }\r
 295 \r
 296                         metadata.Types = types;\r
 297                         metadata.Names = names;\r
 298                         metadata.CustomSerialization = false;\r
 299                 }\r
 300 \r
 301                 private void WriteArray (BinaryWriter writer, long id, Array array)\r
 302                 {\r
 303                         // There are 4 ways of serializing arrays:\r
 304                         // The element GenericArray (7) can be used for all arrays.\r
 305                         // The element ArrayOfPrimitiveType (15) can be used for single-dimensional\r
 306                         // arrays of primitive types\r
 307                         // The element ArrayOfObject (16) can be used for single-dimensional Object arrays\r
 308                         // The element ArrayOfString (17) can be used for single-dimensional string arrays\r
 309 \r
 310                         Type elementType = array.GetType().GetElementType();\r
 311 \r
 312                         if (elementType == typeof (object) && array.Rank == 1) {\r
 313                                 WriteObjectArray (writer, id, array);\r
 314                         }\r
 315                         else if (elementType == typeof (string) && array.Rank == 1) {\r
 316                                 WriteStringArray (writer, id, array);\r
 317                         }\r
 318                         else if (BinaryCommon.IsPrimitive(elementType) && array.Rank == 1) {\r
 319                                 WritePrimitiveTypeArray (writer, id, array);\r
 320                         }\r
 321                         else\r
 322                                 WriteGenericArray (writer, id, array);\r
 323                 }\r
 324 \r
 325                 private void WriteGenericArray (BinaryWriter writer, long id, Array array)\r
 326                 {\r
 327                         Type elementType = array.GetType().GetElementType();\r
 328 \r
 329                         // Registers and writes the assembly of the array element type if needed\r
 330 \r
 331                         if (!elementType.IsArray && elementType.Assembly != _corlibAssembly)\r
 332                         {\r
 333                                 bool firstTime;\r
 334                                 int aid = RegisterAssembly (elementType.Assembly, out firstTime);\r
 335                                 if (firstTime) WriteAssembly (writer, aid, elementType.Assembly);\r
 336                         }\r
 337 \r
 338                         // Writes the array\r
 339 \r
 340                         writer.Write ((byte) BinaryElement.GenericArray);\r
 341                         writer.Write ((int)id);\r
 342                         \r
 343                         // Write the structure of the array\r
 344 \r
 345                         if (elementType.IsArray) \r
 346                                 writer.Write ((byte) ArrayStructure.Jagged);\r
 347                         else if (array.Rank == 1)\r
 348                                 writer.Write ((byte) ArrayStructure.SingleDimensional);\r
 349                         else\r
 350                                 writer.Write ((byte) ArrayStructure.MultiDimensional);\r
 351 \r
 352                         // Write the number of dimensions and the length\r
 353                         // of each dimension\r
 354 \r
 355                         writer.Write (array.Rank);\r
 356                         for (int n=0; n<array.Rank; n++)\r
 357                                 writer.Write (array.GetUpperBound (n) + 1);\r
 358 \r
 359                         // Writes the type\r
 360                         WriteTypeCode (writer, elementType);\r
 361                         WriteTypeSpec (writer, elementType);\r
 362 \r
 363                         // Writes the values. For single-dimension array, a special tag is used\r
 364                         // to represent multiple consecutive null values. I don't know why this\r
 365                         // optimization is not used for multidimensional arrays.\r
 366 \r
 367                         if (array.Rank == 1 && !elementType.IsValueType)\r
 368                         {\r
 369                                 WriteSingleDimensionArrayElements (writer, array, elementType);\r
 370                         }\r
 371                         else\r
 372                         {\r
 373                                 int[] indices = new int[array.Rank];\r
 374 \r
 375                                 // Initialize indexes\r
 376                                 for (int dim = array.Rank-1; dim >= 0; dim--)\r
 377                                         indices[dim] = array.GetLowerBound (dim);\r
 378 \r
 379                                 bool end = false;\r
 380                                 while (!end)\r
 381                                 {\r
 382                                         WriteValue (writer, elementType, array.GetValue (indices));\r
 383 \r
 384                                         for (int dim = array.Rank-1; dim >= 0; dim--)\r
 385                                         {\r
 386                                                 indices[dim]++;\r
 387                                                 if (indices[dim] > array.GetUpperBound (dim))\r
 388                                                 {\r
 389                                                         if (dim > 0) {\r
 390                                                                 indices[dim] = array.GetLowerBound (dim);\r
 391                                                                 continue;       // Increment the next dimension's index\r
 392                                                         }\r
 393                                                         end = true;     // That was the last dimension. Finished.\r
 394                                                 }\r
 395                                                 break;\r
 396                                         }\r
 397                                 }\r
 398                         }\r
 399                 }\r
 400 \r
 401                 private void WriteObjectArray (BinaryWriter writer, long id, Array array)\r
 402                 {\r
 403                         writer.Write ((byte) BinaryElement.ArrayOfObject);\r
 404                         writer.Write ((int)id);\r
 405                         writer.Write (array.Length);    // Single dimension. Just write the length\r
 406                         WriteSingleDimensionArrayElements (writer, array, typeof (object));\r
 407                 }\r
 408 \r
 409                 private void WriteStringArray (BinaryWriter writer, long id, Array array)\r
 410                 {\r
 411                         writer.Write ((byte) BinaryElement.ArrayOfString);\r
 412                         writer.Write ((int)id);\r
 413                         writer.Write (array.Length);    // Single dimension. Just write the length\r
 414                         WriteSingleDimensionArrayElements (writer, array, typeof (string));\r
 415                 }\r
 416 \r
 417                 private void WritePrimitiveTypeArray (BinaryWriter writer, long id, Array array)\r
 418                 {\r
 419                         writer.Write ((byte) BinaryElement.ArrayOfPrimitiveType);\r
 420                         writer.Write ((int)id);\r
 421                         writer.Write (array.Length);    // Single dimension. Just write the length\r
 422 \r
 423                         Type elementType = array.GetType().GetElementType();\r
 424                         WriteTypeSpec (writer, elementType);\r
 425 \r
 426                         for (int n=0; n<array.Length; n++)\r
 427                                 WritePrimitiveValue (writer, array.GetValue (n));\r
 428                 }\r
 429 \r
 430                 private void WriteSingleDimensionArrayElements (BinaryWriter writer, Array array, Type elementType)\r
 431                 {\r
 432                         int numNulls = 0;\r
 433                         for (int n = array.GetLowerBound (0); n<=array.GetUpperBound(0); n++)\r
 434                         {\r
 435                                 object val = array.GetValue (n);\r
 436                                 if (val != null && numNulls > 0)\r
 437                                 {\r
 438                                         WriteNullFiller (writer, numNulls);\r
 439                                         WriteValue (writer, elementType, val);\r
 440                                         numNulls = 0;\r
 441                                 }\r
 442                                 else if (val == null)\r
 443                                         numNulls++;\r
 444                                 else\r
 445                                         WriteValue (writer, elementType, val);\r
 446                         }\r
 447                         if (numNulls > 0)\r
 448                                 WriteNullFiller (writer, numNulls);\r
 449                 }\r
 450 \r
 451                 private void WriteNullFiller (BinaryWriter writer, int numNulls)\r
 452                 {\r
 453                         if (numNulls == 1) {\r
 454                                 writer.Write ((byte) BinaryElement.NullValue);\r
 455                         }\r
 456                         else if (numNulls == 2) {\r
 457                                 writer.Write ((byte) BinaryElement.NullValue);\r
 458                                 writer.Write ((byte) BinaryElement.NullValue);\r
 459                         }\r
 460                         else if (numNulls <= byte.MaxValue) {\r
 461                                 writer.Write ((byte) BinaryElement.ArrayFiller8b);\r
 462                                 writer.Write ((byte) numNulls);\r
 463                         }\r
 464                         else {\r
 465                                 writer.Write ((byte) BinaryElement.ArrayFiller32b);\r
 466                                 writer.Write (numNulls);\r
 467                         }\r
 468                 }\r
 469 \r
 470                 private void WriteObjectReference (BinaryWriter writer, long id)\r
 471                 {\r
 472                         writer.Write ((byte) BinaryElement.ObjectReference);\r
 473                         writer.Write ((int)id);\r
 474                 }\r
 475 \r
 476                 private void WriteValue (BinaryWriter writer, Type valueType, object val)\r
 477                 {\r
 478                         if (val == null) \r
 479                         {\r
 480                                 writer.Write ((byte) BinaryElement.NullValue);\r
 481                         }\r
 482                         else if (BinaryCommon.IsPrimitive(val.GetType()))\r
 483                         {\r
 484                                 if (!BinaryCommon.IsPrimitive(valueType))\r
 485                                 {\r
 486                                         // It is a boxed primitive type value\r
 487                                         writer.Write ((byte) BinaryElement.BoxedPrimitiveTypeValue);\r
 488                                         WriteTypeSpec (writer, val.GetType());\r
 489                                 }\r
 490                                 WritePrimitiveValue (writer, val);\r
 491                         }\r
 492                         else if (valueType.IsValueType)\r
 493                         {\r
 494                                 // Value types are written embedded in the containing object\r
 495                                 WriteObjectInstance (writer, val);\r
 496                         }\r
 497                         else if (val.GetType() == typeof(string))\r
 498                         {\r
 499                                 // Strings are written embedded, unless already registered\r
 500                                 bool firstTime;\r
 501                                 long id = _idGenerator.GetId (val, out firstTime);\r
 502 \r
 503                                 if (firstTime) WriteObjectInstance (writer, val);\r
 504                                 else WriteObjectReference (writer, id);\r
 505                         }                       \r
 506                         else\r
 507                         {\r
 508                                 // It is a reference type. Write a forward reference and queue the\r
 509                                 // object to the pending object list (unless already written).\r
 510 \r
 511                                 bool firstTime;\r
 512                                 long id = _idGenerator.GetId (val, out firstTime);\r
 513 \r
 514                                 if (firstTime) _pendingObjects.Enqueue (val);\r
 515                                 WriteObjectReference (writer, id);\r
 516                         }\r
 517                 }\r
 518                 \r
 519                 private void WriteString (BinaryWriter writer, long id, string str)\r
 520                 {\r
 521                         writer.Write ((byte) BinaryElement.String);\r
 522                         writer.Write ((int)id);\r
 523                         writer.Write (str);\r
 524                 }\r
 525 \r
 526                 private void WriteAssembly (BinaryWriter writer, int id, Assembly assembly)\r
 527                 {\r
 528                         writer.Write ((byte) BinaryElement.Assembly);\r
 529                         writer.Write (id);\r
 530                         writer.Write (assembly.GetName ().FullName);\r
 531                 }\r
 532 \r
 533                 private int GetAssemblyId (Assembly assembly)\r
 534                 {\r
 535                         return (int)_assemblyCache[assembly];\r
 536                 }\r
 537 \r
 538                 private int RegisterAssembly (Assembly assembly, out bool firstTime)\r
 539                 {\r
 540                         if (_assemblyCache.ContainsKey (assembly))\r
 541                         {\r
 542                                 firstTime = false;\r
 543                                 return (int)_assemblyCache[assembly];\r
 544                         }\r
 545                         else\r
 546                         {\r
 547                                 int id = (int)_idGenerator.GetId (0, out firstTime);\r
 548                                 _assemblyCache.Add (assembly, id);\r
 549                                 return id;\r
 550                         }\r
 551                 }\r
 552 \r
 553                 public static void WritePrimitiveValue (BinaryWriter writer, object value)\r
 554                 {\r
 555                         switch (Type.GetTypeCode (value.GetType()))\r
 556                         {\r
 557                                 case TypeCode.Boolean:\r
 558                                         writer.Write ((bool)value);\r
 559                                         break;\r
 560 \r
 561                                 case TypeCode.Byte:\r
 562                                         writer.Write ((byte) value);\r
 563                                         break;\r
 564 \r
 565                                 case TypeCode.Char:\r
 566                                         writer.Write ((char) value);\r
 567                                         break;\r
 568 \r
 569                                 case TypeCode.DateTime: \r
 570                                         writer.Write ( ((DateTime)value).Ticks);\r
 571                                         break;\r
 572 \r
 573                                 case TypeCode.Decimal:\r
 574                                         writer.Write ((decimal) value);\r
 575                                         break;\r
 576 \r
 577                                 case TypeCode.Double:\r
 578                                         writer.Write ((double) value);\r
 579                                         break;\r
 580 \r
 581                                 case TypeCode.Int16:\r
 582                                         writer.Write ((short) value);\r
 583                                         break;\r
 584 \r
 585                                 case TypeCode.Int32:\r
 586                                         writer.Write ((int) value);\r
 587                                         break;\r
 588 \r
 589                                 case TypeCode.Int64:\r
 590                                         writer.Write ((long) value);\r
 591                                         break;\r
 592 \r
 593                                 case TypeCode.SByte:\r
 594                                         writer.Write ((sbyte) value);\r
 595                                         break;\r
 596 \r
 597                                 case TypeCode.Single:\r
 598                                         writer.Write ((float) value);\r
 599                                         break;\r
 600 \r
 601                                 case TypeCode.UInt16:\r
 602                                         writer.Write ((ushort) value);\r
 603                                         break;\r
 604 \r
 605                                 case TypeCode.UInt32:\r
 606                                         writer.Write ((uint) value);\r
 607                                         break;\r
 608 \r
 609                                 case TypeCode.UInt64:\r
 610                                         writer.Write ((ulong) value);\r
 611                                         break;\r
 612 \r
 613                                 case TypeCode.String:\r
 614                                         writer.Write ((string) value);\r
 615                                         break;\r
 616 \r
 617                                 default:\r
 618                                         throw new NotSupportedException ("Unsupported primitive type: " + value.GetType().FullName);\r
 619                         }\r
 620                 }\r
 621 \r
 622                 public static void WriteTypeCode (BinaryWriter writer, Type type)\r
 623                 {\r
 624                         writer.Write ((byte) GetTypeTag (type));\r
 625                 }\r
 626 \r
 627                 public static TypeTag GetTypeTag (Type type)\r
 628                 {\r
 629                         if (type == typeof (string)) {\r
 630                                 return TypeTag.String;\r
 631                         }\r
 632                         else if (BinaryCommon.IsPrimitive (type)) {\r
 633                                 return TypeTag.PrimitiveType;\r
 634                         }\r
 635                         else if (type == typeof (object)) {\r
 636                                 return TypeTag.ObjectType;\r
 637                         }\r
 638                         else if (type.IsArray && type.GetArrayRank() == 1 && type.GetElementType() == typeof (object)) {\r
 639                                 return TypeTag.ArrayOfObject; \r
 640                         }\r
 641                         else if (type.IsArray && type.GetArrayRank() == 1 && type.GetElementType() == typeof (string)){\r
 642                                 return TypeTag.ArrayOfString;\r
 643                         }\r
 644                         else if (type.IsArray && type.GetArrayRank() == 1 && BinaryCommon.IsPrimitive(type.GetElementType())) {\r
 645                                 return TypeTag.ArrayOfPrimitiveType;\r
 646                         }\r
 647                         else if (type.Assembly == _corlibAssembly) {\r
 648                                 return TypeTag.RuntimeType;\r
 649                         }\r
 650                         else\r
 651                                 return TypeTag.GenericType;\r
 652                 }\r
 653 \r
 654                 public void WriteTypeSpec (BinaryWriter writer, Type type)\r
 655                 {\r
 656                         switch (GetTypeTag (type))\r
 657                         {\r
 658                                 case TypeTag.PrimitiveType:\r
 659                                         writer.Write (BinaryCommon.GetTypeCode (type));\r
 660                                         break;\r
 661 \r
 662                                 case TypeTag.RuntimeType:\r
 663                                         writer.Write (type.FullName);\r
 664                                         break;\r
 665 \r
 666                                 case TypeTag.GenericType:\r
 667                                         writer.Write (type.FullName);\r
 668                                         writer.Write ((int)GetAssemblyId (type.Assembly));\r
 669                                         break;\r
 670 \r
 671                                 case TypeTag.ArrayOfPrimitiveType:\r
 672                                         writer.Write (BinaryCommon.GetTypeCode (type.GetElementType()));\r
 673                                         break;\r
 674 \r
 675                                 default:\r
 676                                         // Type spec not needed\r
 677                                         break;\r
 678                         }\r
 679                 }\r
 680         }\r
 681 }\r