mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 03:51:19 -10:00
* MapCodeGenerator.cs: Do not generate base class if it is an XmlNode. Generate types using GetDomType, so if the type is an array, it creates the correct combination of types. * SerializationCodeGenerator.cs, XmlTypeMapping.cs: When trying to parse an enum, if the string is empty and the enum has [Flags], then return 0 as value. This fixes bug #55509. * XmlSchemaImporter.cs: Added check for redefines of attribute groups. They are not supported. Another check: a simple type cannot be enum if it does not have any enum facet. And another fix: use string as default type for attribtues. * XmlSchemas.cs: Fixed search for schema elements. An schema may import other schemas. An imported schema would not be in the table, but its elements (although from another namespace) would be in the schema that imported it. So, we need know to check for every schema in the table. * XmlSerializer.cs: Added environment variable to help debugging code generator output. svn path=/trunk/mcs/; revision=23957
551 lines
14 KiB
C#
551 lines
14 KiB
C#
//
|
|
// XmlSerializer.cs:
|
|
//
|
|
// Author:
|
|
// Lluis Sanchez Gual ([email protected])
|
|
//
|
|
// (C) 2002, 2003 Ximian, Inc. http://www.ximian.com
|
|
//
|
|
|
|
using System;
|
|
using System.Threading;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
using System.Text;
|
|
using System.CodeDom;
|
|
using System.CodeDom.Compiler;
|
|
using Microsoft.CSharp;
|
|
using System.Configuration;
|
|
|
|
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/";
|
|
static int generationThreshold;
|
|
static bool backgroundGeneration = true;
|
|
static bool deleteTempFiles = true;
|
|
|
|
bool customSerializer;
|
|
XmlMapping typeMapping;
|
|
|
|
SerializerData serializerData;
|
|
Type writerType;
|
|
Type readerType;
|
|
|
|
static Hashtable serializerTypes = new Hashtable ();
|
|
|
|
internal class SerializerData
|
|
{
|
|
public int UsageCount;
|
|
public Type ReaderType;
|
|
public MethodInfo ReaderMethod;
|
|
public Type WriterType;
|
|
public MethodInfo WriterMethod;
|
|
public GenerationBatch Batch;
|
|
}
|
|
|
|
internal class GenerationBatch
|
|
{
|
|
public bool Done;
|
|
public XmlMapping[] Maps;
|
|
public SerializerData[] Datas;
|
|
}
|
|
|
|
static XmlSerializer ()
|
|
{
|
|
string db = Environment.GetEnvironmentVariable ("MONO_XMLSERIALIZER_DEBUG");
|
|
deleteTempFiles = (db == null || db == "no");
|
|
|
|
IDictionary table = (IDictionary) ConfigurationSettings.GetConfig("system.diagnostics");
|
|
if (table != null) {
|
|
table = (IDictionary) table["switches"];
|
|
if (table != null) {
|
|
string val = (string) table ["XmlSerialization.Compilation"];
|
|
if (val == "1") deleteTempFiles = false;
|
|
}
|
|
}
|
|
|
|
string th = Environment.GetEnvironmentVariable ("MONO_XMLSERIALIZER_THS");
|
|
|
|
if (th == null) {
|
|
generationThreshold = -1;
|
|
backgroundGeneration = false;
|
|
}
|
|
else if (th.ToLower() == "no")
|
|
generationThreshold = -1;
|
|
else {
|
|
generationThreshold = int.Parse (th);
|
|
backgroundGeneration = (generationThreshold != 0);
|
|
if (generationThreshold < 1) generationThreshold = 1;
|
|
}
|
|
}
|
|
|
|
#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)
|
|
: 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);
|
|
}
|
|
|
|
|
|
#endregion // Constructors
|
|
|
|
#region Events
|
|
|
|
private XmlAttributeEventHandler onUnknownAttribute;
|
|
private XmlElementEventHandler onUnknownElement;
|
|
private XmlNodeEventHandler onUnknownNode;
|
|
private UnreferencedObjectEventHandler onUnreferencedObject;
|
|
|
|
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; }
|
|
}
|
|
|
|
public event UnreferencedObjectEventHandler UnreferencedObject
|
|
{
|
|
add { onUnreferencedObject += value; } remove { onUnreferencedObject -= 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);
|
|
}
|
|
|
|
|
|
#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);
|
|
return Deserialize(xmlReader);
|
|
}
|
|
|
|
public object Deserialize (TextReader textReader)
|
|
{
|
|
XmlTextReader xmlReader = new XmlTextReader(textReader);
|
|
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 ();
|
|
|
|
if (reader is XmlSerializationReaderInterpreter)
|
|
return ((XmlSerializationReaderInterpreter)reader).ReadRoot ();
|
|
else
|
|
return serializerData.ReaderMethod.Invoke (reader, null);
|
|
}
|
|
|
|
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 [] mappings)
|
|
{
|
|
XmlSerializer [] sers = new XmlSerializer [mappings.Length];
|
|
for (int n=0; n<mappings.Length; n++)
|
|
sers[n] = new XmlSerializer (mappings[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
|
|
serializerData.WriterMethod.Invoke (writer, new object[] {o});
|
|
}
|
|
|
|
public void Serialize (Stream stream, object o)
|
|
{
|
|
XmlTextWriter xmlWriter = new XmlTextWriter (stream, System.Text.Encoding.Default);
|
|
xmlWriter.Formatting = Formatting.Indented;
|
|
Serialize (xmlWriter, 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, System.Text.Encoding.Default);
|
|
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 writer, object o, XmlSerializerNamespaces namespaces)
|
|
{
|
|
XmlSerializationWriter xsWriter;
|
|
|
|
if (customSerializer)
|
|
xsWriter = CreateWriter ();
|
|
else
|
|
xsWriter = CreateWriter (typeMapping);
|
|
|
|
if (namespaces == null || namespaces.Count == 0)
|
|
{
|
|
namespaces = new XmlSerializerNamespaces ();
|
|
namespaces.Add ("xsd", XmlSchema.Namespace);
|
|
namespaces.Add ("xsi", XmlSchema.InstanceNamespace);
|
|
}
|
|
|
|
xsWriter.Initialize (writer, namespaces);
|
|
Serialize (o, xsWriter);
|
|
writer.Flush ();
|
|
}
|
|
|
|
XmlSerializationWriter CreateWriter (XmlMapping typeMapping)
|
|
{
|
|
lock (this) {
|
|
if (serializerData != null && serializerData.WriterType != null)
|
|
return (XmlSerializationWriter) Activator.CreateInstance (serializerData.WriterType);
|
|
}
|
|
|
|
if (!typeMapping.Source.CanBeGenerated || generationThreshold == -1)
|
|
return new XmlSerializationWriterInterpreter (typeMapping);
|
|
|
|
CheckGeneratedTypes (typeMapping);
|
|
|
|
lock (this) {
|
|
if (serializerData.WriterType != null)
|
|
return (XmlSerializationWriter) Activator.CreateInstance (serializerData.WriterType);
|
|
}
|
|
|
|
return new XmlSerializationWriterInterpreter (typeMapping);
|
|
}
|
|
|
|
XmlSerializationReader CreateReader (XmlMapping typeMapping)
|
|
{
|
|
lock (this) {
|
|
if (serializerData != null && serializerData.ReaderType != null)
|
|
return (XmlSerializationReader) Activator.CreateInstance (serializerData.ReaderType);
|
|
}
|
|
|
|
if (!typeMapping.Source.CanBeGenerated || generationThreshold == -1)
|
|
return new XmlSerializationReaderInterpreter (typeMapping);
|
|
|
|
CheckGeneratedTypes (typeMapping);
|
|
|
|
lock (this) {
|
|
if (serializerData.ReaderType != null)
|
|
return (XmlSerializationReader) Activator.CreateInstance (serializerData.ReaderType);
|
|
}
|
|
|
|
return new XmlSerializationReaderInterpreter (typeMapping);
|
|
}
|
|
|
|
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)
|
|
{
|
|
generate = (++serializerData.UsageCount == generationThreshold);
|
|
}
|
|
|
|
if (generate)
|
|
{
|
|
if (serializerData.Batch != null)
|
|
GenerateSerializers (serializerData.Batch);
|
|
else
|
|
{
|
|
GenerationBatch batch = new GenerationBatch ();
|
|
batch.Maps = new XmlMapping[] {typeMapping};
|
|
batch.Datas = new SerializerData[] {serializerData};
|
|
GenerateSerializers (batch);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GenerateSerializers (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
|
|
{
|
|
RunSerializerGenerationAux (obj);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Console.WriteLine (ex);
|
|
}
|
|
}
|
|
|
|
void RunSerializerGenerationAux (object obj)
|
|
{
|
|
DateTime tim = DateTime.Now;
|
|
|
|
GenerationBatch batch = (GenerationBatch) obj;
|
|
XmlMapping[] maps = batch.Maps;
|
|
|
|
string file = Path.GetTempFileName ();
|
|
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);
|
|
|
|
if (deleteTempFiles)
|
|
File.Delete (file);
|
|
return;
|
|
}
|
|
sw.Close ();
|
|
|
|
CSharpCodeProvider provider = new CSharpCodeProvider();
|
|
ICodeCompiler comp = provider.CreateCompiler ();
|
|
|
|
CompilerParameters cp = new CompilerParameters();
|
|
cp.GenerateExecutable = false;
|
|
cp.IncludeDebugInformation = false;
|
|
cp.GenerateInMemory = true;
|
|
cp.ReferencedAssemblies.Add ("System.dll");
|
|
cp.ReferencedAssemblies.Add ("System.Xml");
|
|
|
|
foreach (Type rtype in gen.ReferencedTypes)
|
|
{
|
|
if (!cp.ReferencedAssemblies.Contains (rtype.Assembly.Location))
|
|
cp.ReferencedAssemblies.Add (rtype.Assembly.Location);
|
|
}
|
|
|
|
CompilerResults res = comp.CompileAssemblyFromFile (cp, file);
|
|
if (res.Errors.Count > 0)
|
|
{
|
|
Console.WriteLine ("Error while compiling generated serializer");
|
|
foreach (CompilerError error in res.Errors)
|
|
Console.WriteLine (error);
|
|
|
|
if (deleteTempFiles)
|
|
File.Delete (file);
|
|
return;
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
if (deleteTempFiles)
|
|
File.Delete (file);
|
|
|
|
if (!deleteTempFiles)
|
|
Console.WriteLine ("Generation finished - " + (DateTime.Now - tim).TotalMilliseconds + " ms");
|
|
}
|
|
|
|
#endregion // Methods
|
|
}
|
|
}
|