private void GenerateGetSerializer(Hashtable serializers, XmlMapping[] xmlMappings)
{
this.writer.Write("public override ");
this.writer.Write(typeof(XmlSerializer).FullName);
this.writer.Write(" GetSerializer(");
this.writer.Write(typeof(Type).FullName);
this.writer.WriteLine(" type) {");
this.writer.Indent++;
for (int i = 0; i < xmlMappings.Length; i++)
{
if (xmlMappings[i] is XmlTypeMapping)
{
Type type = xmlMappings[i].Accessor.Mapping.TypeDesc.Type;
if (((type != null) && (type.IsPublic || type.IsNestedPublic)) && ((!DynamicAssemblies.IsTypeDynamic(type) && !type.IsGenericType) && (!type.ContainsGenericParameters || !DynamicAssemblies.IsTypeDynamic(type.GetGenericArguments()))))
{
this.writer.Write("if (type == typeof(");
this.writer.Write(CodeIdentifier.GetCSharpName(type));
this.writer.Write(")) return new ");
this.writer.Write((string) serializers[xmlMappings[i].Key]);
this.writer.WriteLine("();");
}
}
}
this.writer.WriteLine("return null;");
this.writer.Indent--;
this.writer.WriteLine("}");
}
internal TempAssembly(XmlMapping[] xmlMappings, Assembly assembly, XmlSerializerImplementation contract)
{
this.assemblies = new Hashtable();
this.assembly = assembly;
this.InitAssemblyMethods(xmlMappings);
this.contract = contract;
this.pregeneratedAssmbly = true;
}
internal static bool IsShallow(XmlMapping[] mappings)
{
for (int i = 0; i < mappings.Length; i++)
{
if ((mappings[i] == null) || mappings[i].shallow)
{
return true;
}
}
return false;
}
internal TempAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, string location, Evidence evidence) {
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
TempFileCollection tempFiles = new TempFileCollection(location);
parameters.TempFiles = tempFiles;
assembly = GenerateAssembly(xmlMappings, types, defaultNamespace, evidence, parameters, null, assemblies);
#if DEBUG
// use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe
if (assembly == null) throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Failed to generate XmlSerializer assembly, but did not throw"));
#endif
InitAssemblyMethods(xmlMappings);
}
internal string GenerateElement(XmlMapping xmlMapping) {
if (!xmlMapping.IsWriteable)
return null;
if (!xmlMapping.GenerateSerializer)
throw new ArgumentException(Res.GetString(Res.XmlInternalError), "xmlMapping");
if (xmlMapping is XmlTypeMapping)
return GenerateTypeElement((XmlTypeMapping)xmlMapping);
else if (xmlMapping is XmlMembersMapping)
return GenerateMembersElement((XmlMembersMapping)xmlMapping);
else
throw new ArgumentException(Res.GetString(Res.XmlInternalError), "xmlMapping");
}
internal bool CanRead(XmlMapping mapping, XmlReader xmlReader)
{
if (mapping == null)
{
return false;
}
if (mapping.Accessor.Any)
{
return true;
}
TempMethod method = this.methods[mapping.Key];
return xmlReader.IsStartElement(method.name, method.ns);
}
internal bool CanRead(XmlMapping mapping, XmlReader xmlReader)
{
if (mapping == null)
{
return(false);
}
if (mapping.Accessor.Any)
{
return(true);
}
TempMethod method = _methods[mapping.Key];
return(xmlReader.IsStartElement(method.name, method.ns));
}
internal static TempAssembly?GenerateTempAssembly(XmlMapping xmlMapping, Type?type, string?defaultNamespace, string?location)
{
if (xmlMapping == null)
{
throw new ArgumentNullException(nameof(xmlMapping));
}
xmlMapping.CheckShallow();
if (xmlMapping.IsSoap)
{
return(null);
}
return(new TempAssembly(new XmlMapping[] { xmlMapping }, new Type?[] { type }, defaultNamespace, location));
}
private static XmlSerializer[] GetSerializersFromCache(XmlMapping[] mappings, Type type)
{
XmlSerializer[] serializerArray = new XmlSerializer[mappings.Length];
Hashtable hashtable = null;
lock (xmlSerializerTable)
{
hashtable = xmlSerializerTable[type] as Hashtable;
if (hashtable == null)
{
hashtable = new Hashtable();
xmlSerializerTable[type] = hashtable;
}
}
lock (hashtable)
{
Hashtable hashtable2 = new Hashtable();
for (int i = 0; i < mappings.Length; i++)
{
XmlSerializerMappingKey key = new XmlSerializerMappingKey(mappings[i]);
serializerArray[i] = hashtable[key] as XmlSerializer;
if (serializerArray[i] == null)
{
hashtable2.Add(key, i);
}
}
if (hashtable2.Count <= 0)
{
return(serializerArray);
}
XmlMapping[] xmlMappings = new XmlMapping[hashtable2.Count];
int index = 0;
foreach (XmlSerializerMappingKey key2 in hashtable2.Keys)
{
xmlMappings[index++] = key2.Mapping;
}
TempAssembly tempAssembly = new TempAssembly(xmlMappings, new Type[] { type }, null, null, null);
XmlSerializerImplementation contract = tempAssembly.Contract;
foreach (XmlSerializerMappingKey key3 in hashtable2.Keys)
{
index = (int)hashtable2[key3];
serializerArray[index] = (XmlSerializer)contract.TypedSerializers[key3.Mapping.Key];
serializerArray[index].SetTempAssembly(tempAssembly, key3.Mapping);
hashtable[key3] = serializerArray[index];
}
}
return(serializerArray);
}
/// <include file='doc\SoapReflectionImporter.uex' path='docs/doc[@for="XmlReflectionImporter.ImportTypeMapping1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlTypeMapping ImportTypeMapping(Type type, string defaultNamespace)
{
ElementAccessor element = new ElementAccessor();
element.IsSoap = true;
element.Mapping = ImportTypeMapping(_modelScope.GetTypeModel(type), new RecursionLimiter());
element.Name = element.Mapping.DefaultElementName;
element.Namespace = element.Mapping.Namespace == null ? defaultNamespace : element.Mapping.Namespace;
element.Form = XmlSchemaForm.Qualified;
XmlTypeMapping xmlMapping = new XmlTypeMapping(_typeScope, element);
xmlMapping.SetKeyInternal(XmlMapping.GenerateKey(type, null, defaultNamespace));
xmlMapping.IsSoap = true;
xmlMapping.GenerateSerializer = true;
return(xmlMapping);
}
/// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlSerializer(Type type, string defaultNamespace)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
#if NET_NATIVE
rootType = type;
#endif
_mapping = GetKnownMapping(type, defaultNamespace);
if (_mapping != null)
{
_primitiveType = type;
return;
}
#if !NET_NATIVE
_tempAssembly = s_cache[defaultNamespace, type];
if (_tempAssembly == null)
{
lock (s_cache)
{
_tempAssembly = s_cache[defaultNamespace, type];
if (_tempAssembly == null)
{
{
// need to reflect and generate new serialization assembly
XmlReflectionImporter importer = new XmlReflectionImporter(defaultNamespace);
_mapping = importer.ImportTypeMapping(type, null, defaultNamespace);
_tempAssembly = GenerateTempAssembly(_mapping, type, defaultNamespace);
}
}
s_cache.Add(defaultNamespace, type, _tempAssembly);
}
}
if (_mapping == null)
{
_mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
}
#else
XmlSerializerImplementation contract = GetXmlSerializerContractFromGeneratedAssembly();
if (contract != null)
{
this.innerSerializer = contract.GetSerializer(type);
}
#endif
}
/// <summary>Initializes a new instance of the <see cref="T:System.Xml.Serialization.XmlSerializer" /> class that can serialize objects of type <see cref="T:System.Object" /> into XML document instances, and deserialize XML document instances into objects of type <see cref="T:System.Object" />. Each object to be serialized can itself contain instances of classes, which this overload overrides with other classes. This overload also specifies the default namespace for all the XML elements and the class to use as the XML root element.</summary>
/// <param name="type">The type of the object that this <see cref="T:System.Xml.Serialization.XmlSerializer" /> can serialize. </param>
/// <param name="overrides">An <see cref="T:System.Xml.Serialization.XmlAttributeOverrides" /> that extends or overrides the behavior of the class specified in the <paramref name="type" /> parameter. </param>
/// <param name="extraTypes">A <see cref="T:System.Type" /> array of additional object types to serialize. </param>
/// <param name="root">An <see cref="T:System.Xml.Serialization.XmlRootAttribute" /> that defines the XML root element properties. </param>
/// <param name="defaultNamespace">The default namespace of all XML elements in the XML document. </param>
public XmlSerializer(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
XmlReflectionImporter xmlReflectionImporter = new XmlReflectionImporter(overrides, defaultNamespace);
if (extraTypes != null)
{
foreach (Type type2 in extraTypes)
{
xmlReflectionImporter.IncludeType(type2);
}
}
this.typeMapping = xmlReflectionImporter.ImportTypeMapping(type, root, defaultNamespace);
}
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);
}
}
}
public ReflectionXmlSerializationWriter(XmlMapping xmlMapping, XmlWriter xmlWriter, XmlSerializerNamespaces namespaces, string encodingStyle, string id)
{
Init(xmlWriter, namespaces, encodingStyle, id, null);
if (!xmlMapping.IsWriteable || !xmlMapping.GenerateSerializer)
{
throw new ArgumentException(SR.Format(SR.XmlInternalError, "xmlMapping"));
}
if (xmlMapping is XmlTypeMapping || xmlMapping is XmlMembersMapping)
{
_mapping = xmlMapping;
}
else
{
throw new ArgumentException(SR.Format(SR.XmlInternalError, "xmlMapping"));
}
}
internal XmlMembersMapping(TypeScope scope, ElementAccessor accessor, XmlMappingAccess access) : base(scope, accessor, access)
{
MembersMapping mapping = (MembersMapping)accessor.Mapping;
StringBuilder builder = new StringBuilder();
builder.Append(":");
this.mappings = new XmlMemberMapping[mapping.Members.Length];
for (int i = 0; i < this.mappings.Length; i++)
{
if (mapping.Members[i].TypeDesc.Type != null)
{
builder.Append(XmlMapping.GenerateKey(mapping.Members[i].TypeDesc.Type, null, null));
builder.Append(":");
}
this.mappings[i] = new XmlMemberMapping(mapping.Members[i]);
}
base.SetKeyInternal(builder.ToString());
}
public XmlTypeMapping ImportTypeMapping(Type type, string defaultNamespace)
{
ElementAccessor accessor;
accessor = new ElementAccessor {
IsSoap = true,
Mapping = this.ImportTypeMapping(this.modelScope.GetTypeModel(type), new RecursionLimiter()),
Name = accessor.Mapping.DefaultElementName,
Namespace = (accessor.Mapping.Namespace == null) ? defaultNamespace : accessor.Mapping.Namespace,
Form = XmlSchemaForm.Qualified
};
XmlTypeMapping mapping = new XmlTypeMapping(this.typeScope, accessor);
mapping.SetKeyInternal(XmlMapping.GenerateKey(type, null, defaultNamespace));
mapping.IsSoap = true;
mapping.GenerateSerializer = true;
return(mapping);
}
public ReflectionXmlSerializationWriter(XmlMapping xmlMapping, XmlWriter xmlWriter, XmlSerializerNamespaces namespaces, string encodingStyle, string id)
{
Init(xmlWriter, namespaces, encodingStyle, id, null);
if (!xmlMapping.IsWriteable || !xmlMapping.GenerateSerializer)
{
throw new ArgumentException(SR.Format(SR.XmlInternalError, nameof(xmlMapping)));
}
if (xmlMapping is XmlTypeMapping || xmlMapping is XmlMembersMapping)
{
_mapping = xmlMapping;
}
else
{
throw new ArgumentException(SR.Format(SR.XmlInternalError, nameof(xmlMapping)));
}
}
/// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlSerializer(Type type, string defaultNamespace)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
this.mapping = GetKnownMapping(type, defaultNamespace);
if (this.mapping != null)
{
this.primitiveType = type;
return;
}
tempAssembly = cache[defaultNamespace, type];
if (tempAssembly == null)
{
lock (cache) {
tempAssembly = cache[defaultNamespace, type];
if (tempAssembly == null)
{
XmlSerializerImplementation contract;
Assembly assembly = TempAssembly.LoadGeneratedAssembly(type, defaultNamespace, out contract);
if (assembly == null)
{
// need to reflect and generate new serialization assembly
XmlReflectionImporter importer = new XmlReflectionImporter(defaultNamespace);
this.mapping = importer.ImportTypeMapping(type, null, defaultNamespace);
tempAssembly = GenerateTempAssembly(this.mapping, type, defaultNamespace);
}
else
{
// we found the pre-generated assembly, now make sure that the assembly has the right serializer
// try to avoid the reflection step, need to get ElementName, namespace and the Key form the type
this.mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
tempAssembly = new TempAssembly(new XmlMapping[] { this.mapping }, assembly, contract);
}
}
cache.Add(defaultNamespace, type, tempAssembly);
}
}
if (mapping == null)
{
mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
}
}
XmlSerializationReader CreateReader(XmlMapping typeMapping)
{
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");
}
}
return(new XmlSerializationReaderInterpreter(typeMapping));
}
public XmlSerializer(Type type, string defaultNamespace)
{
this.events = new XmlDeserializationEvents();
if (type == null)
{
throw new ArgumentNullException("type");
}
this.mapping = GetKnownMapping(type, defaultNamespace);
if (this.mapping != null)
{
this.primitiveType = type;
}
else
{
this.tempAssembly = cache[defaultNamespace, type];
if (this.tempAssembly == null)
{
lock (cache)
{
this.tempAssembly = cache[defaultNamespace, type];
if (this.tempAssembly == null)
{
XmlSerializerImplementation implementation;
Assembly assembly = TempAssembly.LoadGeneratedAssembly(type, defaultNamespace, out implementation);
if (assembly == null)
{
this.mapping = new XmlReflectionImporter(defaultNamespace).ImportTypeMapping(type, null, defaultNamespace);
this.tempAssembly = GenerateTempAssembly(this.mapping, type, defaultNamespace);
}
else
{
this.mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
this.tempAssembly = new TempAssembly(new XmlMapping[] { this.mapping }, assembly, implementation);
}
}
cache.Add(defaultNamespace, type, this.tempAssembly);
}
}
if (this.mapping == null)
{
this.mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
}
}
}
internal static bool GenerateSerializer(Type[] types, XmlMapping[] mappings, Stream stream)
{
if (types == null || types.Length == 0)
{
return(false);
}
if (mappings == null)
{
throw new ArgumentNullException(nameof(mappings));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (XmlMapping.IsShallow(mappings))
{
throw new InvalidOperationException(SR.XmlMelformMapping);
}
Assembly assembly = null;
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (DynamicAssemblies.IsTypeDynamic(type))
{
throw new InvalidOperationException(SR.Format(SR.XmlPregenTypeDynamic, type.FullName));
}
if (assembly == null)
{
assembly = type.Assembly;
}
else if (type.Assembly != assembly)
{
throw new ArgumentException(SR.Format(SR.XmlPregenOrphanType, type.FullName, assembly.Location), nameof(types));
}
}
return(TempAssembly.GenerateSerializerToStream(mappings, types, null, assembly, new Hashtable(), stream));
}
public override object[] GetInitializers (LogicalMethodInfo[] methodInfos)
{
XmlReflectionImporter importer = new XmlReflectionImporter ();
XmlMapping[] sers = new XmlMapping [methodInfos.Length];
for (int n=0; n<sers.Length; n++)
{
LogicalMethodInfo metinfo = methodInfos[n];
if (metinfo.IsVoid)
sers[n] = null;
else
{
LogicalTypeInfo sti = TypeStubManager.GetLogicalTypeInfo (metinfo.DeclaringType);
object[] ats = methodInfos[n].ReturnTypeCustomAttributeProvider.GetCustomAttributes (typeof(XmlRootAttribute), true);
XmlRootAttribute root = ats.Length > 0 ? ats[0] as XmlRootAttribute : null;
sers[n] = importer.ImportTypeMapping (methodInfos[n].ReturnType, root, sti.GetWebServiceLiteralNamespace (sti.WebServiceNamespace));
}
}
return XmlSerializer.FromMappings (sers);
}
/// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer7"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
internal XmlSerializer(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace, object location, object evidence)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
XmlReflectionImporter importer = new XmlReflectionImporter(overrides, defaultNamespace);
if (extraTypes != null)
{
for (int i = 0; i < extraTypes.Length; i++)
{
importer.IncludeType(extraTypes[i]);
}
}
_mapping = importer.ImportTypeMapping(type, root, defaultNamespace);
_tempAssembly = GenerateTempAssembly(_mapping, type, defaultNamespace);
}
private XmlSerializationReader CreateReader(XmlMapping typeMapping)
{
lock (this)
{
if (this.serializerData != null)
{
XmlSerializer.SerializerData obj = this.serializerData;
XmlSerializationReader xmlSerializationReader;
lock (obj)
{
xmlSerializationReader = this.serializerData.CreateReader();
}
if (xmlSerializationReader != null)
{
return(xmlSerializationReader);
}
}
}
if (!typeMapping.Source.CanBeGenerated || XmlSerializer.generationThreshold == -1)
{
return(new XmlSerializationReaderInterpreter(typeMapping));
}
this.CheckGeneratedTypes(typeMapping);
lock (this)
{
XmlSerializer.SerializerData obj2 = this.serializerData;
XmlSerializationReader xmlSerializationReader;
lock (obj2)
{
xmlSerializationReader = this.serializerData.CreateReader();
}
if (xmlSerializationReader != null)
{
return(xmlSerializationReader);
}
if (!XmlSerializer.generatorFallback)
{
throw new InvalidOperationException("Error while generating serializer");
}
}
return(new XmlSerializationReaderInterpreter(typeMapping));
}
public static XmlSerializer[] FromMappings(XmlMapping[] mappings, Evidence evidence)
{
if (mappings == null || mappings.Length == 0)
{
return(new XmlSerializer[0]);
}
if (XmlMapping.IsShallow(mappings))
{
return(new XmlSerializer[0]);
}
TempAssembly tempAssembly = new TempAssembly(mappings, new Type[0], null, null, evidence);
XmlSerializerImplementation contract = tempAssembly.Contract;
XmlSerializer[] serializers = new XmlSerializer[mappings.Length];
for (int i = 0; i < serializers.Length; i++)
{
serializers[i] = (XmlSerializer)contract.TypedSerializers[mappings[i].Key];
}
return(serializers);
}
static XmlTypeMapping GetKnownMapping(Type type, string ns)
{
if (ns != null && ns != string.Empty)
{
return(null);
}
TypeDesc typeDesc = (TypeDesc)TypeScope.PrimtiveTypes[type];
if (typeDesc == null)
{
return(null);
}
ElementAccessor element = new ElementAccessor();
element.Name = typeDesc.DataType.Name;
XmlTypeMapping mapping = new XmlTypeMapping(null, element);
mapping.SetKeyInternal(XmlMapping.GenerateKey(type, null, null));
return(mapping);
}
private static XmlTypeMapping GetKnownMapping(Type type, string ns)
{
if ((ns != null) && (ns != string.Empty))
{
return(null);
}
TypeDesc desc = (TypeDesc)TypeScope.PrimtiveTypes[type];
if (desc == null)
{
return(null);
}
ElementAccessor accessor = new ElementAccessor {
Name = desc.DataType.Name
};
XmlTypeMapping mapping = new XmlTypeMapping(null, accessor);
mapping.SetKeyInternal(XmlMapping.GenerateKey(type, null, null));
return(mapping);
}
public XmlSerializer(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace, string location, Evidence evidence)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
XmlReflectionImporter importer = new XmlReflectionImporter(overrides, defaultNamespace);
if (extraTypes != null)
{
for (int i = 0; i < extraTypes.Length; i++)
{
importer.IncludeType(extraTypes[i]);
}
}
this.mapping = importer.ImportTypeMapping(type, root, defaultNamespace);
if (location != null || evidence != null)
{
DemandForUserLocationOrEvidence();
}
tempAssembly = GenerateTempAssembly(this.mapping, type, defaultNamespace, location, evidence);
}
public static XmlSerializer[] FromMappings(XmlMapping[] mappings, Type type)
{
if (mappings == null || mappings.Length == 0)
{
return(new XmlSerializer[0]);
}
XmlSerializerImplementation contract = null;
Assembly assembly = type == null ? null : TempAssembly.LoadGeneratedAssembly(type, null, out contract);
TempAssembly tempAssembly = null;
if (assembly == null)
{
if (XmlMapping.IsShallow(mappings))
{
return(new XmlSerializer[0]);
}
else
{
tempAssembly = new TempAssembly(mappings, new Type[] { type }, null, null, null);
XmlSerializer[] serializers = new XmlSerializer[mappings.Length];
contract = tempAssembly.Contract;
for (int i = 0; i < serializers.Length; i++)
{
serializers[i] = (XmlSerializer)contract.TypedSerializers[mappings[i].Key];
serializers[i].SetTempAssembly(tempAssembly, mappings[i]);
}
return(serializers);
}
}
else
{
XmlSerializer[] serializers = new XmlSerializer[mappings.Length];
for (int i = 0; i < serializers.Length; i++)
{
serializers[i] = (XmlSerializer)contract.TypedSerializers[mappings[i].Key];
}
return(serializers);
}
}
/// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.FromMappings1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static XmlSerializer[] FromMappings(XmlMapping[] mappings, Type type)
{
if (mappings == null || mappings.Length == 0)
{
return(new XmlSerializer[0]);
}
XmlSerializerImplementation contract = null;
TempAssembly tempAssembly = null;
{
if (XmlMapping.IsShallow(mappings))
{
return(new XmlSerializer[0]);
}
else
{
if (type == null)
{
tempAssembly = new TempAssembly(mappings, new Type[] { type }, null, null, null);
XmlSerializer[] serializers = new XmlSerializer[mappings.Length];
contract = tempAssembly.Contract;
for (int i = 0; i < serializers.Length; i++)
{
serializers[i] = (XmlSerializer)contract.XmlTypedSerializers[mappings[i].Key];
serializers[i].SetTempAssembly(tempAssembly, mappings[i]);
}
return(serializers);
}
else
{
// Use XmlSerializer cache when the type is not null.
return(GetSerializersFromCache(mappings, type));
}
}
}
}
internal object InvokeReader(XmlMapping mapping, XmlReader xmlReader, XmlDeserializationEvents events, string encodingStyle)
{
XmlSerializationReader reader = null;
object obj2;
try
{
encodingStyle = this.ValidateEncodingStyle(encodingStyle, mapping.Key);
reader = this.Contract.Reader;
reader.Init(xmlReader, events, encodingStyle, this);
if (this.methods[mapping.Key].readMethod == null)
{
if (this.readerMethods == null)
{
this.readerMethods = this.Contract.ReadMethods;
}
string methodName = (string) this.readerMethods[mapping.Key];
if (methodName == null)
{
throw new InvalidOperationException(Res.GetString("XmlNotSerializable", new object[] { mapping.Accessor.Name }));
}
this.methods[mapping.Key].readMethod = GetMethodFromType(reader.GetType(), methodName, this.pregeneratedAssmbly ? this.assembly : null);
}
obj2 = this.methods[mapping.Key].readMethod.Invoke(reader, emptyObjectArray);
}
catch (SecurityException exception)
{
throw new InvalidOperationException(Res.GetString("XmlNoPartialTrust"), exception);
}
finally
{
if (reader != null)
{
reader.Dispose();
}
}
return obj2;
}
public static Assembly GenerateSerializer(Type[] types, XmlMapping[] mappings, CompilerParameters parameters)
{
if (types == null || types.Length == 0)
{
return(null);
}
if (mappings == null)
{
throw new ArgumentNullException("mappings");
}
if (XmlMapping.IsShallow(mappings))
{
throw new InvalidOperationException(Res.GetString(Res.XmlMelformMapping));
}
Assembly assembly = null;
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (DynamicAssemblies.IsTypeDynamic(type))
{
throw new InvalidOperationException(Res.GetString(Res.XmlPregenTypeDynamic, type.FullName));
}
if (assembly == null)
{
assembly = type.Assembly;
}
else if (type.Assembly != assembly)
{
throw new ArgumentException(Res.GetString(Res.XmlPregenOrphanType, type.FullName, assembly.Location), "types");
}
}
return(TempAssembly.GenerateAssembly(mappings, types, null, null, XmlSerializerCompilerParameters.Create(parameters, /* needTempDirAccess = */ true), assembly, new Hashtable()));
}
public static XmlSerializer[] FromMappings(XmlMapping[] mappings, Type type)
{
if ((mappings == null) || (mappings.Length == 0))
{
return(new XmlSerializer[0]);
}
XmlSerializerImplementation contract = null;
Assembly assembly = (type == null) ? null : TempAssembly.LoadGeneratedAssembly(type, null, out contract);
TempAssembly tempAssembly = null;
if (assembly == null)
{
if (XmlMapping.IsShallow(mappings))
{
return(new XmlSerializer[0]);
}
if (type != null)
{
return(GetSerializersFromCache(mappings, type));
}
tempAssembly = new TempAssembly(mappings, new Type[] { type }, null, null, null);
XmlSerializer[] serializerArray = new XmlSerializer[mappings.Length];
contract = tempAssembly.Contract;
for (int j = 0; j < serializerArray.Length; j++)
{
serializerArray[j] = (XmlSerializer)contract.TypedSerializers[mappings[j].Key];
serializerArray[j].SetTempAssembly(tempAssembly, mappings[j]);
}
return(serializerArray);
}
XmlSerializer[] serializerArray2 = new XmlSerializer[mappings.Length];
for (int i = 0; i < serializerArray2.Length; i++)
{
serializerArray2[i] = (XmlSerializer)contract.TypedSerializers[mappings[i].Key];
}
return(serializerArray2);
}
internal TempAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, string location, Evidence evidence) {
bool containsSoapMapping = false;
for (int i = 0; i < xmlMappings.Length; i++) {
xmlMappings[i].CheckShallow();
if (xmlMappings[i].IsSoap) {
containsSoapMapping = true;
}
}
// We will make best effort to use RefEmit for assembly generation
bool fallbackToCSharpAssemblyGeneration = false;
if (!containsSoapMapping && !TempAssembly.UseLegacySerializerGeneration) {
try {
assembly = GenerateRefEmitAssembly(xmlMappings, types, defaultNamespace, evidence);
}
// Only catch and handle known failures with RefEmit
catch (CodeGeneratorConversionException) {
fallbackToCSharpAssemblyGeneration = true;
}
// Add other known exceptions here...
//
}
else {
fallbackToCSharpAssemblyGeneration = true;
}
if (fallbackToCSharpAssemblyGeneration) {
assembly = GenerateAssembly(xmlMappings, types, defaultNamespace, evidence, XmlSerializerCompilerParameters.Create(location), null, assemblies);
}
#if DEBUG
// use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe
if (assembly == null) throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Failed to generate XmlSerializer assembly, but did not throw"));
#endif
InitAssemblyMethods(xmlMappings);
}
private void Init(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace, object location, object evidence)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
DefaultNamespace = defaultNamespace;
rootType = type;
XmlReflectionImporter importer = new XmlReflectionImporter(overrides, defaultNamespace);
if (extraTypes != null)
{
for (int i = 0; i < extraTypes.Length; i++)
{
importer.IncludeType(extraTypes[i]);
}
}
_mapping = importer.ImportTypeMapping(type, root, defaultNamespace);
#if !NET_NATIVE
_tempAssembly = GenerateTempAssembly(_mapping, type, defaultNamespace);
#endif
}
internal void InvokeWriter(XmlMapping mapping, XmlWriter xmlWriter, object o, XmlSerializerNamespaces namespaces, string encodingStyle, string id)
{
XmlSerializationWriter writer = null;
try
{
encodingStyle = ValidateEncodingStyle(encodingStyle, mapping.Key);
writer = Contract.Writer;
writer.Init(xmlWriter, namespaces, encodingStyle, id, this);
if (_methods[mapping.Key].writeMethod == null)
{
if (_writerMethods == null)
{
_writerMethods = Contract.WriteMethods;
}
string methodName = (string)_writerMethods[mapping.Key];
if (methodName == null)
{
throw new InvalidOperationException(SR.Format(SR.XmlNotSerializable, mapping.Accessor.Name));
}
_methods[mapping.Key].writeMethod = GetMethodFromType(writer.GetType(), methodName);
}
_methods[mapping.Key].writeMethod.Invoke(writer, new object[] { o });
}
catch (SecurityException e)
{
throw new InvalidOperationException(SR.XmlNoPartialTrust, e);
}
finally
{
if (writer != null)
{
writer.Dispose();
}
}
}
/// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlSerializer(Type type, string defaultNamespace)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
_mapping = GetKnownMapping(type, defaultNamespace);
if (_mapping != null)
{
_primitiveType = type;
return;
}
_tempAssembly = s_cache[defaultNamespace, type];
if (_tempAssembly == null)
{
lock (s_cache)
{
_tempAssembly = s_cache[defaultNamespace, type];
if (_tempAssembly == null)
{
{
// need to reflect and generate new serialization assembly
XmlReflectionImporter importer = new XmlReflectionImporter(defaultNamespace);
_mapping = importer.ImportTypeMapping(type, null, defaultNamespace);
_tempAssembly = GenerateTempAssembly(_mapping, type, defaultNamespace);
}
}
s_cache.Add(defaultNamespace, type, _tempAssembly);
}
}
if (_mapping == null)
{
_mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
}
}
internal object InvokeReader(XmlMapping mapping, XmlReader xmlReader, XmlDeserializationEvents events, string encodingStyle)
{
XmlSerializationReader reader = null;
try
{
encodingStyle = ValidateEncodingStyle(encodingStyle, mapping.Key);
reader = Contract.Reader;
reader.Init(xmlReader, events, encodingStyle, this);
if (_methods[mapping.Key].readMethod == null)
{
if (_readerMethods == null)
{
_readerMethods = Contract.ReadMethods;
}
string methodName = (string)_readerMethods[mapping.Key];
if (methodName == null)
{
throw new InvalidOperationException(SR.Format(SR.XmlNotSerializable, mapping.Accessor.Name));
}
_methods[mapping.Key].readMethod = GetMethodFromType(reader.GetType(), methodName);
}
return(_methods[mapping.Key].readMethod.Invoke(reader, Array.Empty <object>()));
}
catch (SecurityException e)
{
throw new InvalidOperationException(SR.XmlNoPartialTrust, e);
}
finally
{
if (reader != null)
{
reader.Dispose();
}
}
}
internal void SetTempAssembly(TempAssembly tempAssembly, XmlMapping mapping)
{
this.tempAssembly = tempAssembly;
this.mapping = mapping;
this.typedSerializer = true;
}
//*******************************************************
// Reader generation
//
public void GenerateReader (string readerClassName, ArrayList maps)
{
if (_config == null || !_config.GenerateAsInternal)
WriteLine ("public class " + readerClassName + " : XmlSerializationReader");
else
WriteLine ("internal class " + readerClassName + " : XmlSerializationReader");
WriteLineInd ("{");
// FromBinHexString() is not public, so use reflection here.
WriteLine ("static readonly System.Reflection.MethodInfo fromBinHexStringMethod = typeof (XmlConvert).GetMethod (\"FromBinHexString\", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new Type [] {typeof (string)}, null);");
WriteLine ("static byte [] FromBinHexString (string input)");
WriteLineInd ("{");
WriteLine ("return input == null ? null : (byte []) fromBinHexStringMethod.Invoke (null, new object [] {input});");
WriteLineUni ("}");
_mapsToGenerate = new ArrayList ();
_fixupCallbacks = new ArrayList ();
InitHooks ();
for (int n=0; n<maps.Count; n++)
{
GenerationResult res = (GenerationResult) maps [n];
_typeMap = res.Mapping;
_format = _typeMap.Format;
_result = res;
GenerateReadRoot ();
}
for (int n=0; n<_mapsToGenerate.Count; n++)
{
XmlTypeMapping map = _mapsToGenerate [n] as XmlTypeMapping;
if (map == null) continue;
GenerateReadObject (map);
if (map.TypeData.SchemaType == SchemaTypes.Enum)
GenerateGetEnumValueMethod (map);
}
GenerateReadInitCallbacks ();
if (_format == SerializationFormat.Encoded)
{
GenerateFixupCallbacks ();
GenerateFillerCallbacks ();
}
WriteLineUni ("}");
UpdateGeneratedTypes (_mapsToGenerate);
}
public int RegisterSerializer (XmlMapping map)
{
if (mappings == null) mappings = new ArrayList ();
return mappings.Add (map);
}
void GenerateReadMembers (XmlMapping xmlMap, ClassMap map, string ob, bool isValueList, bool readBySoapOrder)
{
XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
bool first = false;
// Read attributes
GenerateReadAttributeMembers (xmlMap, map, ob, isValueList, ref first);
if (!isValueList)
{
WriteLine ("Reader.MoveToElement();");
WriteLineInd ("if (Reader.IsEmptyElement) {");
WriteLine ("Reader.Skip ();");
GenerateSetListMembersDefaults (typeMap, map, ob, isValueList);
WriteLine ("return " + ob + ";");
WriteLineUni ("}");
WriteLine ("");
WriteLine ("Reader.ReadStartElement();");
}
// Reads elements
WriteLine("Reader.MoveToContent();");
WriteLine ("");
if (!GenerateReadHook (HookType.elements, xmlMapType))
{
string[] readFlag = null;
if (map.ElementMembers != null && !readBySoapOrder)
{
string readFlagsVars = string.Empty;
readFlag = new string[map.ElementMembers.Count];
int n=0;
foreach (XmlTypeMapMember mem in map.ElementMembers) {
// The text collector doesn't need a flag
if (!((mem is XmlTypeMapMemberElement) && ((XmlTypeMapMemberElement)mem).IsXmlTextCollector)) {
readFlag[n] = GetBoolTempVar ();
if (readFlagsVars.Length > 0) readFlagsVars += ", ";
readFlagsVars += readFlag[n] + "=false";
}
n++;
}
if (readFlagsVars.Length > 0) {
readFlagsVars = "bool " + readFlagsVars;
WriteLine (readFlagsVars + ";");
}
foreach (XmlTypeMapElementInfo info in map.AllElementInfos)
if (info.ExplicitOrder >= 0) {
WriteLine ("int idx = -1;");
break;
}
WriteLine ("");
}
string[] indexes = null;
string[] flatLists = null;
string[] flatListsChoices = null;
if (map.FlatLists != null)
{
indexes = new string[map.FlatLists.Count];
flatLists = new string[map.FlatLists.Count];
string code = "int ";
for (int n=0; n<map.FlatLists.Count; n++)
{
XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement)map.FlatLists[n];
indexes[n] = GetNumTempVar ();
if (n > 0) code += ", ";
code += indexes[n] + "=0";
if (!MemberHasReadReplaceHook (xmlMapType, mem)) {
flatLists[n] = GetObTempVar ();
string rval;
WriteLine (mem.TypeData.CSharpFullName + " " + flatLists[n] + ";");
if (IsReadOnly (typeMap, mem, mem.TypeData, isValueList)) {
rval = GenerateGetMemberValue (mem, ob, isValueList);
WriteLine (flatLists[n] + " = " + rval + ";");
} else if (mem.TypeData.Type.IsArray) {
rval = GenerateInitializeList (mem.TypeData);
WriteLine (flatLists[n] + " = " + rval + ";");
} else {
WriteLine (flatLists[n] + " = " + GenerateGetMemberValue (mem, ob, isValueList) + ";");
WriteLineInd ("if (((object)" + flatLists[n] + ") == null) {");
WriteLine (flatLists[n] + " = " + GenerateInitializeList (mem.TypeData) + ";");
GenerateSetMemberValue (mem, ob, flatLists[n], isValueList);
WriteLineUni ("}");
}
}
if (mem.ChoiceMember != null) {
if (flatListsChoices == null)
flatListsChoices = new string [map.FlatLists.Count];
flatListsChoices[n] = GetObTempVar ();
string rval = GenerateInitializeList (mem.ChoiceTypeData);
WriteLine (mem.ChoiceTypeData.CSharpFullName + " " + flatListsChoices[n] + " = " + rval + ";");
}
}
WriteLine (code + ";");
WriteLine ("");
}
if (_format == SerializationFormat.Encoded && map.ElementMembers != null)
{
_fixupCallbacks.Add (xmlMap);
WriteLine ("Fixup fixup = new Fixup(" + ob + ", new XmlSerializationFixupCallback(" + GetFixupCallbackName (xmlMap) + "), " + map.ElementMembers.Count + ");");
WriteLine ("AddFixup (fixup);");
WriteLine ("");
}
ArrayList infos = null;
int maxInd;
if (readBySoapOrder) {
if (map.ElementMembers != null) maxInd = map.ElementMembers.Count;
else maxInd = 0;
}
else
{
infos = new ArrayList ();
infos.AddRange (map.AllElementInfos);
maxInd = infos.Count;
WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) ");
WriteLineInd ("{");
WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
WriteLineInd ("{");
}
first = true;
for (int ind = 0; ind < maxInd; ind++)
{
XmlTypeMapElementInfo info = readBySoapOrder ? map.GetElement (ind) : (XmlTypeMapElementInfo) infos [ind];
if (!readBySoapOrder)
{
if (info.IsTextElement || info.IsUnnamedAnyElement) continue;
string elemCond = first ? "" : "else ";
elemCond += "if (";
if (info.ExplicitOrder >= 0)
elemCond += "idx < " + info.ExplicitOrder + "&& ";
if (!(info.Member.IsReturnValue && _format == SerializationFormat.Encoded)) {
elemCond += "Reader.LocalName == " + GetLiteral (info.ElementName);
if (!map.IgnoreMemberNamespace) elemCond += " && Reader.NamespaceURI == " + GetLiteral (info.Namespace);
elemCond += " && ";
}
if (readFlag[info.Member.Index] != null)
elemCond += "!" + readFlag[info.Member.Index] + ") {";
else
elemCond += "true) {";
WriteLineInd (elemCond);
}
if (info.Member.GetType() == typeof (XmlTypeMapMemberList))
{
if (_format == SerializationFormat.Encoded && info.MultiReferenceType)
{
string list = GetObTempVar ();
WriteLine ("object " + list + " = ReadReferencingElement (out fixup.Ids[" + info.Member.Index + "]);");
RegisterReferencingMap (info.MappedType);
WriteLineInd ("if (fixup.Ids[" + info.Member.Index + "] == null) {"); // Already read
if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList))
WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral(info.TypeData.CSharpFullName) + ");");
else
GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,list), isValueList);
WriteLineUni ("}");
if (!info.MappedType.TypeData.Type.IsArray)
{
WriteLineInd ("else {");
if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList))
WriteLine (list + " = " + GenerateGetMemberValue (info.Member, ob, isValueList) + ";");
else {
WriteLine (list + " = " + GenerateCreateList (info.MappedType.TypeData.Type) + ";");
GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,list), isValueList);
}
WriteLine ("AddFixup (new CollectionFixup (" + list + ", new XmlSerializationCollectionFixupCallback (" + GetFillListName(info.Member.TypeData) + "), fixup.Ids[" + info.Member.Index + "]));");
WriteLine ("fixup.Ids[" + info.Member.Index + "] = null;"); // The member already has the value, no further fix needed.
WriteLineUni ("}");
}
}
else
{
if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList)) {
GenerateReadListElement (info.MappedType, GenerateGetMemberValue (info.Member, ob, isValueList), GetLiteral(info.IsNullable), false);
} else if (info.MappedType.TypeData.Type.IsArray) {
if (info.IsNullable)
GenerateSetMemberValue (info.Member, ob, GenerateReadListElement (info.MappedType, null, GetLiteral(info.IsNullable), true), isValueList);
else {
string list = GetObTempVar ();
WriteLine (info.MappedType.TypeData.CSharpFullName + " " + list + " = " + GenerateReadListElement (info.MappedType, null, GetLiteral(info.IsNullable), true) + ";");
WriteLineInd ("if (((object)" + list + ") != null) {");
GenerateSetMemberValue (info.Member, ob, list, isValueList);
WriteLineUni ("}");
}
} else {
string list = GetObTempVar ();
WriteLine (info.MappedType.TypeData.CSharpFullName + " " + list + " = " + GenerateGetMemberValue (info.Member, ob, isValueList) + ";");
WriteLineInd ("if (((object)" + list + ") == null) {");
WriteLine (list + " = " + GenerateCreateList (info.MappedType.TypeData.Type) + ";");
GenerateSetMemberValue (info.Member, ob, list, isValueList);
WriteLineUni ("}");
GenerateReadListElement (info.MappedType, list, GetLiteral(info.IsNullable), true);
}
GenerateEndHook ();
}
}
if (!readBySoapOrder)
WriteLine (readFlag[info.Member.Index] + " = true;");
}
else if (info.Member.GetType() == typeof (XmlTypeMapMemberFlatList))
{
XmlTypeMapMemberFlatList mem = (XmlTypeMapMemberFlatList)info.Member;
if (!GenerateReadArrayMemberHook (xmlMapType, info.Member, indexes[mem.FlatArrayIndex])) {
GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GenerateReadObjectElement (info), !IsReadOnly (typeMap, info.Member, info.TypeData, isValueList));
if (mem.ChoiceMember != null) {
GenerateAddListValue (mem.ChoiceTypeData, flatListsChoices[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetLiteral (info.ChoiceValue), true);
}
GenerateEndHook ();
}
WriteLine (indexes[mem.FlatArrayIndex] + "++;");
}
else if (info.Member.GetType() == typeof (XmlTypeMapMemberAnyElement))
{
XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement)info.Member;
if (mem.TypeData.IsListType) {
if (!GenerateReadArrayMemberHook (xmlMapType, info.Member, indexes[mem.FlatArrayIndex])) {
GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetReadXmlNode (mem.TypeData.ListItemTypeData, false), true);
GenerateEndHook ();
}
WriteLine (indexes[mem.FlatArrayIndex] + "++;");
}
else {
if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
GenerateSetMemberValue (mem, ob, GetReadXmlNode(mem.TypeData, false), isValueList);
GenerateEndHook ();
}
}
}
else if (info.Member.GetType() == typeof(XmlTypeMapMemberElement))
{
if (!readBySoapOrder)
WriteLine (readFlag[info.Member.Index] + " = true;");
if (info.ExplicitOrder >= 0)
WriteLine ("idx = " + info.ExplicitOrder + ";");
if (_format == SerializationFormat.Encoded)
{
string val = GetObTempVar ();
RegisterReferencingMap (info.MappedType);
if (info.Member.TypeData.SchemaType != SchemaTypes.Primitive)
WriteLine ("object " + val + " = ReadReferencingElement (out fixup.Ids[" + info.Member.Index + "]);");
else
WriteLine ("object " + val + " = ReadReferencingElement (" + GetLiteral(info.Member.TypeData.XmlType) + ", " + GetLiteral(System.Xml.Schema.XmlSchema.Namespace) + ", out fixup.Ids[" + info.Member.Index + "]);");
if (info.MultiReferenceType)
WriteLineInd ("if (fixup.Ids[" + info.Member.Index + "] == null) {"); // already read
else
WriteLineInd ("if (" + val + " != null) {"); // null value
GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,val), isValueList);
WriteLineUni ("}");
}
else if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
if (info.ChoiceValue != null) {
XmlTypeMapMemberElement imem = (XmlTypeMapMemberElement) info.Member;
WriteLine (ob + ".@" + imem.ChoiceMember + " = " + GetLiteral(info.ChoiceValue) + ";");
}
GenerateSetMemberValue (info.Member, ob, GenerateReadObjectElement (info), isValueList);
GenerateEndHook ();
}
}
else
throw new InvalidOperationException ("Unknown member type");
if (!readBySoapOrder)
WriteLineUni ("}");
else
WriteLine ("Reader.MoveToContent();");
first = false;
}
if (!readBySoapOrder)
{
if (!first) WriteLineInd ("else {");
if (map.DefaultAnyElementMember != null)
{
XmlTypeMapMemberAnyElement mem = map.DefaultAnyElementMember;
if (mem.TypeData.IsListType) {
if (!GenerateReadArrayMemberHook (xmlMapType, mem, indexes[mem.FlatArrayIndex])) {
GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetReadXmlNode(mem.TypeData.ListItemTypeData, false), true);
GenerateEndHook ();
}
WriteLine (indexes[mem.FlatArrayIndex] + "++;");
}
else if (! GenerateReadMemberHook (xmlMapType, mem)) {
GenerateSetMemberValue (mem, ob, GetReadXmlNode(mem.TypeData, false), isValueList);
GenerateEndHook ();
}
}
else {
if (!GenerateReadHook (HookType.unknownElement, xmlMapType)) {
WriteLine ("UnknownNode (" + ob + ");");
GenerateEndHook ();
}
}
if (!first) WriteLineUni ("}");
WriteLineUni ("}");
if (map.XmlTextCollector != null)
{
WriteLine ("else if (Reader.NodeType == System.Xml.XmlNodeType.Text || Reader.NodeType == System.Xml.XmlNodeType.CDATA)");
WriteLineInd ("{");
if (map.XmlTextCollector is XmlTypeMapMemberExpandable)
{
XmlTypeMapMemberExpandable mem = (XmlTypeMapMemberExpandable)map.XmlTextCollector;
XmlTypeMapMemberFlatList flatl = mem as XmlTypeMapMemberFlatList;
TypeData itype = (flatl == null) ? mem.TypeData.ListItemTypeData : flatl.ListMap.FindTextElement().TypeData;
if (!GenerateReadArrayMemberHook (xmlMapType, map.XmlTextCollector, indexes[mem.FlatArrayIndex])) {
string val = (itype.Type == typeof (string)) ? "Reader.ReadString()" : GetReadXmlNode (itype, false);
GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], val, true);
GenerateEndHook ();
}
WriteLine (indexes[mem.FlatArrayIndex] + "++;");
}
else if (!GenerateReadMemberHook (xmlMapType, map.XmlTextCollector))
{
XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement) map.XmlTextCollector;
XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) mem.ElementInfo [0];
if (info.TypeData.Type == typeof (string))
GenerateSetMemberValue (mem, ob, "ReadString (" + GenerateGetMemberValue (mem, ob, isValueList) + ")", isValueList);
else {
WriteLineInd ("{");
string str = GetStrTempVar ();
WriteLine ("string " + str + " = Reader.ReadString();");
GenerateSetMemberValue (mem, ob, GenerateGetValueFromXmlString (str, info.TypeData, info.MappedType, info.IsNullable), isValueList);
WriteLineUni ("}");
}
GenerateEndHook ();
}
WriteLineUni ("}");
}
WriteLine ("else");
WriteLine ("\tUnknownNode(" + ob + ");");
WriteLine ("");
WriteLine ("Reader.MoveToContent();");
WriteLineUni ("}");
}
else
WriteLine ("Reader.MoveToContent();");
if (flatLists != null)
{
WriteLine ("");
foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
{
if (MemberHasReadReplaceHook (xmlMapType, mem)) continue;
string list = flatLists[mem.FlatArrayIndex];
if (mem.TypeData.Type.IsArray)
WriteLine (list + " = (" + mem.TypeData.CSharpFullName + ") ShrinkArray (" + list + ", " + indexes[mem.FlatArrayIndex] + ", " + GetTypeOf(mem.TypeData.Type.GetElementType()) + ", true);");
if (!IsReadOnly (typeMap, mem, mem.TypeData, isValueList) && mem.TypeData.Type.IsArray)
GenerateSetMemberValue (mem, ob, list, isValueList);
}
}
if (flatListsChoices != null)
{
WriteLine ("");
foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
{
if (MemberHasReadReplaceHook (xmlMapType, mem)) continue;
if (mem.ChoiceMember == null) continue;
string list = flatListsChoices[mem.FlatArrayIndex];
WriteLine (list + " = (" + mem.ChoiceTypeData.CSharpFullName + ") ShrinkArray (" + list + ", " + indexes[mem.FlatArrayIndex] + ", " + GetTypeOf(mem.ChoiceTypeData.Type.GetElementType()) + ", true);");
WriteLine (ob + ".@" + mem.ChoiceMember + " = " + list + ";");
}
}
GenerateSetListMembersDefaults (typeMap, map, ob, isValueList);
GenerateEndHook ();
}
if (!isValueList)
{
WriteLine ("");
WriteLine ("ReadEndElement();");
}
}
public void GenerateSerializers (TextWriter writer)
{
_writer = writer;
_results = new GenerationResult [_xmlMaps.Length];
WriteLine ("// It is automatically generated");
WriteLine ("using System;");
WriteLine ("using System.Xml;");
WriteLine ("using System.Xml.Schema;");
WriteLine ("using System.Xml.Serialization;");
WriteLine ("using System.Text;");
WriteLine ("using System.Collections;");
WriteLine ("using System.Globalization;");
if (_config != null && _config.NamespaceImports != null && _config.NamespaceImports.Length > 0) {
foreach (string ns in _config.NamespaceImports)
WriteLine ("using " + ns + ";");
}
WriteLine ("");
string readerClassName = null;
string writerClassName = null;
string baseClassName = null;
string implClassName = null;
string namspace = null;
if (_config != null)
{
readerClassName = _config.ReaderClassName;
writerClassName = _config.WriterClassName;
baseClassName = _config.BaseSerializerClassName;
implClassName = _config.ImplementationClassName;
namspace = _config.Namespace;
}
if (readerClassName == null || readerClassName.Length == 0)
readerClassName = "GeneratedReader";
if (writerClassName == null || writerClassName.Length == 0)
writerClassName = "GeneratedWriter";
if (baseClassName == null || baseClassName.Length == 0)
baseClassName = "BaseXmlSerializer";
if (implClassName == null || implClassName.Length == 0)
implClassName = "XmlSerializerContract";
readerClassName = GetUniqueClassName (readerClassName);
writerClassName = GetUniqueClassName (writerClassName);
baseClassName = GetUniqueClassName (baseClassName);
implClassName = GetUniqueClassName (implClassName);
Hashtable mapsByNamespace = new Hashtable ();
Hashtable generatedMaps = new Hashtable ();
for (int n=0; n<_xmlMaps.Length; n++)
{
_typeMap = _xmlMaps [n];
if (_typeMap == null) continue;
_result = generatedMaps [_typeMap] as GenerationResult;
if (_result != null) {
_results[n] = _result;
continue;
}
_result = new GenerationResult ();
_results[n] = _result;
generatedMaps [_typeMap] = _result;
string typeName;
if (_typeMap is XmlTypeMapping) typeName = CodeIdentifier.MakeValid (((XmlTypeMapping)_typeMap).TypeData.CSharpName);
else typeName = ((XmlMembersMapping)_typeMap).ElementName;
_result.ReaderClassName = readerClassName;
_result.WriterClassName = writerClassName;
_result.BaseSerializerClassName = baseClassName;
_result.ImplementationClassName = implClassName;
if (namspace == null || namspace.Length == 0)
_result.Namespace = "Mono.GeneratedSerializers." + _typeMap.Format;
else
_result.Namespace = namspace;
_result.WriteMethodName = GetUniqueName ("rwo", _typeMap, "WriteRoot_" + typeName);
_result.ReadMethodName = GetUniqueName ("rro", _typeMap, "ReadRoot_" + typeName);
_result.Mapping = _typeMap;
ArrayList maps = (ArrayList) mapsByNamespace [_result.Namespace];
if (maps == null) {
maps = new ArrayList ();
mapsByNamespace [_result.Namespace] = maps;
}
maps.Add (_result);
}
foreach (DictionaryEntry entry in mapsByNamespace)
{
ArrayList maps = (ArrayList) entry.Value;
WriteLine ("namespace " + entry.Key);
WriteLineInd ("{");
if (_config == null || !_config.NoReader)
GenerateReader (readerClassName, maps);
WriteLine ("");
if (_config == null || !_config.NoWriter)
GenerateWriter (writerClassName, maps);
WriteLine ("");
#if NET_2_0
GenerateContract (maps);
#endif
WriteLineUni ("}");
WriteLine ("");
}
}
string GetFixupCallbackName (XmlMapping typeMap)
{
if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
if (typeMap is XmlTypeMapping)
return GetUniqueName ("fc", typeMap, "FixupCallback_" + ((XmlTypeMapping)typeMap).XmlType);
else
return GetUniqueName ("fc", typeMap, "FixupCallback__Message");
}
internal void GenerateEnd(string[] methods, XmlMapping[] xmlMappings, Type[] types) {
GenerateReferencedMethods();
GenerateInitCallbacksMethod();
foreach (CreateCollectionInfo c in createMethods.Values) {
WriteCreateCollectionMethod(c);
}
Writer.WriteLine();
foreach (string idName in idNames.Values) {
Writer.Write("string ");
Writer.Write(idName);
Writer.WriteLine(";");
}
Writer.WriteLine();
Writer.WriteLine("protected override void InitIDs() {");
Writer.Indent++;
foreach (string id in idNames.Keys) {
//
string idName = (string)idNames[id];
Writer.Write(idName);
Writer.Write(" = Reader.NameTable.Add(");
WriteQuotedCSharpString(id);
Writer.WriteLine(");");
}
Writer.Indent--;
Writer.WriteLine("}");
Writer.Indent--;
Writer.WriteLine("}");
}
//GenerateGetSerializer(serializers, xmlMappings);
private void GenerateGetSerializer(Dictionary<string, string> serializers, XmlMapping[] xmlMappings, TypeBuilder serializerContractTypeBuilder)
{
ilg = new CodeGenerator(serializerContractTypeBuilder);
ilg.BeginMethod(
typeof(XmlSerializer),
"GetSerializer",
new Type[] { typeof(Type) },
new string[] { "type" },
CodeGenerator.PublicOverrideMethodAttributes);
for (int i = 0; i < xmlMappings.Length; i++)
{
if (xmlMappings[i] is XmlTypeMapping)
{
Type type = xmlMappings[i].Accessor.Mapping.TypeDesc.Type;
if (type == null)
continue;
if (!type.GetTypeInfo().IsPublic && !type.GetTypeInfo().IsNestedPublic)
continue;
// DDB172141: Wrong generated CS for serializer of List<string> type
if (type.GetTypeInfo().IsGenericType || type.GetTypeInfo().ContainsGenericParameters)
continue;
ilg.Ldarg("type");
ilg.Ldc(type);
ilg.If(Cmp.EqualTo);
{
ConstructorInfo ctor = CreatedTypes[(string)serializers[xmlMappings[i].Key]].GetConstructor(
CodeGenerator.InstanceBindingFlags,
Array.Empty<Type>()
);
ilg.New(ctor);
ilg.Stloc(ilg.ReturnLocal);
ilg.Br(ilg.ReturnLabel);
}
ilg.EndIf();
}
}
ilg.Load(null);
ilg.Stloc(ilg.ReturnLocal);
ilg.Br(ilg.ReturnLabel);
ilg.MarkLabel(ilg.ReturnLabel);
ilg.Ldloc(ilg.ReturnLocal);
ilg.EndMethod();
}
internal void GenerateSerializerContract(string className, XmlMapping[] xmlMappings, Type[] types, string readerType, string[] readMethods, string writerType, string[] writerMethods, Dictionary<string, string> serializers)
{
TypeBuilder serializerContractTypeBuilder = CodeGenerator.CreateTypeBuilder(
_moduleBuilder,
"XmlSerializerContract",
TypeAttributes.Public | TypeAttributes.BeforeFieldInit,
typeof(XmlSerializerImplementation),
Array.Empty<Type>()
);
ilg = new CodeGenerator(serializerContractTypeBuilder);
PropertyBuilder propertyBuilder = serializerContractTypeBuilder.DefineProperty(
"Reader",
PropertyAttributes.None,
typeof(XmlSerializationReader),
null, null, null, null, null);
ilg.BeginMethod(
typeof(XmlSerializationReader),
"get_Reader",
Array.Empty<Type>(),
Array.Empty<string>(),
CodeGenerator.PublicOverrideMethodAttributes | MethodAttributes.SpecialName);
propertyBuilder.SetGetMethod(ilg.MethodBuilder);
ConstructorInfo ctor = CreatedTypes[readerType].GetConstructor(
CodeGenerator.InstanceBindingFlags,
Array.Empty<Type>()
);
ilg.New(ctor);
ilg.EndMethod();
ilg = new CodeGenerator(serializerContractTypeBuilder);
propertyBuilder = serializerContractTypeBuilder.DefineProperty(
"Writer",
PropertyAttributes.None,
typeof(XmlSerializationWriter),
null, null, null, null, null);
ilg.BeginMethod(
typeof(XmlSerializationWriter),
"get_Writer",
Array.Empty<Type>(),
Array.Empty<string>(),
CodeGenerator.PublicOverrideMethodAttributes | MethodAttributes.SpecialName);
propertyBuilder.SetGetMethod(ilg.MethodBuilder);
ctor = CreatedTypes[writerType].GetConstructor(
CodeGenerator.InstanceBindingFlags,
Array.Empty<Type>()
);
ilg.New(ctor);
ilg.EndMethod();
FieldBuilder readMethodsField = GeneratePublicMethods("readMethods", "ReadMethods", readMethods, xmlMappings, serializerContractTypeBuilder);
FieldBuilder writeMethodsField = GeneratePublicMethods("writeMethods", "WriteMethods", writerMethods, xmlMappings, serializerContractTypeBuilder);
FieldBuilder typedSerializersField = GenerateTypedSerializers(serializers, serializerContractTypeBuilder);
GenerateSupportedTypes(types, serializerContractTypeBuilder);
GenerateGetSerializer(serializers, xmlMappings, serializerContractTypeBuilder);
// Default ctor
ConstructorInfo baseCtor = typeof(XmlSerializerImplementation).GetConstructor(
CodeGenerator.InstanceBindingFlags,
Array.Empty<Type>()
);
ilg = new CodeGenerator(serializerContractTypeBuilder);
ilg.BeginMethod(
typeof(void),
".ctor",
Array.Empty<Type>(),
Array.Empty<string>(),
CodeGenerator.PublicMethodAttributes | MethodAttributes.RTSpecialName | MethodAttributes.SpecialName
);
ilg.Ldarg(0);
ilg.Load(null);
ilg.StoreMember(readMethodsField);
ilg.Ldarg(0);
ilg.Load(null);
ilg.StoreMember(writeMethodsField);
ilg.Ldarg(0);
ilg.Load(null);
ilg.StoreMember(typedSerializersField);
ilg.Ldarg(0);
ilg.Call(baseCtor);
ilg.EndMethod();
// Instantiate type
Type serializerContractType = serializerContractTypeBuilder.CreateTypeInfo().AsType();
CreatedTypes.Add(serializerContractType.Name, serializerContractType);
}
internal FieldBuilder GeneratePublicMethods(string privateName, string publicName, string[] methods, XmlMapping[] xmlMappings, TypeBuilder serializerContractTypeBuilder)
{
FieldBuilder fieldBuilder = GenerateHashtableGetBegin(privateName, publicName, serializerContractTypeBuilder);
if (methods != null && methods.Length != 0 && xmlMappings != null && xmlMappings.Length == methods.Length)
{
MethodInfo Hashtable_set_Item = typeof(Hashtable).GetMethod(
"set_Item",
new Type[] { typeof(Object), typeof(Object) }
);
for (int i = 0; i < methods.Length; i++)
{
if (methods[i] == null)
continue;
ilg.Ldloc(typeof(Hashtable), "_tmp");
ilg.Ldstr(GetCSharpString(xmlMappings[i].Key));
ilg.Ldstr(GetCSharpString(methods[i]));
ilg.Call(Hashtable_set_Item);
}
}
GenerateHashtableGetEnd(fieldBuilder);
return fieldBuilder;
}
internal string GenerateTypedSerializer(string readMethod, string writeMethod, XmlMapping mapping, CodeIdentifiers classes, string baseSerializer, string readerClass, string writerClass)
{
string serializerName = CodeIdentifier.MakeValid(Accessor.UnescapeName(mapping.Accessor.Mapping.TypeDesc.Name));
serializerName = classes.AddUnique(serializerName + "Serializer", mapping);
TypeBuilder typedSerializerTypeBuilder = CodeGenerator.CreateTypeBuilder(
_moduleBuilder,
CodeIdentifier.GetCSharpName(serializerName),
TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit,
CreatedTypes[baseSerializer],
Array.Empty<Type>()
);
ilg = new CodeGenerator(typedSerializerTypeBuilder);
ilg.BeginMethod(
typeof(Boolean),
"CanDeserialize",
new Type[] { typeof(XmlReader) },
new string[] { "xmlReader" },
CodeGenerator.PublicOverrideMethodAttributes
);
if (mapping.Accessor.Any)
{
ilg.Ldc(true);
ilg.Stloc(ilg.ReturnLocal);
ilg.Br(ilg.ReturnLabel);
}
else
{
MethodInfo XmlReader_IsStartElement = typeof(XmlReader).GetMethod(
"IsStartElement",
CodeGenerator.InstanceBindingFlags,
new Type[] { typeof(String), typeof(String) }
);
ilg.Ldarg(ilg.GetArg("xmlReader"));
ilg.Ldstr(GetCSharpString(mapping.Accessor.Name));
ilg.Ldstr(GetCSharpString(mapping.Accessor.Namespace));
ilg.Call(XmlReader_IsStartElement);
ilg.Stloc(ilg.ReturnLocal);
ilg.Br(ilg.ReturnLabel);
}
ilg.MarkLabel(ilg.ReturnLabel);
ilg.Ldloc(ilg.ReturnLocal);
ilg.EndMethod();
if (writeMethod != null)
{
ilg = new CodeGenerator(typedSerializerTypeBuilder);
ilg.BeginMethod(
typeof(void),
"Serialize",
new Type[] { typeof(object), typeof(XmlSerializationWriter) },
new string[] { "objectToSerialize", "writer" },
CodeGenerator.ProtectedOverrideMethodAttributes);
MethodInfo writerType_writeMethod = CreatedTypes[writerClass].GetMethod(
writeMethod,
CodeGenerator.InstanceBindingFlags,
new Type[] { (mapping is XmlMembersMapping) ? typeof(object[]) : typeof(object) }
);
ilg.Ldarg("writer");
ilg.Castclass(CreatedTypes[writerClass]);
ilg.Ldarg("objectToSerialize");
if (mapping is XmlMembersMapping)
{
ilg.ConvertValue(typeof(object), typeof(object[]));
}
ilg.Call(writerType_writeMethod);
ilg.EndMethod();
}
if (readMethod != null)
{
ilg = new CodeGenerator(typedSerializerTypeBuilder);
ilg.BeginMethod(
typeof(object),
"Deserialize",
new Type[] { typeof(XmlSerializationReader) },
new string[] { "reader" },
CodeGenerator.ProtectedOverrideMethodAttributes);
MethodInfo readerType_readMethod = CreatedTypes[readerClass].GetMethod(
readMethod,
CodeGenerator.InstanceBindingFlags,
Array.Empty<Type>()
);
ilg.Ldarg("reader");
ilg.Castclass(CreatedTypes[readerClass]);
ilg.Call(readerType_readMethod);
ilg.EndMethod();
}
typedSerializerTypeBuilder.DefineDefaultConstructor(CodeGenerator.PublicMethodAttributes);
Type typedSerializerType = typedSerializerTypeBuilder.CreateTypeInfo().AsType();
CreatedTypes.Add(typedSerializerType.Name, typedSerializerType);
return typedSerializerType.Name;
}
void GenerateWriteObjectElement (XmlMapping xmlMap, string ob, bool isValueList)
{
XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
ClassMap map = (ClassMap)xmlMap.ObjectMap;
if (!GenerateWriteHook (HookType.attributes, xmlMapType))
{
if (map.NamespaceDeclarations != null) {
WriteLine ("WriteNamespaceDeclarations ((XmlSerializerNamespaces) " + ob + ".@" + map.NamespaceDeclarations.Name + ");");
WriteLine ("");
}
XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
if (anyAttrMember != null)
{
if (!GenerateWriteMemberHook (xmlMapType, anyAttrMember))
{
string cond = GenerateMemberHasValueCondition (anyAttrMember, ob, isValueList);
if (cond != null) WriteLineInd ("if (" + cond + ") {");
string tmpVar = GetObTempVar ();
WriteLine ("ICollection " + tmpVar + " = " + GenerateGetMemberValue (anyAttrMember, ob, isValueList) + ";");
WriteLineInd ("if (" + tmpVar + " != null) {");
string tmpVar2 = GetObTempVar ();
WriteLineInd ("foreach (XmlAttribute " + tmpVar2 + " in " + tmpVar + ")");
WriteLineInd ("if (" + tmpVar2 + ".NamespaceURI != xmlNamespace)");
WriteLine ("WriteXmlAttribute (" + tmpVar2 + ", " + ob + ");");
Unindent ();
Unindent ();
WriteLineUni ("}");
if (cond != null) WriteLineUni ("}");
WriteLine ("");
GenerateEndHook ();
}
}
ICollection attributes = map.AttributeMembers;
if (attributes != null)
{
foreach (XmlTypeMapMemberAttribute attr in attributes)
{
if (GenerateWriteMemberHook (xmlMapType, attr)) continue;
string val = GenerateGetMemberValue (attr, ob, isValueList);
string cond = GenerateMemberHasValueCondition (attr, ob, isValueList);
if (cond != null) WriteLineInd ("if (" + cond + ") {");
string strVal = GenerateGetStringValue (attr.MappedType, attr.TypeData, val, false);
WriteLine ("WriteAttribute (" + GetLiteral(attr.AttributeName) + ", " + GetLiteral(attr.Namespace) + ", " + strVal + ");");
if (cond != null) WriteLineUni ("}");
GenerateEndHook ();
}
WriteLine ("");
}
GenerateEndHook ();
}
if (!GenerateWriteHook (HookType.elements, xmlMapType))
{
ICollection members = map.ElementMembers;
if (members != null)
{
foreach (XmlTypeMapMemberElement member in members)
{
if (GenerateWriteMemberHook (xmlMapType, member)) continue;
string cond = GenerateMemberHasValueCondition (member, ob, isValueList);
if (cond != null) WriteLineInd ("if (" + cond + ") {");
string memberValue = GenerateGetMemberValue (member, ob, isValueList);
Type memType = member.GetType();
if (memType == typeof(XmlTypeMapMemberList))
{
GenerateWriteMemberElement ((XmlTypeMapElementInfo) member.ElementInfo[0], memberValue);
}
else if (memType == typeof(XmlTypeMapMemberFlatList))
{
WriteLineInd ("if (" + memberValue + " != null) {");
GenerateWriteListContent (ob, member.TypeData, ((XmlTypeMapMemberFlatList)member).ListMap, memberValue, false);
WriteLineUni ("}");
}
else if (memType == typeof(XmlTypeMapMemberAnyElement))
{
WriteLineInd ("if (" + memberValue + " != null) {");
GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
WriteLineUni ("}");
}
else if (memType == typeof(XmlTypeMapMemberAnyElement))
{
WriteLineInd ("if (" + memberValue + " != null) {");
GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
WriteLineUni ("}");
}
else if (memType == typeof(XmlTypeMapMemberAnyAttribute))
{
// Ignore
}
else if (memType == typeof(XmlTypeMapMemberElement))
{
if (member.ElementInfo.Count == 1) {
XmlTypeMapElementInfo elem = (XmlTypeMapElementInfo)member.ElementInfo[0];
GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
}
else if (member.ChoiceMember != null)
{
string choiceValue = ob + ".@" + member.ChoiceMember;
foreach (XmlTypeMapElementInfo elem in member.ElementInfo) {
WriteLineInd ("if (" + choiceValue + " == " + GetLiteral(elem.ChoiceValue) + ") {");
GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
WriteLineUni ("}");
}
}
else
{
// WriteLineInd ("if (" + memberValue + " == null) {");
// GenerateWriteMemberElement ((XmlTypeMapElementInfo)member.ElementInfo[0], memberValue);
// WriteLineUni ("}");
bool first = true;
foreach (XmlTypeMapElementInfo elem in member.ElementInfo)
{
WriteLineInd ((first?"":"else ") + "if (" + memberValue + " is " + elem.TypeData.CSharpFullName + ") {");
GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
WriteLineUni ("}");
first = false;
}
}
}
else
throw new InvalidOperationException ("Unknown member type");
if (cond != null)
WriteLineUni ("}");
GenerateEndHook ();
}
}
GenerateEndHook ();
}
}
public SerializationCodeGenerator (XmlMapping xmlMap, SerializerInfo config)
{
_xmlMaps = new XmlMapping [] {xmlMap};
_config = config;
}
public SerializationCodeGenerator (XmlMapping[] xmlMaps, SerializerInfo config)
{
_xmlMaps = xmlMaps;
_config = config;
}
internal string GenerateTypedSerializer(string readMethod, string writeMethod, XmlMapping mapping, CodeIdentifiers classes, string baseSerializer, string readerClass, string writerClass) {
string serializerName = CodeIdentifier.MakeValid(Accessor.UnescapeName(mapping.Accessor.Mapping.TypeDesc.Name));
serializerName = classes.AddUnique(serializerName + "Serializer", mapping);
writer.WriteLine();
writer.Write("public sealed class ");
writer.Write(CodeIdentifier.GetCSharpName(serializerName));
writer.Write(" : ");
writer.Write(baseSerializer);
writer.WriteLine(" {");
writer.Indent++;
writer.WriteLine();
writer.Write("public override ");
writer.Write(typeof(bool).FullName);
writer.Write(" CanDeserialize(");
writer.Write(typeof(XmlReader).FullName);
writer.WriteLine(" xmlReader) {");
writer.Indent++;
if (mapping.Accessor.Any) {
writer.WriteLine("return true;");
}
else {
writer.Write("return xmlReader.IsStartElement(");
WriteQuotedCSharpString(mapping.Accessor.Name);
writer.Write(", ");
WriteQuotedCSharpString(mapping.Accessor.Namespace);
writer.WriteLine(");");
}
writer.Indent--;
writer.WriteLine("}");
if (writeMethod != null) {
writer.WriteLine();
writer.Write("protected override void Serialize(object objectToSerialize, ");
writer.Write(typeof(XmlSerializationWriter).FullName);
writer.WriteLine(" writer) {");
writer.Indent++;
writer.Write("((");
writer.Write(writerClass);
writer.Write(")writer).");
writer.Write(writeMethod);
writer.Write("(");
if (mapping is XmlMembersMapping) {
writer.Write("(object[])");
}
writer.WriteLine("objectToSerialize);");
writer.Indent--;
writer.WriteLine("}");
}
if (readMethod != null) {
writer.WriteLine();
writer.Write("protected override object Deserialize(");
writer.Write(typeof(XmlSerializationReader).FullName);
writer.WriteLine(" reader) {");
writer.Indent++;
writer.Write("return ((");
writer.Write(readerClass);
writer.Write(")reader).");
writer.Write(readMethod);
writer.WriteLine("();");
writer.Indent--;
writer.WriteLine("}");
}
writer.Indent--;
writer.WriteLine("}");
return serializerName;
}
void GenerateReadAttributeMembers (XmlMapping xmlMap, ClassMap map, string ob, bool isValueList, ref bool first)
{
XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
if (GenerateReadHook (HookType.attributes, xmlMapType))
return;
XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
if (anyAttrMember != null)
{
WriteLine ("int anyAttributeIndex = 0;");
WriteLine (anyAttrMember.TypeData.CSharpFullName + " anyAttributeArray = null;");
}
WriteLine ("while (Reader.MoveToNextAttribute())");
WriteLineInd ("{");
first = true;
if (map.AttributeMembers != null) {
foreach (XmlTypeMapMemberAttribute at in map.AttributeMembers)
{
WriteLineInd ((first?"":"else ") + "if (Reader.LocalName == " + GetLiteral (at.AttributeName) + " && Reader.NamespaceURI == " + GetLiteral (at.Namespace) + ") {");
if (!GenerateReadMemberHook (xmlMapType, at)) {
GenerateSetMemberValue (at, ob, GenerateGetValueFromXmlString ("Reader.Value", at.TypeData, at.MappedType, false), isValueList);
GenerateEndHook ();
}
WriteLineUni ("}");
first = false;
}
}
WriteLineInd ((first?"":"else ") + "if (IsXmlnsAttribute (Reader.Name)) {");
// If the map has NamespaceDeclarations,
// then store this xmlns to the given member.
// If the instance doesn't exist, then create.
if (map.NamespaceDeclarations != null) {
if (!GenerateReadMemberHook (xmlMapType, map.NamespaceDeclarations)) {
string nss = ob + ".@" + map.NamespaceDeclarations.Name;
WriteLine ("if (" + nss + " == null) " + nss + " = new XmlSerializerNamespaces ();");
WriteLineInd ("if (Reader.Prefix == \"xmlns\")");
WriteLine (nss + ".Add (Reader.LocalName, Reader.Value);");
Unindent ();
WriteLineInd ("else");
WriteLine (nss + ".Add (\"\", Reader.Value);");
Unindent ();
GenerateEndHook ();
}
}
WriteLineUni ("}");
WriteLineInd ("else {");
if (anyAttrMember != null)
{
if (!GenerateReadArrayMemberHook (xmlMapType, anyAttrMember, "anyAttributeIndex")) {
WriteLine ("System.Xml.XmlAttribute attr = (System.Xml.XmlAttribute) Document.ReadNode(Reader);");
if (typeof(System.Xml.Schema.XmlSchemaAnnotated).IsAssignableFrom (xmlMapType))
WriteLine ("ParseWsdlArrayType (attr);");
GenerateAddListValue (anyAttrMember.TypeData, "anyAttributeArray", "anyAttributeIndex", GetCast (anyAttrMember.TypeData.ListItemTypeData, "attr"), true);
GenerateEndHook ();
}
WriteLine ("anyAttributeIndex++;");
}
else {
if (!GenerateReadHook (HookType.unknownAttribute, xmlMapType)) {
WriteLine ("UnknownNode (" + ob + ");");
GenerateEndHook ();
}
}
WriteLineUni ("}");
WriteLineUni ("}");
if (anyAttrMember != null && !MemberHasReadReplaceHook (xmlMapType, anyAttrMember))
{
WriteLine ("");
WriteLine("anyAttributeArray = (" + anyAttrMember.TypeData.CSharpFullName + ") ShrinkArray (anyAttributeArray, anyAttributeIndex, " + GetTypeOf(anyAttrMember.TypeData.Type.GetElementType()) + ", true);");
GenerateSetMemberValue (anyAttrMember, ob, "anyAttributeArray", isValueList);
}
WriteLine ("");
WriteLine ("Reader.MoveToElement ();");
GenerateEndHook ();
}
public SerializationCodeGenerator (XmlMapping[] xmlMaps): this (xmlMaps, null)
{
}
//*******************************************************
// Writer generation
//
public void GenerateWriter (string writerClassName, ArrayList maps)
{
_mapsToGenerate = new ArrayList ();
InitHooks ();
if (_config == null || !_config.GenerateAsInternal)
WriteLine ("public class " + writerClassName + " : XmlSerializationWriter");
else
WriteLine ("internal class " + writerClassName + " : XmlSerializationWriter");
WriteLineInd ("{");
WriteLine ("const string xmlNamespace = \"http://www.w3.org/2000/xmlns/\";");
// ToBinHexString() is not public, so use reflection here.
WriteLine ("static readonly System.Reflection.MethodInfo toBinHexStringMethod = typeof (XmlConvert).GetMethod (\"ToBinHexString\", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic, null, new Type [] {typeof (byte [])}, null);");
WriteLine ("static string ToBinHexString (byte [] input)");
WriteLineInd ("{");
WriteLine ("return input == null ? null : (string) toBinHexStringMethod.Invoke (null, new object [] {input});");
WriteLineUni ("}");
for (int n=0; n<maps.Count; n++)
{
GenerationResult res = (GenerationResult) maps [n];
_typeMap = res.Mapping;
_format = _typeMap.Format;
_result = res;
GenerateWriteRoot ();
}
for (int n=0; n<_mapsToGenerate.Count; n++)
{
XmlTypeMapping map = (XmlTypeMapping) _mapsToGenerate[n];
GenerateWriteObject (map);
if (map.TypeData.SchemaType == SchemaTypes.Enum)
GenerateGetXmlEnumValue (map);
}
GenerateWriteInitCallbacks ();
UpdateGeneratedTypes (_mapsToGenerate);
WriteLineUni ("}");
}
internal void GeneratePublicMethods(string privateName, string publicName, string[] methods, XmlMapping[] xmlMappings) {
GenerateHashtableGetBegin(privateName, publicName);
if (methods != null && methods.Length != 0 && xmlMappings != null && xmlMappings.Length == methods.Length) {
for (int i = 0; i < methods.Length; i++) {
if (methods[i] == null)
continue;
writer.Write("_tmp[");
WriteQuotedCSharpString(xmlMappings[i].Key);
writer.Write("] = ");
WriteQuotedCSharpString(methods[i]);
writer.WriteLine(";");
}
}
GenerateHashtableGetEnd(privateName);
}
internal void SetTempAssembly(TempAssembly tempAssembly, XmlMapping mapping)
{
_tempAssembly = tempAssembly;
_mapping = mapping;
_typedSerializer = true;
}
internal void GenerateSerializerContract(string className, XmlMapping[] xmlMappings, Type[] types, string readerType, string[] readMethods, string writerType, string[] writerMethods, Hashtable serializers) {
writer.WriteLine();
writer.Write("public class XmlSerializerContract : global::");
writer.Write(typeof(XmlSerializerImplementation).FullName);
writer.WriteLine(" {");
writer.Indent++;
writer.Write("public override global::");
writer.Write(typeof(XmlSerializationReader).FullName);
writer.Write(" Reader { get { return new ");
writer.Write(readerType);
writer.WriteLine("(); } }");
writer.Write("public override global::");
writer.Write(typeof(XmlSerializationWriter).FullName);
writer.Write(" Writer { get { return new ");
writer.Write(writerType);
writer.WriteLine("(); } }");
GeneratePublicMethods("readMethods", "ReadMethods", readMethods, xmlMappings);
GeneratePublicMethods("writeMethods", "WriteMethods", writerMethods, xmlMappings);
GenerateTypedSerializers(serializers);
GenerateSupportedTypes(types);
GenerateGetSerializer(serializers, xmlMappings);
writer.Indent--;
writer.WriteLine("}");
}
public XmlSerializerMappingKey(XmlMapping mapping)
{
this.Mapping = mapping;
}
