[2019-12] [bcl] Default XmlSerializer stream serialize to UTF8 Encoding (#18908)

[mono-project.git] / mcs / class / System.XML / System.Xml.Serialization / XmlSerializer.cs

//
// XmlSerializer.cs: 
//
// Author:
//   Lluis Sanchez Gual (lluis@ximian.com)
//
// (C) 2002, 2003 Ximian, Inc.  http://www.ximian.com
//

//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

using System;
using System.Threading;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Xml;
using System.Xml.Schema;
using System.Text;
#if !MOBILE
using System.CodeDom;
using System.CodeDom.Compiler;
using Microsoft.CSharp;
#endif
using System.Configuration;
using System.Security.Policy;

namespace System.Xml.Serialization
{

        public class XmlSerializer
        {
                internal const string WsdlNamespace = "http://schemas.xmlsoap.org/wsdl/";
                internal const string EncodingNamespace = "http://schemas.xmlsoap.org/soap/encoding/";
                internal const string WsdlTypesNamespace = "http://microsoft.com/wsdl/types/";
                static int generationThreshold;
                static bool backgroundGeneration = true;
                static bool deleteTempFiles = true;
                static bool generatorFallback = true;

                bool customSerializer;
                XmlMapping typeMapping;
                
                SerializerData serializerData;
                
                static Hashtable serializerTypes = new Hashtable ();
                
                internal class SerializerData
                {
                        public int UsageCount;
                        public bool Generated;
                        public Type ReaderType;
                        public MethodInfo ReaderMethod;
                        public Type WriterType;
                        public MethodInfo WriterMethod;
                        public GenerationBatch Batch;
                        public XmlSerializerImplementation Implementation = null;
                        
                        public XmlSerializationReader CreateReader () {
                                if (ReaderType != null)
                                        return (XmlSerializationReader) Activator.CreateInstance (ReaderType);
                                else if (Implementation != null)
                                        return Implementation.Reader;
                                else
                                        return null;
                        }
                        
                        public XmlSerializationWriter CreateWriter () {
                                if (WriterType != null)
                                        return (XmlSerializationWriter) Activator.CreateInstance (WriterType);
                                else if (Implementation != null)
                                        return Implementation.Writer;
                                else
                                        return null;
                        }
                }
                
                internal class GenerationBatch
                {
                        public bool Done;
                        public XmlMapping[] Maps;
                        public SerializerData[] Datas;
                }
                
                static XmlSerializer ()
                {
                        // The following options are available:
                        // MONO_XMLSERIALIZER_DEBUG: when set to something != "no", it will
                        //       it will print the name of the generated file, and it won't
                        //       be deleted.
                        // MONO_XMLSERIALIZER_THS: The code generator threshold. It can be:
                        //       no: does not use the generator, always the interpreter.
                        //       0: always use the generator, wait until the generation is done.
                        //       any number: use the interpreted serializer until the specified
                        //       number of serializations is reached. At this point the generation
                        //       of the serializer will start in the background. The interpreter
                        //       will be used while the serializer is being generated.
                        //
                        //       XmlSerializer will fall back to the interpreted serializer if
                        //       the code generation somehow fails. This can be avoided for
                        //       debugging pourposes by adding the "nofallback" option.
                        //       For example: MONO_XMLSERIALIZER_THS=0,nofallback
                        
#if MOBILE
                        string db = null;
                        string th = null;
                        generationThreshold = -1;
                        backgroundGeneration = false;
#else
                        string db = Environment.GetEnvironmentVariable ("MONO_XMLSERIALIZER_DEBUG");
                        string th = Environment.GetEnvironmentVariable ("MONO_XMLSERIALIZER_THS");
                        
                        if (th == null) {
                                generationThreshold = 50;
                                backgroundGeneration = true;
                        } else {
                                int i = th.IndexOf (',');
                                if (i != -1) {
                                        if (th.Substring (i+1) == "nofallback")
                                                generatorFallback = false;
                                        th = th.Substring (0, i);
                                }
                                
                                if (th.ToLower(CultureInfo.InvariantCulture) == "no") 
                                        generationThreshold = -1;
                                else {
                                        generationThreshold = int.Parse (th, CultureInfo.InvariantCulture);
                                        backgroundGeneration = (generationThreshold != 0);
                                }
                        }
#endif
                        deleteTempFiles = (db == null || db == "no");
#if !MOBILE && CONFIGURATION_DEP
                        // DiagnosticsSection
                        ConfigurationSection table = (ConfigurationSection) ConfigurationSettings.GetConfig("system.diagnostics");
                        var bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
                        if (table != null) 
                        {
                                // SwitchElementsCollection
                                var pi = table.GetType ().GetProperty ("Switches", bf);
                                var switchesElement = (ConfigurationElementCollection) pi.GetValue (table, null);
                                foreach (ConfigurationElement e in switchesElement) {
                                        // SwitchElement
                                        if (e.GetType ().GetProperty ("Name", bf).GetValue (e, null) as string == "XmlSerialization.Compilation") {
                                                if (e.GetType ().GetProperty ("Value", bf).GetValue (e, null) as string == "1")
                                                        deleteTempFiles = false;
                                                break;
                                        }
                                }
                        }
#endif
                }

#region Constructors

                protected XmlSerializer ()
                {
                        customSerializer = true;
                }

                public XmlSerializer (Type type)
                        : this (type, null, null, null, null)
                {
                }

                public XmlSerializer (XmlTypeMapping xmlTypeMapping)
                {
                        typeMapping = xmlTypeMapping;
                }

                internal XmlSerializer (XmlMapping mapping, SerializerData data)
                {
                        typeMapping = mapping;
                        serializerData = data;
                }

                public XmlSerializer (Type type, string defaultNamespace)
                        : this (type, null, null, null, defaultNamespace)
                {
                }

                public XmlSerializer (Type type, Type[] extraTypes)
                        : this (type, null, extraTypes, null, null)
                {
                }

                public XmlSerializer (Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace, string location)
                        : this (type, overrides, extraTypes, root, defaultNamespace, location, null)
                {
                }

                public XmlSerializer (Type type, XmlAttributeOverrides overrides)
                        : this (type, overrides, null, null, null)
                {
                }

                public XmlSerializer (Type type, XmlRootAttribute root)
                        : this (type, null, null, root, null)
                {
                }

                public XmlSerializer (Type type,
                        XmlAttributeOverrides overrides,
                        Type [] extraTypes,
                        XmlRootAttribute root,
                        string defaultNamespace)
                {
                        if (type == null)
                                throw new ArgumentNullException ("type");

                        XmlReflectionImporter importer = new XmlReflectionImporter (overrides, defaultNamespace);

                        if (extraTypes != null) 
                        {
                                foreach (Type intype in extraTypes)
                                        importer.IncludeType (intype);
                        }

                        typeMapping = importer.ImportTypeMapping (type, root, defaultNamespace);
                }
                
                internal XmlMapping Mapping
                {
                        get { return typeMapping; }
                }


                [MonoTODO]
                public XmlSerializer (Type type,
                        XmlAttributeOverrides overrides,
                        Type [] extraTypes,
                        XmlRootAttribute root,
                        string defaultNamespace,
                        string location,
                        Evidence evidence)
                {
                }

#endregion // Constructors

#region Events
                private UnreferencedObjectEventHandler onUnreferencedObject;
                private XmlAttributeEventHandler onUnknownAttribute;
                private XmlElementEventHandler onUnknownElement;
                private XmlNodeEventHandler onUnknownNode;

                public event XmlAttributeEventHandler UnknownAttribute 
                {
                        add { onUnknownAttribute += value; } remove { onUnknownAttribute -= value; }
                }

                public event XmlElementEventHandler UnknownElement 
                {
                        add { onUnknownElement += value; } remove { onUnknownElement -= value; }
                }

                public event XmlNodeEventHandler UnknownNode 
                {
                        add { onUnknownNode += value; } remove { onUnknownNode -= value; }
                }


                internal virtual void OnUnknownAttribute (XmlAttributeEventArgs e) 
                {
                        if (onUnknownAttribute != null) onUnknownAttribute(this, e);
                }

                internal virtual void OnUnknownElement (XmlElementEventArgs e) 
                {
                        if (onUnknownElement != null) onUnknownElement(this, e);
                }

                internal virtual void OnUnknownNode (XmlNodeEventArgs e) 
                {
                        if (onUnknownNode != null) onUnknownNode(this, e);
                }

                internal virtual void OnUnreferencedObject (UnreferencedObjectEventArgs e) 
                {
                        if (onUnreferencedObject != null) onUnreferencedObject(this, e);
                }

                public event UnreferencedObjectEventHandler UnreferencedObject 
                {
                        add { onUnreferencedObject += value; } remove { onUnreferencedObject -= value; }
                }

#endregion // Events

#region Methods

                public virtual bool CanDeserialize (XmlReader xmlReader)
                {
                        xmlReader.MoveToContent ();
                        if (typeMapping is XmlMembersMapping) 
                                return true;
                        else
                                return ((XmlTypeMapping)typeMapping).ElementName == xmlReader.LocalName;
                }

                protected virtual XmlSerializationReader CreateReader ()
                {
                        // Must be implemented in derived class
                        throw new NotImplementedException ();
                }

                protected virtual XmlSerializationWriter CreateWriter ()
                {
                        // Must be implemented in derived class
                        throw new NotImplementedException ();
                }

                public object Deserialize (Stream stream)
                {
                        XmlTextReader xmlReader = new XmlTextReader(stream);
                        xmlReader.Normalization = true;
                        xmlReader.WhitespaceHandling = WhitespaceHandling.Significant;
                        return Deserialize(xmlReader);
                }

                public object Deserialize (TextReader textReader)
                {
                        XmlTextReader xmlReader = new XmlTextReader(textReader);
                        xmlReader.Normalization = true;
                        xmlReader.WhitespaceHandling = WhitespaceHandling.Significant;
                        return Deserialize(xmlReader);
                }

                public object Deserialize (XmlReader xmlReader)
                {
                        XmlSerializationReader xsReader;
                        if (customSerializer)
                                xsReader = CreateReader ();
                        else
                                xsReader = CreateReader (typeMapping);
                                
                        xsReader.Initialize (xmlReader, this);
                        return Deserialize (xsReader);
                }

                protected virtual object Deserialize (XmlSerializationReader reader)
                {
                        if (customSerializer)
                                // Must be implemented in derived class
                                throw new NotImplementedException ();
                        
                        try {
                                if (reader is XmlSerializationReaderInterpreter)
                                        return ((XmlSerializationReaderInterpreter) reader).ReadRoot ();
                                else {
                                        try {
                                                return serializerData.ReaderMethod.Invoke (reader, null);
                                        } catch (TargetInvocationException ex) {
                                                throw ex.InnerException;
                                        }
                                }
                        } catch (Exception ex) {
                                if (ex is InvalidOperationException || ex is InvalidCastException)
                                        throw new InvalidOperationException ("There is an error in"
                                                + " XML document.", ex);
                                throw;
                        }
                }

                public static XmlSerializer [] FromMappings (XmlMapping [] mappings)
                {
                        XmlSerializer[] sers = new XmlSerializer [mappings.Length];
                        SerializerData[] datas = new SerializerData [mappings.Length];
                        GenerationBatch batch = new GenerationBatch ();
                        batch.Maps = mappings;
                        batch.Datas = datas;
                        
                        for (int n=0; n<mappings.Length; n++)
                        {
                                if (mappings[n] != null)
                                {
                                        SerializerData data = new SerializerData ();
                                        data.Batch = batch;
                                        sers[n] = new XmlSerializer (mappings[n], data);
                                        datas[n] = data;
                                }
                        }
                        
                        return sers;
                }

                public static XmlSerializer [] FromTypes (Type [] types)
                {
                        XmlSerializer [] sers = new XmlSerializer [types.Length];
                        for (int n=0; n<types.Length; n++)
                                sers[n] = new XmlSerializer (types[n]);
                        return sers;
                }

                protected virtual void Serialize (object o, XmlSerializationWriter writer)
                {
                        if (customSerializer)
                                // Must be implemented in derived class
                                throw new NotImplementedException ();
                                
                        if (writer is XmlSerializationWriterInterpreter)
                                ((XmlSerializationWriterInterpreter)writer).WriteRoot (o);
                        else {
                                try {
                                        serializerData.WriterMethod.Invoke (writer, new object[] {o});
                                } catch (TargetInvocationException ex) {
                                        throw ex.InnerException;
                                }
                        }
                }

                public void Serialize (Stream stream, object o)
                {
                        Serialize (stream, o, null);
                }

                public void Serialize (TextWriter textWriter, object o)
                {
                        XmlTextWriter xmlWriter = new XmlTextWriter (textWriter);
                        xmlWriter.Formatting = Formatting.Indented;
                        Serialize (xmlWriter, o, null);
                }

                public void Serialize (XmlWriter xmlWriter, object o)
                {
                        Serialize (xmlWriter, o, null);
                }

                public void Serialize (Stream stream, object o, XmlSerializerNamespaces namespaces)
                {
                        XmlTextWriter xmlWriter = new XmlTextWriter (stream, Encoding.UTF8);
                        xmlWriter.Formatting = Formatting.Indented;
                        Serialize (xmlWriter, o, namespaces);
                }

                public void Serialize (TextWriter textWriter, object o, XmlSerializerNamespaces namespaces)
                {
                        XmlTextWriter xmlWriter = new XmlTextWriter (textWriter);
                        xmlWriter.Formatting = Formatting.Indented;
                        Serialize (xmlWriter, o, namespaces);
                        xmlWriter.Flush();
                }

                public void Serialize (XmlWriter xmlWriter, object o, XmlSerializerNamespaces namespaces)
                {
                        XmlSerializationWriter xsWriter;

                        try {
                                if (customSerializer)
                                        xsWriter = CreateWriter ();
                                else
                                        xsWriter = CreateWriter (typeMapping);

                                if (namespaces == null || namespaces.Count == 0) {
                                        namespaces = new XmlSerializerNamespaces ();
                                        namespaces.Add ("xsi", XmlSchema.InstanceNamespace);
                                        namespaces.Add ("xsd", XmlSchema.Namespace);
                                }

                                xsWriter.Initialize (xmlWriter, namespaces);
                                Serialize (o, xsWriter);
                                xmlWriter.Flush ();
                        } catch (Exception ex) {
                                if (ex is TargetInvocationException)
                                        ex = ex.InnerException;

                                if (ex is InvalidOperationException || ex is InvalidCastException)
                                        throw new InvalidOperationException ("There was an error generating" +
                                                " the XML document.", ex);

                                throw;
                        }
                }
                
                [MonoTODO]
                public object Deserialize (XmlReader xmlReader, string encodingStyle, XmlDeserializationEvents events)
                {
                        throw new NotImplementedException ();
                }

                [MonoTODO]
                public object Deserialize (XmlReader xmlReader, string encodingStyle)
                {
                        throw new NotImplementedException ();
                }

                [MonoTODO]
                public object Deserialize (XmlReader xmlReader, XmlDeserializationEvents events)
                {
                        throw new NotImplementedException ();
                }
                
                [MonoTODO]
                public static XmlSerializer[] FromMappings (XmlMapping[] mappings, Evidence evidence)
                {
                        throw new NotImplementedException ();
                }

                [MonoTODO]
                public static XmlSerializer[] FromMappings (XmlMapping[] mappings, Type type)
                {
                        throw new NotImplementedException ();
                }

#if !MOBILE
                public static Assembly GenerateSerializer (Type[] types, XmlMapping[] mappings)
                {
                        return GenerateSerializer (types, mappings, null);
                }
                
                [MonoTODO]
                public static Assembly GenerateSerializer (Type[] types, XmlMapping[] mappings, CompilerParameters parameters)
                {
                        GenerationBatch batch = new GenerationBatch ();
                        batch.Maps = mappings;
                        batch.Datas = new SerializerData [mappings.Length];
                        
                        for (int n=0; n<mappings.Length; n++) {
                                SerializerData data = new SerializerData ();
                                data.Batch = batch;
                                batch.Datas [n] = data;
                        }
                        
                        return GenerateSerializers (batch, parameters);
                }
#endif

                public static string GetXmlSerializerAssemblyName (Type type)
                {
                        return type.Assembly.GetName().Name + ".XmlSerializers";
                }

                public static string GetXmlSerializerAssemblyName (Type type, string defaultNamespace)
                {
                        return GetXmlSerializerAssemblyName (type) + "." + defaultNamespace.GetHashCode ();
                }
                
                [MonoTODO]
                public void Serialize (XmlWriter xmlWriter, object o, XmlSerializerNamespaces namespaces, string encodingStyle)
                {
                        throw new NotImplementedException ();
                }

                [MonoNotSupported("")]
                public void Serialize (XmlWriter xmlWriter, Object o, XmlSerializerNamespaces namespaces, string encodingStyle, string id)
                {
                        throw new NotImplementedException ();
                }
                
                XmlSerializationWriter CreateWriter (XmlMapping typeMapping)
                {
                        XmlSerializationWriter writer;
                        
                        lock (this) {
                                if (serializerData != null) {
                                        lock (serializerData) {
                                                writer = serializerData.CreateWriter ();
                                        }
                                        if (writer != null) return writer;
                                }
                        }
                        
#if !MOBILE
                        if (!typeMapping.Source.CanBeGenerated || generationThreshold == -1)
                                return new XmlSerializationWriterInterpreter (typeMapping);

                        CheckGeneratedTypes (typeMapping);
                        
                        lock (this) {
                                lock (serializerData) {
                                        writer = serializerData.CreateWriter ();
                                }
                                if (writer != null) return writer;
                                if (!generatorFallback)
                                        throw new InvalidOperationException ("Error while generating serializer");
                        }
                        
#endif
                        return new XmlSerializationWriterInterpreter (typeMapping);
                }
                
                XmlSerializationReader CreateReader (XmlMapping typeMapping)
                {
#if !MOBILE
                        XmlSerializationReader reader;
                        
                        lock (this) {
                                if (serializerData != null) {
                                        lock (serializerData) {
                                                reader = serializerData.CreateReader ();
                                        }
                                        if (reader != null) return reader;
                                }
                        }
                        
                        if (!typeMapping.Source.CanBeGenerated || generationThreshold == -1)
                                return new XmlSerializationReaderInterpreter (typeMapping);

                        CheckGeneratedTypes (typeMapping);
                        
                        lock (this) {
                                lock (serializerData) {
                                        reader = serializerData.CreateReader ();
                                }
                                if (reader != null) return reader;
                                if (!generatorFallback)
                                        throw new InvalidOperationException ("Error while generating serializer");
                        }

#endif
                        return new XmlSerializationReaderInterpreter (typeMapping);
                }
                
#if MOBILE
                void CheckGeneratedTypes (XmlMapping typeMapping)
                {
                        throw new NotImplementedException();
                }
                void GenerateSerializersAsync (GenerationBatch batch)
                {
                        throw new NotImplementedException();
                }
                void RunSerializerGeneration (object obj)
                {
                        throw new NotImplementedException();
                }
#else
                void CheckGeneratedTypes (XmlMapping typeMapping)
                {
                        lock (this)
                        {
                                if (serializerData == null) 
                                {
                                        lock (serializerTypes)
                                        {
                                                serializerData = (SerializerData) serializerTypes [typeMapping.Source];
                                                if (serializerData == null) {
                                                        serializerData = new SerializerData();
                                                        serializerTypes [typeMapping.Source] = serializerData;
                                                }
                                        }
                                }
                        }
                        
                        bool generate = false;
                        lock (serializerData)
                        {
                                if (serializerData.UsageCount >= generationThreshold && !serializerData.Generated)
                                        serializerData.Generated = generate = true;

                                serializerData.UsageCount++;
                        }
                        
                        if (generate)
                        {
                                if (serializerData.Batch != null)
                                        GenerateSerializersAsync (serializerData.Batch);
                                else
                                {
                                        GenerationBatch batch = new GenerationBatch ();
                                        batch.Maps = new XmlMapping[] {typeMapping};
                                        batch.Datas = new SerializerData[] {serializerData};
                                        GenerateSerializersAsync (batch);
                                }
                        }
                }
                
                void GenerateSerializersAsync (GenerationBatch batch)
                {
                        if (batch.Maps.Length != batch.Datas.Length)
                                throw new ArgumentException ("batch");

                        lock (batch)
                        {
                                if (batch.Done) return;
                                batch.Done = true;
                        }
                        
                        if (backgroundGeneration)
                                ThreadPool.QueueUserWorkItem (new WaitCallback (RunSerializerGeneration), batch);
                        else
                                RunSerializerGeneration (batch);
                }
                
                void RunSerializerGeneration (object obj)
                {
                        try
                        {
                                GenerationBatch batch = (GenerationBatch) obj;
                                batch = LoadFromSatelliteAssembly (batch);
                                
                                if (batch != null)
                                        GenerateSerializers (batch, null);
                        }
                        catch (Exception ex)
                        {
                                Console.WriteLine (ex);
                        }
                }
                
                static Assembly GenerateSerializers (GenerationBatch batch, CompilerParameters cp)
                {
                        DateTime tim = DateTime.Now;
                        
                        XmlMapping[] maps = batch.Maps;
                        
                        if (cp == null) {
                                cp = new CompilerParameters();
                                cp.IncludeDebugInformation = false;
                                cp.GenerateInMemory = true;
                                cp.TempFiles.KeepFiles = !deleteTempFiles;
                        }
                        
                        string file = cp.TempFiles.AddExtension ("cs");
                        StreamWriter sw = new StreamWriter (file);
                        
                        if (!deleteTempFiles)
                                Console.WriteLine ("Generating " + file);
                        
                        SerializationCodeGenerator gen = new SerializationCodeGenerator (maps);
                        
                        try
                        {
                                gen.GenerateSerializers (sw);
                        }
                        catch (Exception ex)
                        {
                                Console.WriteLine ("Serializer could not be generated");
                                Console.WriteLine (ex);
                                cp.TempFiles.Delete ();
                                return null;
                        }
                        sw.Close ();
                        
                        CSharpCodeProvider provider = new CSharpCodeProvider();
                        ICodeCompiler comp = provider.CreateCompiler ();
                        
                        cp.GenerateExecutable = false;
                        
                        foreach (Type rtype in gen.ReferencedTypes)
                        {
                                string path = new Uri (rtype.Assembly.CodeBase).LocalPath;
                                if (!cp.ReferencedAssemblies.Contains (path))
                                        cp.ReferencedAssemblies.Add (path);
                        }
                                
                        if (!cp.ReferencedAssemblies.Contains ("System.dll"))
                                cp.ReferencedAssemblies.Add ("System.dll");
                        if (!cp.ReferencedAssemblies.Contains ("System.Xml"))
                                cp.ReferencedAssemblies.Add ("System.Xml");
                        if (!cp.ReferencedAssemblies.Contains ("System.Data"))
                                cp.ReferencedAssemblies.Add ("System.Data");
                        if (!cp.ReferencedAssemblies.Contains ("System.Web.Services"))
                                cp.ReferencedAssemblies.Add ("System.Web.Services");
                        
                        CompilerResults res = comp.CompileAssemblyFromFile (cp, file);
                        if (res.Errors.HasErrors || res.CompiledAssembly == null) {
                                Console.WriteLine ("Error while compiling generated serializer");
                                foreach (CompilerError error in res.Errors)
                                        Console.WriteLine (error);
                                        
                                cp.TempFiles.Delete ();
                                return null;
                        }
                        
                        GenerationResult[] results = gen.GenerationResults;
                        for (int n=0; n<results.Length; n++)
                        {
                                GenerationResult gres = results[n];
                                SerializerData sd = batch.Datas [n];
                                lock (sd)
                                {
                                        sd.WriterType = res.CompiledAssembly.GetType (gres.Namespace + "." + gres.WriterClassName);
                                        sd.ReaderType = res.CompiledAssembly.GetType (gres.Namespace + "." + gres.ReaderClassName);
                                        sd.WriterMethod = sd.WriterType.GetMethod (gres.WriteMethodName);
                                        sd.ReaderMethod = sd.ReaderType.GetMethod (gres.ReadMethodName);
                                        sd.Batch = null;
                                }
                        }
                        
                        cp.TempFiles.Delete ();

                        if (!deleteTempFiles)
                                Console.WriteLine ("Generation finished - " + (DateTime.Now - tim).TotalMilliseconds + " ms");
                                
                        return res.CompiledAssembly;
                }
#endif
                
                GenerationBatch LoadFromSatelliteAssembly (GenerationBatch batch)
                {
                        return batch;
                }
                
#endregion // Methods
        }
}