using System.Xml;
using System.Xml.Schema;
using System.Text;
-#if !TARGET_JVM
+#if !NET_2_1
using System.CodeDom;
using System.CodeDom.Compiler;
using Microsoft.CSharp;
internal class SerializerData
{
public int UsageCount;
+ public bool Generated;
public Type ReaderType;
public MethodInfo ReaderMethod;
public Type WriterType;
// debugging pourposes by adding the "nofallback" option.
// For example: MONO_XMLSERIALIZER_THS=0,nofallback
-#if TARGET_JVM
+#if NET_2_1
string db = null;
string th = null;
generationThreshold = -1;
else {
generationThreshold = int.Parse (th, CultureInfo.InvariantCulture);
backgroundGeneration = (generationThreshold != 0);
- if (generationThreshold < 1) generationThreshold = 1;
}
}
#endif
deleteTempFiles = (db == null || db == "no");
-
+#if !NET_2_1
IDictionary table = (IDictionary) ConfigurationSettings.GetConfig("system.diagnostics");
if (table != null)
{
if (val == "1") deleteTempFiles = false;
}
}
+#endif
}
#region Constructors
get { return typeMapping; }
}
-#if NET_2_0
[MonoTODO]
public XmlSerializer (Type type,
Evidence evidence)
{
}
-#endif
#endregion // Constructors
#region Events
-
+ private UnreferencedObjectEventHandler onUnreferencedObject;
private XmlAttributeEventHandler onUnknownAttribute;
private XmlElementEventHandler onUnknownElement;
private XmlNodeEventHandler onUnknownNode;
- private UnreferencedObjectEventHandler onUnreferencedObject;
public event XmlAttributeEventHandler UnknownAttribute
{
add { onUnknownNode += value; } remove { onUnknownNode -= value; }
}
- public event UnreferencedObjectEventHandler UnreferencedObject
- {
- add { onUnreferencedObject += value; } remove { onUnreferencedObject -= value; }
- }
-
internal virtual void OnUnknownAttribute (XmlAttributeEventArgs e)
{
if (onUnreferencedObject != null) onUnreferencedObject(this, e);
}
+ public event UnreferencedObjectEventHandler UnreferencedObject
+ {
+ add { onUnreferencedObject += value; } remove { onUnreferencedObject -= value; }
+ }
#endregion // Events
try {
if (reader is XmlSerializationReaderInterpreter)
return ((XmlSerializationReaderInterpreter) reader).ReadRoot ();
- else
- return serializerData.ReaderMethod.Invoke (reader, null);
+ 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"
return sers;
}
- public static XmlSerializer [] FromTypes (Type [] mappings)
+ public static XmlSerializer [] FromTypes (Type [] types)
{
- XmlSerializer [] sers = new XmlSerializer [mappings.Length];
- for (int n=0; n<mappings.Length; n++)
- sers[n] = new XmlSerializer (mappings[n]);
+ XmlSerializer [] sers = new XmlSerializer [types.Length];
+ for (int n=0; n<types.Length; n++)
+ sers[n] = new XmlSerializer (types[n]);
return sers;
}
if (writer is XmlSerializationWriterInterpreter)
((XmlSerializationWriterInterpreter)writer).WriteRoot (o);
- else
- serializerData.WriterMethod.Invoke (writer, new object[] {o});
+ else {
+ try {
+ serializerData.WriterMethod.Invoke (writer, new object[] {o});
+ } catch (TargetInvocationException ex) {
+ throw ex.InnerException;
+ }
+ }
}
+ static Encoding DefaultEncoding = Encoding.Default;
+
public void Serialize (Stream stream, object o)
{
- XmlTextWriter xmlWriter = new XmlTextWriter (stream, System.Text.Encoding.Default);
+ XmlTextWriter xmlWriter = new XmlTextWriter (stream, DefaultEncoding);
xmlWriter.Formatting = Formatting.Indented;
Serialize (xmlWriter, o, null);
}
public void Serialize (Stream stream, object o, XmlSerializerNamespaces namespaces)
{
- XmlTextWriter xmlWriter = new XmlTextWriter (stream, System.Text.Encoding.Default);
+ XmlTextWriter xmlWriter = new XmlTextWriter (stream, DefaultEncoding);
xmlWriter.Formatting = Formatting.Indented;
Serialize (xmlWriter, o, namespaces);
}
xmlWriter.Flush();
}
- public void Serialize (XmlWriter writer, object o, XmlSerializerNamespaces namespaces)
+ public void Serialize (XmlWriter xmlWriter, object o, XmlSerializerNamespaces namespaces)
{
XmlSerializationWriter xsWriter;
if (namespaces == null || namespaces.Count == 0) {
namespaces = new XmlSerializerNamespaces ();
-#if NET_2_0
namespaces.Add ("xsi", XmlSchema.InstanceNamespace);
namespaces.Add ("xsd", XmlSchema.Namespace);
-#else
- namespaces.Add ("xsd", XmlSchema.Namespace);
- namespaces.Add ("xsi", XmlSchema.InstanceNamespace);
-#endif
}
- xsWriter.Initialize (writer, namespaces);
+ xsWriter.Initialize (xmlWriter, namespaces);
Serialize (o, xsWriter);
- writer.Flush ();
+ xmlWriter.Flush ();
} catch (Exception ex) {
if (ex is TargetInvocationException)
ex = ex.InnerException;
}
}
-#if NET_2_0
-
[MonoTODO]
public object Deserialize (XmlReader xmlReader, string encodingStyle, XmlDeserializationEvents events)
{
throw new NotImplementedException ();
}
-#if !TARGET_JVM
+#if !MOBILE
public static Assembly GenerateSerializer (Type[] types, XmlMapping[] mappings)
{
return GenerateSerializer (types, mappings, null);
{
throw new NotImplementedException ();
}
-#endif
XmlSerializationWriter CreateWriter (XmlMapping typeMapping)
{
}
}
+#if !NET_2_1
if (!typeMapping.Source.CanBeGenerated || generationThreshold == -1)
return new XmlSerializationWriterInterpreter (typeMapping);
throw new InvalidOperationException ("Error while generating serializer");
}
+#endif
return new XmlSerializationWriterInterpreter (typeMapping);
}
XmlSerializationReader CreateReader (XmlMapping typeMapping)
{
+#if !NET_2_1
XmlSerializationReader reader;
lock (this) {
if (!generatorFallback)
throw new InvalidOperationException ("Error while generating serializer");
}
-
+
+#endif
return new XmlSerializationReaderInterpreter (typeMapping);
}
-#if TARGET_JVM
+#if NET_2_1
void CheckGeneratedTypes (XmlMapping typeMapping)
{
throw new NotImplementedException();
bool generate = false;
lock (serializerData)
{
- generate = (++serializerData.UsageCount == generationThreshold);
+ if (serializerData.UsageCount >= generationThreshold && !serializerData.Generated)
+ serializerData.Generated = generate = true;
+
+ serializerData.UsageCount++;
}
if (generate)
foreach (Type rtype in gen.ReferencedTypes)
{
- if (!cp.ReferencedAssemblies.Contains (rtype.Assembly.Location))
- cp.ReferencedAssemblies.Add (rtype.Assembly.Location);
+ string path = new Uri (rtype.Assembly.CodeBase).LocalPath;
+ if (!cp.ReferencedAssemblies.Contains (path))
+ cp.ReferencedAssemblies.Add (path);
}
if (!cp.ReferencedAssemblies.Contains ("System.dll"))
}
#endif
-#if NET_2_0
- GenerationBatch LoadFromSatelliteAssembly (GenerationBatch batch)
- {
- return batch;
- }
-#else
GenerationBatch LoadFromSatelliteAssembly (GenerationBatch batch)
{
return batch;
}
-#endif
#endregion // Methods
}