mcs/class/System.XML/System.Xml.Serialization/XmlSerializer.cs

   1 //
   2 // XmlSerializer.cs:
   3 //
   4 // Author:
   5 //   Lluis Sanchez Gual (lluis@ximian.com)
   6 //
   7 // (C) 2002, 2003 Ximian, Inc.  http://www.ximian.com
   8 //
   9
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 using System;
  32 using System.Threading;
  33 using System.Collections;
  34 using System.Globalization;
  35 using System.IO;
  36 using System.Reflection;
  37 using System.Xml;
  38 using System.Xml.Schema;
  39 using System.Text;
  40 using System.CodeDom;
  41 using System.CodeDom.Compiler;
  42 using Microsoft.CSharp;
  43 using System.Configuration;
  44 using System.Security.Policy;
  45
  46 namespace System.Xml.Serialization
  47 {
  48
  49         public class XmlSerializer
  50         {
  51                 internal const string WsdlNamespace = "http://schemas.xmlsoap.org/wsdl/";
  52                 internal const string EncodingNamespace = "http://schemas.xmlsoap.org/soap/encoding/";
  53                 static int generationThreshold;
  54                 static bool backgroundGeneration = true;
  55                 static bool deleteTempFiles = true;
  56
  57                 bool customSerializer;
  58                 XmlMapping typeMapping;
  59
  60                 SerializerData serializerData;
  61                 Type writerType;
  62                 Type readerType;
  63
  64                 static Hashtable serializerTypes = new Hashtable ();
  65
  66                 internal class SerializerData
  67                 {
  68                         public int UsageCount;
  69                         public Type ReaderType;
  70                         public MethodInfo ReaderMethod;
  71                         public Type WriterType;
  72                         public MethodInfo WriterMethod;
  73                         public GenerationBatch Batch;
  74                         public IXmlSerializerImplementation Implementation;
  75
  76                         public XmlSerializationReader CreateReader () {
  77                                 if (ReaderType != null)
  78                                         return (XmlSerializationReader) Activator.CreateInstance (ReaderType);
  79                                 else if (Implementation != null)
  80                                         return Implementation.Reader;
  81                                 else
  82                                         return null;
  83                         }
  84
  85                         public XmlSerializationWriter CreateWriter () {
  86                                 if (WriterType != null)
  87                                         return (XmlSerializationWriter) Activator.CreateInstance (WriterType);
  88                                 else if (Implementation != null)
  89                                         return Implementation.Writer;
  90                                 else
  91                                         return null;
  92                         }
  93                 }
  94
  95                 internal class GenerationBatch
  96                 {
  97                         public bool Done;
  98                         public XmlMapping[] Maps;
  99                         public SerializerData[] Datas;
 100                 }
 101
 102                 static XmlSerializer ()
 103                 {
 104                         string db = Environment.GetEnvironmentVariable ("MONO_XMLSERIALIZER_DEBUG");
 105                         deleteTempFiles = (db == null || db == "no");
 106
 107                         IDictionary table = (IDictionary) ConfigurationSettings.GetConfig("system.diagnostics");
 108                         if (table != null) {
 109                                 table = (IDictionary) table["switches"];
 110                                 if (table != null) {
 111                                         string val = (string) table ["XmlSerialization.Compilation"];
 112                                         if (val == "1") deleteTempFiles = false;
 113                                 }
 114                         }
 115
 116                         string th = Environment.GetEnvironmentVariable ("MONO_XMLSERIALIZER_THS");
 117
 118                         if (th == null) {
 119                                 generationThreshold = 50;
 120                                 backgroundGeneration = true;
 121                         }
 122                         else if (th.ToLower(CultureInfo.InvariantCulture) == "no")
 123                                 generationThreshold = -1;
 124                         else {
 125                                 generationThreshold = int.Parse (th, CultureInfo.InvariantCulture);
 126                                 backgroundGeneration = (generationThreshold != 0);
 127                                 if (generationThreshold < 1) generationThreshold = 1;
 128                         }
 129                 }
 130
 131 #region Constructors
 132
 133                 protected XmlSerializer ()
 134                 {
 135                         customSerializer = true;
 136                 }
 137
 138                 public XmlSerializer (Type type)
 139                         : this (type, null, null, null, null)
 140                 {
 141                 }
 142
 143                 public XmlSerializer (XmlTypeMapping xmlTypeMapping)
 144                 {
 145                         typeMapping = xmlTypeMapping;
 146                 }
 147
 148                 internal XmlSerializer (XmlMapping mapping, SerializerData data)
 149                 {
 150                         typeMapping = mapping;
 151                         serializerData = data;
 152                 }
 153
 154                 public XmlSerializer (Type type, string defaultNamespace)
 155                         : this (type, null, null, null, defaultNamespace)
 156                 {
 157                 }
 158
 159                 public XmlSerializer (Type type, Type[] extraTypes)
 160                         : this (type, null, extraTypes, null, null)
 161                 {
 162                 }
 163
 164                 public XmlSerializer (Type type, XmlAttributeOverrides overrides)
 165                         : this (type, overrides, null, null, null)
 166                 {
 167                 }
 168
 169                 public XmlSerializer (Type type, XmlRootAttribute root)
 170                         : this (type, null, null, root, null)
 171                 {
 172                 }
 173
 174                 public XmlSerializer (Type type,
 175                         XmlAttributeOverrides overrides,
 176                         Type [] extraTypes,
 177                         XmlRootAttribute root,
 178                         string defaultNamespace)
 179                 {
 180                         if (type == null)
 181                                 throw new ArgumentNullException ("type");
 182
 183                         XmlReflectionImporter importer = new XmlReflectionImporter (overrides, defaultNamespace);
 184
 185                         if (extraTypes != null)
 186                         {
 187                                 foreach (Type intype in extraTypes)
 188                                         importer.IncludeType (intype);
 189                         }
 190
 191                         typeMapping = importer.ImportTypeMapping (type, root, defaultNamespace);
 192                 }
 193
 194                 internal XmlMapping Mapping
 195                 {
 196                         get { return typeMapping; }
 197                 }
 198
 199 #if NET_2_0
 200
 201                 [MonoTODO]
 202                 public XmlSerializer (Type type,
 203                         XmlAttributeOverrides overrides,
 204                         Type [] extraTypes,
 205                         XmlRootAttribute root,
 206                         string defaultNamespace,
 207                         string location,
 208                         Evidence evidence)
 209                 {
 210                 }
 211 #endif
 212
 213 #endregion // Constructors
 214
 215 #region Events
 216
 217                 private XmlAttributeEventHandler onUnknownAttribute;
 218                 private XmlElementEventHandler onUnknownElement;
 219                 private XmlNodeEventHandler onUnknownNode;
 220                 private UnreferencedObjectEventHandler onUnreferencedObject;
 221
 222                 public event XmlAttributeEventHandler UnknownAttribute
 223                 {
 224                         add { onUnknownAttribute += value; } remove { onUnknownAttribute -= value; }
 225                 }
 226
 227                 public event XmlElementEventHandler UnknownElement
 228                 {
 229                         add { onUnknownElement += value; } remove { onUnknownElement -= value; }
 230                 }
 231
 232                 public event XmlNodeEventHandler UnknownNode
 233                 {
 234                         add { onUnknownNode += value; } remove { onUnknownNode -= value; }
 235                 }
 236
 237                 public event UnreferencedObjectEventHandler UnreferencedObject
 238                 {
 239                         add { onUnreferencedObject += value; } remove { onUnreferencedObject -= value; }
 240                 }
 241
 242
 243                 internal virtual void OnUnknownAttribute (XmlAttributeEventArgs e)
 244                 {
 245                         if (onUnknownAttribute != null) onUnknownAttribute(this, e);
 246                 }
 247
 248                 internal virtual void OnUnknownElement (XmlElementEventArgs e)
 249                 {
 250                         if (onUnknownElement != null) onUnknownElement(this, e);
 251                 }
 252
 253                 internal virtual void OnUnknownNode (XmlNodeEventArgs e)
 254                 {
 255                         if (onUnknownNode != null) onUnknownNode(this, e);
 256                 }
 257
 258                 internal virtual void OnUnreferencedObject (UnreferencedObjectEventArgs e)
 259                 {
 260                         if (onUnreferencedObject != null) onUnreferencedObject(this, e);
 261                 }
 262
 263
 264 #endregion // Events
 265
 266 #region Methods
 267
 268                 public virtual bool CanDeserialize (XmlReader xmlReader)
 269                 {
 270                         xmlReader.MoveToContent ();
 271                         if (typeMapping is XmlMembersMapping)
 272                                 return true;
 273                         else
 274                                 return ((XmlTypeMapping)typeMapping).ElementName == xmlReader.LocalName;
 275                 }
 276
 277                 protected virtual XmlSerializationReader CreateReader ()
 278                 {
 279                         // Must be implemented in derived class
 280                         throw new NotImplementedException ();
 281                 }
 282
 283                 protected virtual XmlSerializationWriter CreateWriter ()
 284                 {
 285                         // Must be implemented in derived class
 286                         throw new NotImplementedException ();
 287                 }
 288
 289                 public object Deserialize (Stream stream)
 290                 {
 291                         XmlTextReader xmlReader = new XmlTextReader(stream);
 292                         xmlReader.Normalization = true;
 293                         return Deserialize(xmlReader);
 294                 }
 295
 296                 public object Deserialize (TextReader textReader)
 297                 {
 298                         XmlTextReader xmlReader = new XmlTextReader(textReader);
 299                         xmlReader.Normalization = true;
 300                         return Deserialize(xmlReader);
 301                 }
 302
 303                 public object Deserialize (XmlReader xmlReader)
 304                 {
 305                         XmlSerializationReader xsReader;
 306                         if (customSerializer)
 307                                 xsReader = CreateReader ();
 308                         else
 309                                 xsReader = CreateReader (typeMapping);
 310
 311                         xsReader.Initialize (xmlReader, this);
 312                         return Deserialize (xsReader);
 313                 }
 314
 315                 protected virtual object Deserialize (XmlSerializationReader reader)
 316                 {
 317                         if (customSerializer)
 318                                 // Must be implemented in derived class
 319                                 throw new NotImplementedException ();
 320
 321                         if (reader is XmlSerializationReaderInterpreter)
 322                                 return ((XmlSerializationReaderInterpreter)reader).ReadRoot ();
 323                         else
 324                                 return serializerData.ReaderMethod.Invoke (reader, null);
 325                 }
 326
 327                 public static XmlSerializer [] FromMappings (XmlMapping [] mappings)
 328                 {
 329                         XmlSerializer[] sers = new XmlSerializer [mappings.Length];
 330                         SerializerData[] datas = new SerializerData [mappings.Length];
 331                         GenerationBatch batch = new GenerationBatch ();
 332                         batch.Maps = mappings;
 333                         batch.Datas = datas;
 334
 335                         for (int n=0; n<mappings.Length; n++)
 336                         {
 337                                 if (mappings[n] != null)
 338                                 {
 339                                         SerializerData data = new SerializerData ();
 340                                         data.Batch = batch;
 341                                         sers[n] = new XmlSerializer (mappings[n], data);
 342                                         datas[n] = data;
 343                                 }
 344                         }
 345
 346                         return sers;
 347                 }
 348
 349                 public static XmlSerializer [] FromTypes (Type [] mappings)
 350                 {
 351                         XmlSerializer [] sers = new XmlSerializer [mappings.Length];
 352                         for (int n=0; n<mappings.Length; n++)
 353                                 sers[n] = new XmlSerializer (mappings[n]);
 354                         return sers;
 355                 }
 356
 357                 protected virtual void Serialize (object o, XmlSerializationWriter writer)
 358                 {
 359                         if (customSerializer)
 360                                 // Must be implemented in derived class
 361                                 throw new NotImplementedException ();
 362
 363                         if (writer is XmlSerializationWriterInterpreter)
 364                                 ((XmlSerializationWriterInterpreter)writer).WriteRoot (o);
 365                         else
 366                                 serializerData.WriterMethod.Invoke (writer, new object[] {o});
 367                 }
 368
 369                 public void Serialize (Stream stream, object o)
 370                 {
 371                         XmlTextWriter xmlWriter = new XmlTextWriter (stream, System.Text.Encoding.Default);
 372                         xmlWriter.Formatting = Formatting.Indented;
 373                         Serialize (xmlWriter, o, null);
 374                 }
 375
 376                 public void Serialize (TextWriter textWriter, object o)
 377                 {
 378                         XmlTextWriter xmlWriter = new XmlTextWriter (textWriter);
 379                         xmlWriter.Formatting = Formatting.Indented;
 380                         Serialize (xmlWriter, o, null);
 381                 }
 382
 383                 public void Serialize (XmlWriter xmlWriter, object o)
 384                 {
 385                         Serialize (xmlWriter, o, null);
 386                 }
 387
 388                 public void Serialize (Stream stream, object o, XmlSerializerNamespaces namespaces)
 389                 {
 390                         XmlTextWriter xmlWriter = new XmlTextWriter (stream, System.Text.Encoding.Default);
 391                         xmlWriter.Formatting = Formatting.Indented;
 392                         Serialize (xmlWriter, o, namespaces);
 393                 }
 394
 395                 public void Serialize (TextWriter textWriter, object o, XmlSerializerNamespaces namespaces)
 396                 {
 397                         XmlTextWriter xmlWriter = new XmlTextWriter (textWriter);
 398                         xmlWriter.Formatting = Formatting.Indented;
 399                         Serialize (xmlWriter, o, namespaces);
 400                         xmlWriter.Flush();
 401                 }
 402
 403                 public void Serialize (XmlWriter writer, object o, XmlSerializerNamespaces namespaces)
 404                 {
 405                         XmlSerializationWriter xsWriter;
 406
 407                         if (customSerializer)
 408                                 xsWriter = CreateWriter ();
 409                         else
 410                                 xsWriter = CreateWriter (typeMapping);
 411
 412                         if (namespaces == null || namespaces.Count == 0)
 413                         {
 414                                 namespaces = new XmlSerializerNamespaces ();
 415                                 namespaces.Add ("xsd", XmlSchema.Namespace);
 416                                 namespaces.Add ("xsi", XmlSchema.InstanceNamespace);
 417                         }
 418
 419                         xsWriter.Initialize (writer, namespaces);
 420                         Serialize (o, xsWriter);
 421                         writer.Flush ();
 422                 }
 423
 424 #if NET_2_0
 425
 426                 [MonoTODO]
 427                 public object Deserialize (XmlReader xmlReader, string encodingStyle, XmlDeserializationEvents events)
 428                 {
 429                         throw new NotImplementedException ();
 430                 }
 431
 432                 [MonoTODO]
 433                 public object Deserialize (XmlReader xmlReader, string encodingStyle)
 434                 {
 435                         throw new NotImplementedException ();
 436                 }
 437
 438                 [MonoTODO]
 439                 public object Deserialize (XmlReader xmlReader, XmlDeserializationEvents events)
 440                 {
 441                         throw new NotImplementedException ();
 442                 }
 443
 444                 [MonoTODO]
 445                 public static XmlSerializer[] FromMappings (XmlMapping[] mappings, Evidence evidence)
 446                 {
 447                         throw new NotImplementedException ();
 448                 }
 449
 450                 [MonoTODO]
 451                 public static XmlSerializer[] FromMappings (XmlMapping[] mappings, Type type)
 452                 {
 453                         throw new NotImplementedException ();
 454                 }
 455
 456                 public static Assembly GenerateSerializer (Type[] types, XmlMapping[] mappings)
 457                 {
 458                         return GenerateSerializer (types, mappings, null);
 459                 }
 460
 461                 [MonoTODO]
 462                 public static Assembly GenerateSerializer (Type[] types, XmlMapping[] mappings, CompilerParameters parameters)
 463                 {
 464                         GenerationBatch batch = new GenerationBatch ();
 465                         batch.Maps = mappings;
 466                         batch.Datas = new SerializerData [mappings.Length];
 467
 468                         for (int n=0; n<mappings.Length; n++) {
 469                                 SerializerData data = new SerializerData ();
 470                                 data.Batch = batch;
 471                                 batch.Datas [n] = data;
 472                         }
 473
 474                         return GenerateSerializers (batch, parameters);
 475                 }
 476
 477                 [MonoTODO]
 478                 [Obsolete]
 479                 public static Assembly GenerateSerializer (Type[] types,
 480                         XmlMapping[] mappings,
 481                         string codePath,
 482                         bool debug,
 483                         bool keepFiles)
 484                 {
 485                         throw new NotImplementedException ();
 486                 }
 487
 488                 [MonoTODO]
 489                 [Obsolete]
 490                 public static Assembly GenerateSerializer (Type[] types,
 491                         XmlMapping[] mappings,
 492                         string codePath,
 493                         bool debug,
 494                         bool keepFiles,
 495                         string compilerOptions)
 496                 {
 497                         throw new NotImplementedException ();
 498                 }
 499
 500                 public static string GetXmlSerializerAssemblyName (Type type)
 501                 {
 502                         return type.Assembly.GetName().Name + ".XmlSerializers";
 503                 }
 504
 505                 public static string GetXmlSerializerAssemblyName (Type type, string defaultNamespace)
 506                 {
 507                         return GetXmlSerializerAssemblyName (type) + "." + defaultNamespace.GetHashCode ();
 508                 }
 509
 510                 [MonoTODO]
 511                 public void Serialize (XmlWriter xmlWriter, object o, XmlSerializerNamespaces namespaces, string encodingStyle)
 512                 {
 513                         throw new NotImplementedException ();
 514                 }
 515
 516 #endif
 517
 518                 XmlSerializationWriter CreateWriter (XmlMapping typeMapping)
 519                 {
 520                         XmlSerializationWriter writer;
 521
 522                         lock (this) {
 523                                 if (serializerData != null) {
 524                                         writer = serializerData.CreateWriter ();
 525                                         if (writer != null) return writer;
 526                                 }
 527                         }
 528
 529                         if (!typeMapping.Source.CanBeGenerated || generationThreshold == -1)
 530                                 return new XmlSerializationWriterInterpreter (typeMapping);
 531
 532                         CheckGeneratedTypes (typeMapping);
 533
 534                         lock (this) {
 535                                 writer = serializerData.CreateWriter ();
 536                                 if (writer != null) return writer;
 537                         }
 538
 539                         return new XmlSerializationWriterInterpreter (typeMapping);
 540                 }
 541
 542                 XmlSerializationReader CreateReader (XmlMapping typeMapping)
 543                 {
 544                         XmlSerializationReader reader;
 545
 546                         lock (this) {
 547                                 if (serializerData != null) {
 548                                         reader = serializerData.CreateReader ();
 549                                         if (reader != null) return reader;
 550                                 }
 551                         }
 552
 553                         if (!typeMapping.Source.CanBeGenerated || generationThreshold == -1)
 554                                 return new XmlSerializationReaderInterpreter (typeMapping);
 555
 556                         CheckGeneratedTypes (typeMapping);
 557
 558                         lock (this) {
 559                                 reader = serializerData.CreateReader ();
 560                                 if (reader != null) return reader;
 561                         }
 562
 563                         return new XmlSerializationReaderInterpreter (typeMapping);
 564                 }
 565
 566                 void CheckGeneratedTypes (XmlMapping typeMapping)
 567                 {
 568                         lock (this)
 569                         {
 570                                 if (serializerData == null)
 571                                 {
 572                                         lock (serializerTypes)
 573                                         {
 574                                                 serializerData = (SerializerData) serializerTypes [typeMapping.Source];
 575                                                 if (serializerData == null) {
 576                                                         serializerData = new SerializerData();
 577                                                         serializerTypes [typeMapping.Source] = serializerData;
 578                                                 }
 579                                         }
 580                                 }
 581                         }
 582
 583                         bool generate = false;
 584                         lock (serializerData)
 585                         {
 586                                 generate = (++serializerData.UsageCount == generationThreshold);
 587                         }
 588
 589                         if (generate)
 590                         {
 591                                 if (serializerData.Batch != null)
 592                                         GenerateSerializersAsync (serializerData.Batch);
 593                                 else
 594                                 {
 595                                         GenerationBatch batch = new GenerationBatch ();
 596                                         batch.Maps = new XmlMapping[] {typeMapping};
 597                                         batch.Datas = new SerializerData[] {serializerData};
 598                                         GenerateSerializersAsync (batch);
 599                                 }
 600                         }
 601                 }
 602
 603                 void GenerateSerializersAsync (GenerationBatch batch)
 604                 {
 605                         if (batch.Maps.Length != batch.Datas.Length)
 606                                 throw new ArgumentException ("batch");
 607
 608                         lock (batch)
 609                         {
 610                                 if (batch.Done) return;
 611                                 batch.Done = true;
 612                         }
 613
 614                         if (backgroundGeneration)
 615                                 ThreadPool.QueueUserWorkItem (new WaitCallback (RunSerializerGeneration), batch);
 616                         else
 617                                 RunSerializerGeneration (batch);
 618                 }
 619
 620                 void RunSerializerGeneration (object obj)
 621                 {
 622                         try
 623                         {
 624                                 GenerationBatch batch = (GenerationBatch) obj;
 625                                 batch = LoadFromSatelliteAssembly (batch);
 626
 627                                 if (batch != null)
 628                                         GenerateSerializers (batch, null);
 629                         }
 630                         catch (Exception ex)
 631                         {
 632                                 Console.WriteLine (ex);
 633                         }
 634                 }
 635
 636                 static Assembly GenerateSerializers (GenerationBatch batch, CompilerParameters cp)
 637                 {
 638                         DateTime tim = DateTime.Now;
 639
 640                         XmlMapping[] maps = batch.Maps;
 641
 642                         if (cp == null) {
 643                                 cp = new CompilerParameters();
 644                                 cp.IncludeDebugInformation = false;
 645                                 cp.GenerateInMemory = true;
 646                                 cp.TempFiles.KeepFiles = !deleteTempFiles;
 647                         }
 648
 649                         string file = cp.TempFiles.AddExtension ("cs");
 650                         StreamWriter sw = new StreamWriter (file);
 651
 652                         if (!deleteTempFiles)
 653                                 Console.WriteLine ("Generating " + file);
 654
 655                         SerializationCodeGenerator gen = new SerializationCodeGenerator (maps);
 656
 657                         try
 658                         {
 659                                 gen.GenerateSerializers (sw);
 660                         }
 661                         catch (Exception ex)
 662                         {
 663                                 Console.WriteLine ("Serializer could not be generated");
 664                                 Console.WriteLine (ex);
 665                                 cp.TempFiles.Delete ();
 666                                 return null;
 667                         }
 668                         sw.Close ();
 669
 670                         CSharpCodeProvider provider = new CSharpCodeProvider();
 671                         ICodeCompiler comp = provider.CreateCompiler ();
 672
 673                         cp.GenerateExecutable = false;
 674
 675                         foreach (Type rtype in gen.ReferencedTypes)
 676                         {
 677                                 if (!cp.ReferencedAssemblies.Contains (rtype.Assembly.Location))
 678                                         cp.ReferencedAssemblies.Add (rtype.Assembly.Location);
 679                         }
 680
 681                         if (!cp.ReferencedAssemblies.Contains ("System.dll"))
 682                                 cp.ReferencedAssemblies.Add ("System.dll");
 683                         if (!cp.ReferencedAssemblies.Contains ("System.Xml"))
 684                                 cp.ReferencedAssemblies.Add ("System.Xml");
 685                         if (!cp.ReferencedAssemblies.Contains ("System.Data"))
 686                                 cp.ReferencedAssemblies.Add ("System.Data");
 687
 688                         CompilerResults res = comp.CompileAssemblyFromFile (cp, file);
 689                         if (res.Errors.Count > 0)
 690                         {
 691                                 Console.WriteLine ("Error while compiling generated serializer");
 692                                 foreach (CompilerError error in res.Errors)
 693                                         Console.WriteLine (error);
 694
 695                                 cp.TempFiles.Delete ();
 696                                 return null;
 697                         }
 698
 699                         GenerationResult[] results = gen.GenerationResults;
 700                         for (int n=0; n<results.Length; n++)
 701                         {
 702                                 GenerationResult gres = results[n];
 703                                 SerializerData sd = batch.Datas [n];
 704                                 lock (sd)
 705                                 {
 706                                         sd.WriterType = res.CompiledAssembly.GetType (gres.Namespace + "." + gres.WriterClassName);
 707                                         sd.ReaderType = res.CompiledAssembly.GetType (gres.Namespace + "." + gres.ReaderClassName);
 708                                         sd.WriterMethod = sd.WriterType.GetMethod (gres.WriteMethodName);
 709                                         sd.ReaderMethod = sd.ReaderType.GetMethod (gres.ReadMethodName);
 710                                         sd.Batch = null;
 711                                 }
 712                         }
 713
 714                         cp.TempFiles.Delete ();
 715
 716                         if (!deleteTempFiles)
 717                                 Console.WriteLine ("Generation finished - " + (DateTime.Now - tim).TotalMilliseconds + " ms");
 718
 719                         return res.CompiledAssembly;
 720                 }
 721
 722 #if NET_2_0
 723                 GenerationBatch LoadFromSatelliteAssembly (GenerationBatch batch)
 724                 {
 725                         return batch;
 726                 }
 727 #else
 728                 GenerationBatch LoadFromSatelliteAssembly (GenerationBatch batch)
 729                 {
 730                         return batch;
 731                 }
 732 #endif
 733
 734 #endregion // Methods
 735         }
 736 }