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("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("XmlPregenTypeDynamic", new object[] { type.FullName }));
}
if (assembly == null)
{
assembly = type.Assembly;
}
else if (type.Assembly != assembly)
{
throw new ArgumentException(Res.GetString("XmlPregenOrphanType", new object[] { type.FullName, assembly.Location }), "types");
}
}
return(TempAssembly.GenerateAssembly(mappings, types, null, null, XmlSerializerCompilerParameters.Create(parameters, true), assembly, new Hashtable()));
}
internal void AddImport(Type type, Hashtable types)
{
if (((type != null) && !TypeScope.IsKnownType(type)) && (types[type] == null))
{
types[type] = type;
Type baseType = type.BaseType;
if (baseType != null)
{
this.AddImport(baseType, types);
}
Type declaringType = type.DeclaringType;
if (declaringType != null)
{
this.AddImport(declaringType, types);
}
foreach (Type type4 in type.GetInterfaces())
{
this.AddImport(type4, types);
}
ConstructorInfo[] constructors = type.GetConstructors();
for (int i = 0; i < constructors.Length; i++)
{
ParameterInfo[] parameters = constructors[i].GetParameters();
for (int j = 0; j < parameters.Length; j++)
{
this.AddImport(parameters[j].ParameterType, types);
}
}
if (type.IsGenericType)
{
Type[] genericArguments = type.GetGenericArguments();
for (int k = 0; k < genericArguments.Length; k++)
{
this.AddImport(genericArguments[k], types);
}
}
TempAssembly.FileIOPermission.Assert();
Assembly a = type.Module.Assembly;
if (DynamicAssemblies.IsTypeDynamic(type))
{
DynamicAssemblies.Add(a);
}
else
{
object[] customAttributes = type.GetCustomAttributes(typeof(TypeForwardedFromAttribute), false);
if (customAttributes.Length > 0)
{
TypeForwardedFromAttribute attribute = customAttributes[0] as TypeForwardedFromAttribute;
Assembly assembly2 = Assembly.Load(attribute.AssemblyFullName);
this.imports[assembly2] = assembly2.Location;
}
this.imports[a] = a.Location;
}
}
}
private string WriteAssemblyInfo(Type type)
{
string fullName = type.Assembly.FullName;
string str2 = (string)this.reflectionVariables[fullName];
if (str2 == null)
{
int index = fullName.IndexOf(',');
string str3 = (index > -1) ? fullName.Substring(0, index) : fullName;
str2 = this.GenerateVariableName("assembly", str3);
this.writer.Write("static " + typeof(Assembly).FullName + " " + str2 + " = ResolveDynamicAssembly(");
this.WriteQuotedCSharpString(DynamicAssemblies.GetName(type.Assembly));
this.writer.WriteLine(");");
this.reflectionVariables.Add(fullName, str2);
}
return(str2);
}
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));
}
internal void GenerateSupportedTypes(Type[] types)
{
_writer.Write("public override ");
_writer.Write(typeof(bool).FullName);
_writer.Write(" CanSerialize(");
_writer.Write(typeof(Type).FullName);
_writer.WriteLine(" type) {");
_writer.Indent++;
Hashtable uniqueTypes = new Hashtable();
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (type == null)
{
continue;
}
if (!type.IsPublic && !type.IsNestedPublic)
{
continue;
}
if (uniqueTypes[type] != null)
{
continue;
}
if (DynamicAssemblies.IsTypeDynamic(type))
{
continue;
}
if (type.IsGenericType || type.ContainsGenericParameters && DynamicAssemblies.IsTypeDynamic(type.GetGenericArguments()))
{
continue;
}
uniqueTypes[type] = type;
_writer.Write("if (type == typeof(");
_writer.Write(CodeIdentifier.GetCSharpName(type));
_writer.WriteLine(")) return true;");
}
_writer.WriteLine("return false;");
_writer.Indent--;
_writer.WriteLine("}");
}
//GenerateGetSerializer(serializers, xmlMappings);
private void GenerateGetSerializer(Hashtable serializers, XmlMapping[] xmlMappings)
{
_writer.Write("public override ");
_writer.Write(typeof(System.Xml.Serialization.XmlSerializer).FullName);
_writer.Write(" GetSerializer(");
_writer.Write(typeof(Type).FullName);
_writer.WriteLine(" type) {");
_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)
{
continue;
}
if (!type.IsPublic && !type.IsNestedPublic)
{
continue;
}
if (DynamicAssemblies.IsTypeDynamic(type))
{
continue;
}
if (type.IsGenericType || type.ContainsGenericParameters && DynamicAssemblies.IsTypeDynamic(type.GetGenericArguments()))
{
continue;
}
_writer.Write("if (type == typeof(");
_writer.Write(CodeIdentifier.GetCSharpName(type));
_writer.Write(")) return new ");
_writer.Write((string)serializers[xmlMappings[i].Key]);
_writer.WriteLine("();");
}
}
_writer.WriteLine("return null;");
_writer.Indent--;
_writer.WriteLine("}");
}
internal static Assembly GenerateAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Evidence evidence, XmlSerializerCompilerParameters parameters, Assembly assembly, Hashtable assemblies)
{
FileIOPermission.Assert();
Compiler compiler = new Compiler();
try {
Hashtable scopeTable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
TypeScope[] scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
assemblies.Clear();
Hashtable importedTypes = new Hashtable();
foreach (TypeScope scope in scopes)
{
foreach (Type t in scope.Types)
{
compiler.AddImport(t, importedTypes);
Assembly a = t.Assembly;
string name = a.FullName;
if (assemblies[name] != null)
{
continue;
}
if (!a.GlobalAssemblyCache)
{
assemblies[name] = a;
}
}
}
for (int i = 0; i < types.Length; i++)
{
compiler.AddImport(types[i], importedTypes);
}
compiler.AddImport(typeof(object).Assembly);
compiler.AddImport(typeof(XmlSerializer).Assembly);
IndentedWriter writer = new IndentedWriter(compiler.Source, false);
writer.WriteLine("#if _DYNAMIC_XMLSERIALIZER_COMPILATION");
writer.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
writer.WriteLine("[assembly:System.Security.SecurityTransparent()]");
writer.WriteLine("[assembly:System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)]");
writer.WriteLine("#endif");
// Add AssemblyVersion attribute to match parent accembly version
if (types != null && types.Length > 0 && types[0] != null)
{
writer.WriteLine("[assembly:System.Reflection.AssemblyVersionAttribute(\"" + types[0].Assembly.GetName().Version.ToString() + "\")]");
}
if (assembly != null && types.Length > 0)
{
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (type == null)
{
continue;
}
if (DynamicAssemblies.IsTypeDynamic(type))
{
throw new InvalidOperationException(Res.GetString(Res.XmlPregenTypeDynamic, types[i].FullName));
}
}
writer.Write("[assembly:");
writer.Write(typeof(XmlSerializerVersionAttribute).FullName);
writer.Write("(");
writer.Write("ParentAssemblyId=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, GenerateAssemblyId(types[0]));
writer.Write(", Version=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, ThisAssembly.Version);
if (defaultNamespace != null)
{
writer.Write(", Namespace=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, defaultNamespace);
}
writer.WriteLine(")]");
}
CodeIdentifiers classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string suffix = null;
if (types != null && types.Length == 1 && types[0] != null)
{
suffix = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
suffix += "Array";
}
}
writer.WriteLine("namespace " + GeneratedAssemblyNamespace + " {");
writer.Indent++;
writer.WriteLine();
string writerClass = "XmlSerializationWriter" + suffix;
writerClass = classes.AddUnique(writerClass, writerClass);
XmlSerializationWriterCodeGen writerCodeGen = new XmlSerializationWriterCodeGen(writer, scopes, "public", writerClass);
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
writerCodeGen.GenerateEnd();
writer.WriteLine();
string readerClass = "XmlSerializationReader" + suffix;
readerClass = classes.AddUnique(readerClass, readerClass);
XmlSerializationReaderCodeGen readerCodeGen = new XmlSerializationReaderCodeGen(writer, scopes, "public", readerClass);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd(readMethodNames, xmlMappings, types);
string baseSerializer = readerCodeGen.GenerateBaseSerializer("XmlSerializer1", readerClass, writerClass, classes);
Hashtable serializers = new Hashtable();
for (int i = 0; i < xmlMappings.Length; i++)
{
if (serializers[xmlMappings[i].Key] == null)
{
serializers[xmlMappings[i].Key] = readerCodeGen.GenerateTypedSerializer(readMethodNames[i], writeMethodNames[i], xmlMappings[i], classes, baseSerializer, readerClass, writerClass);
}
}
readerCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, readerClass, readMethodNames, writerClass, writeMethodNames, serializers);
writer.Indent--;
writer.WriteLine("}");
return(compiler.Compile(assembly, defaultNamespace, parameters, evidence));
}
finally {
compiler.Close();
}
}
// SxS: This method does not take any resource name and does not expose any resources to the caller.
// It's OK to suppress the SxS warning.
internal void AddImport(Type type, Hashtable types)
{
if (type == null)
{
return;
}
if (TypeScope.IsKnownType(type))
{
return;
}
if (types[type] != null)
{
return;
}
types[type] = type;
Type baseType = type.GetTypeInfo().BaseType;
if (baseType != null)
{
AddImport(baseType, types);
}
Type declaringType = type.DeclaringType;
if (declaringType != null)
{
AddImport(declaringType, types);
}
foreach (Type intf in type.GetInterfaces())
{
AddImport(intf, types);
}
ConstructorInfo[] ctors = type.GetConstructors();
for (int i = 0; i < ctors.Length; i++)
{
ParameterInfo[] parms = ctors[i].GetParameters();
for (int j = 0; j < parms.Length; j++)
{
AddImport(parms[j].ParameterType, types);
}
}
if (type.GetTypeInfo().IsGenericType)
{
Type[] arguments = type.GetGenericArguments();
for (int i = 0; i < arguments.Length; i++)
{
AddImport(arguments[i], types);
}
}
Module module = type.GetTypeInfo().Module;
Assembly assembly = module.Assembly;
if (DynamicAssemblies.IsTypeDynamic(type))
{
DynamicAssemblies.Add(assembly);
return;
}
object[] typeForwardedFromAttribute = type.GetCustomAttributes(typeof(TypeForwardedFromAttribute), false);
if (typeForwardedFromAttribute.Length > 0)
{
TypeForwardedFromAttribute originalAssemblyInfo = typeForwardedFromAttribute[0] as TypeForwardedFromAttribute;
Assembly originalAssembly = Assembly.Load(new AssemblyName(originalAssemblyInfo.AssemblyFullName));
//_imports[originalAssembly] = originalAssembly.Location;
}
//_imports[assembly] = assembly.Location;
}
internal static bool GenerateSerializerToStream(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Assembly assembly, Hashtable assemblies, Stream stream)
{
var compiler = new Compiler();
try
{
var scopeTable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
var scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
assemblies.Clear();
var importedTypes = new Hashtable();
foreach (TypeScope scope in scopes)
{
foreach (Type t in scope.Types)
{
compiler.AddImport(t, importedTypes);
Assembly a = t.Assembly;
string name = a.FullName;
if (assemblies[name] != null)
{
continue;
}
assemblies[name] = a;
}
}
for (int i = 0; i < types.Length; i++)
{
compiler.AddImport(types[i], importedTypes);
}
compiler.AddImport(typeof(object).Assembly);
compiler.AddImport(typeof(System.Xml.Serialization.XmlSerializer).Assembly);
var writer = new IndentedWriter(compiler.Source, false);
writer.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
writer.WriteLine("[assembly:System.Security.SecurityTransparent()]");
writer.WriteLine("[assembly:System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)]");
if (assembly != null && types.Length > 0)
{
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (type == null)
{
continue;
}
if (DynamicAssemblies.IsTypeDynamic(type))
{
throw new InvalidOperationException(SR.Format(SR.XmlPregenTypeDynamic, types[i].FullName));
}
}
writer.Write("[assembly:");
writer.Write(typeof(XmlSerializerVersionAttribute).FullName);
writer.Write("(");
writer.Write("ParentAssemblyId=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, GenerateAssemblyId(types[0]));
writer.Write(", Version=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, ThisAssembly.Version);
if (defaultNamespace != null)
{
writer.Write(", Namespace=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, defaultNamespace);
}
writer.WriteLine(")]");
}
var classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string suffix = null;
if (types != null && types.Length == 1 && types[0] != null)
{
suffix = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
suffix += "Array";
}
}
writer.WriteLine("namespace " + GeneratedAssemblyNamespace + " {");
writer.Indent++;
writer.WriteLine();
string writerClass = "XmlSerializationWriter" + suffix;
writerClass = classes.AddUnique(writerClass, writerClass);
var writerCodeGen = new XmlSerializationWriterCodeGen(writer, scopes, "public", writerClass);
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
writerCodeGen.GenerateEnd();
writer.WriteLine();
string readerClass = "XmlSerializationReader" + suffix;
readerClass = classes.AddUnique(readerClass, readerClass);
var readerCodeGen = new XmlSerializationReaderCodeGen(writer, scopes, "public", readerClass);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd(readMethodNames, xmlMappings, types);
string baseSerializer = readerCodeGen.GenerateBaseSerializer("XmlSerializer1", readerClass, writerClass, classes);
var serializers = new Hashtable();
for (int i = 0; i < xmlMappings.Length; i++)
{
if (serializers[xmlMappings[i].Key] == null)
{
serializers[xmlMappings[i].Key] = readerCodeGen.GenerateTypedSerializer(readMethodNames[i], writeMethodNames[i], xmlMappings[i], classes, baseSerializer, readerClass, writerClass);
}
}
readerCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, readerClass, readMethodNames, writerClass, writeMethodNames, serializers);
writer.Indent--;
writer.WriteLine("}");
string codecontent = compiler.Source.ToString();
byte[] info = new UTF8Encoding(true).GetBytes(codecontent);
stream.Write(info, 0, info.Length);
stream.Flush();
return(true);
}
finally
{
compiler.Close();
}
}
internal void GenerateSupportedTypes(Type[] types)
{
this.writer.Write("public override ");
this.writer.Write(typeof(bool).FullName);
this.writer.Write(" CanSerialize(");
this.writer.Write(typeof(Type).FullName);
this.writer.WriteLine(" type) {");
this.writer.Indent++;
Hashtable hashtable = new Hashtable();
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (((type != null) && (type.IsPublic || type.IsNestedPublic)) && ((((hashtable[type] == null) && !DynamicAssemblies.IsTypeDynamic(type)) && !type.IsGenericType) && (!type.ContainsGenericParameters || !DynamicAssemblies.IsTypeDynamic(type.GetGenericArguments()))))
{
hashtable[type] = type;
this.writer.Write("if (type == typeof(");
this.writer.Write(CodeIdentifier.GetCSharpName(type));
this.writer.WriteLine(")) return true;");
}
}
this.writer.WriteLine("return false;");
this.writer.Indent--;
this.writer.WriteLine("}");
}
internal void AddImport(Type type, Hashtable types)
{
if (type == null)
{
return;
}
if (TypeScope.IsKnownType(type))
{
return;
}
if (types[type] != null)
{
return;
}
types[type] = type;
Type baseType = type.BaseType;
if (baseType != null)
{
AddImport(baseType, types);
}
Type declaringType = type.DeclaringType;
if (declaringType != null)
{
AddImport(declaringType, types);
}
foreach (Type intf in type.GetInterfaces())
{
AddImport(intf, types);
}
ConstructorInfo[] ctors = type.GetConstructors();
for (int i = 0; i < ctors.Length; i++)
{
ParameterInfo[] parms = ctors[i].GetParameters();
for (int j = 0; j < parms.Length; j++)
{
AddImport(parms[j].ParameterType, types);
}
}
if (type.IsGenericType)
{
Type[] arguments = type.GetGenericArguments();
for (int i = 0; i < arguments.Length; i++)
{
AddImport(arguments[i], types);
}
}
TempAssembly.FileIOPermission.Assert();
Module module = type.Module;
Assembly assembly = module.Assembly;
if (DynamicAssemblies.IsTypeDynamic(type))
{
DynamicAssemblies.Add(assembly);
return;
}
imports[assembly] = assembly.Location;
}
private TypeDesc ImportTypeDesc(Type type, MemberInfo memberInfo, bool directReference)
{
TypeDesc desc = null;
TypeKind root;
Type elementType = null;
Type baseType = null;
TypeFlags none = TypeFlags.None;
Exception exception = null;
if (!type.IsPublic && !type.IsNestedPublic)
{
none |= TypeFlags.Unsupported;
exception = new InvalidOperationException(Res.GetString("XmlTypeInaccessible", new object[] { type.FullName }));
}
else if (type.IsAbstract && type.IsSealed)
{
none |= TypeFlags.Unsupported;
exception = new InvalidOperationException(Res.GetString("XmlTypeStatic", new object[] { type.FullName }));
}
if (DynamicAssemblies.IsTypeDynamic(type))
{
none |= TypeFlags.UseReflection;
}
if (!type.IsValueType)
{
none |= TypeFlags.Reference;
}
if (type == typeof(object))
{
root = TypeKind.Root;
none |= TypeFlags.HasDefaultConstructor;
}
else if (type == typeof(ValueType))
{
root = TypeKind.Enum;
none |= TypeFlags.Unsupported;
if (exception == null)
{
exception = new NotSupportedException(Res.GetString("XmlSerializerUnsupportedType", new object[] { type.FullName }));
}
}
else if (type == typeof(void))
{
root = TypeKind.Void;
}
else if (typeof(IXmlSerializable).IsAssignableFrom(type))
{
root = TypeKind.Serializable;
none |= TypeFlags.CanBeElementValue | TypeFlags.Special;
none |= GetConstructorFlags(type, ref exception);
}
else if (type.IsArray)
{
root = TypeKind.Array;
if (type.GetArrayRank() > 1)
{
none |= TypeFlags.Unsupported;
if (exception == null)
{
exception = new NotSupportedException(Res.GetString("XmlUnsupportedRank", new object[] { type.FullName }));
}
}
elementType = type.GetElementType();
none |= TypeFlags.HasDefaultConstructor;
}
else if (typeof(ICollection).IsAssignableFrom(type))
{
root = TypeKind.Collection;
elementType = GetCollectionElementType(type, (memberInfo == null) ? null : (memberInfo.DeclaringType.FullName + "." + memberInfo.Name));
none |= GetConstructorFlags(type, ref exception);
}
else if (type == typeof(XmlQualifiedName))
{
root = TypeKind.Primitive;
}
else if (type.IsPrimitive)
{
root = TypeKind.Primitive;
none |= TypeFlags.Unsupported;
if (exception == null)
{
exception = new NotSupportedException(Res.GetString("XmlSerializerUnsupportedType", new object[] { type.FullName }));
}
}
else if (type.IsEnum)
{
root = TypeKind.Enum;
}
else if (type.IsValueType)
{
root = TypeKind.Struct;
if (IsOptionalValue(type))
{
baseType = type.GetGenericArguments()[0];
none |= TypeFlags.OptionalValue;
}
else
{
baseType = type.BaseType;
}
if (type.IsAbstract)
{
none |= TypeFlags.Abstract;
}
}
else if (type.IsClass)
{
if (type == typeof(XmlAttribute))
{
root = TypeKind.Attribute;
none |= TypeFlags.CanBeAttributeValue | TypeFlags.Special;
}
else if (typeof(XmlNode).IsAssignableFrom(type))
{
root = TypeKind.Node;
baseType = type.BaseType;
none |= TypeFlags.CanBeElementValue | TypeFlags.CanBeTextValue | TypeFlags.Special;
if (typeof(XmlText).IsAssignableFrom(type))
{
none &= ~TypeFlags.CanBeElementValue;
}
else if (typeof(XmlElement).IsAssignableFrom(type))
{
none &= ~TypeFlags.CanBeTextValue;
}
else if (type.IsAssignableFrom(typeof(XmlAttribute)))
{
none |= TypeFlags.CanBeAttributeValue;
}
}
else
{
root = TypeKind.Class;
baseType = type.BaseType;
if (type.IsAbstract)
{
none |= TypeFlags.Abstract;
}
}
}
else if (type.IsInterface)
{
root = TypeKind.Void;
none |= TypeFlags.Unsupported;
if (exception == null)
{
if (memberInfo == null)
{
exception = new NotSupportedException(Res.GetString("XmlUnsupportedInterface", new object[] { type.FullName }));
}
else
{
exception = new NotSupportedException(Res.GetString("XmlUnsupportedInterfaceDetails", new object[] { memberInfo.DeclaringType.FullName + "." + memberInfo.Name, type.FullName }));
}
}
}
else
{
root = TypeKind.Void;
none |= TypeFlags.Unsupported;
if (exception == null)
{
exception = new NotSupportedException(Res.GetString("XmlSerializerUnsupportedType", new object[] { type.FullName }));
}
}
if ((root == TypeKind.Class) && !type.IsAbstract)
{
none |= GetConstructorFlags(type, ref exception);
}
if (((root == TypeKind.Struct) || (root == TypeKind.Class)) && typeof(IEnumerable).IsAssignableFrom(type))
{
elementType = GetEnumeratorElementType(type, ref none);
root = TypeKind.Enumerable;
none |= GetConstructorFlags(type, ref exception);
}
desc = new TypeDesc(type, CodeIdentifier.MakeValid(TypeName(type)), type.ToString(), root, null, none, null)
{
Exception = exception
};
if (directReference && (desc.IsClass || (root == TypeKind.Serializable)))
{
desc.CheckNeedConstructor();
}
if (!desc.IsUnsupported)
{
this.typeDescs.Add(type, desc);
if (elementType != null)
{
TypeDesc desc2 = this.GetTypeDesc(elementType, memberInfo, true, false);
if ((directReference && (desc2.IsCollection || desc2.IsEnumerable)) && !desc2.IsPrimitive)
{
desc2.CheckNeedConstructor();
}
desc.ArrayElementTypeDesc = desc2;
}
if (((baseType != null) && (baseType != typeof(object))) && (baseType != typeof(ValueType)))
{
desc.BaseTypeDesc = this.GetTypeDesc(baseType, memberInfo, false, false);
}
if (type.IsNestedPublic)
{
for (Type type4 = type.DeclaringType; (type4 != null) && !type4.ContainsGenericParameters; type4 = type4.DeclaringType)
{
this.GetTypeDesc(type4, null, false);
}
}
}
return(desc);
}
internal static Assembly GenerateAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Evidence evidence, XmlSerializerCompilerParameters parameters, Assembly assembly, Hashtable assemblies)
{
Assembly assembly3;
FileIOPermission.Assert();
for (int i = 0; i < xmlMappings.Length; i++)
{
xmlMappings[i].CheckShallow();
}
Compiler compiler = new Compiler();
try
{
Hashtable hashtable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
hashtable[mapping.Scope] = mapping;
}
TypeScope[] array = new TypeScope[hashtable.Keys.Count];
hashtable.Keys.CopyTo(array, 0);
assemblies.Clear();
Hashtable hashtable2 = new Hashtable();
foreach (TypeScope scope in array)
{
foreach (Type type in scope.Types)
{
compiler.AddImport(type, hashtable2);
Assembly assembly2 = type.Assembly;
string fullName = assembly2.FullName;
if ((assemblies[fullName] == null) && !assembly2.GlobalAssemblyCache)
{
assemblies[fullName] = assembly2;
}
}
}
for (int j = 0; j < types.Length; j++)
{
compiler.AddImport(types[j], hashtable2);
}
compiler.AddImport(typeof(object).Assembly);
compiler.AddImport(typeof(XmlSerializer).Assembly);
IndentedWriter writer = new IndentedWriter(compiler.Source, false);
writer.WriteLine("#if _DYNAMIC_XMLSERIALIZER_COMPILATION");
writer.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
writer.WriteLine("[assembly:System.Security.SecurityTransparent()]");
writer.WriteLine("[assembly:System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)]");
writer.WriteLine("#endif");
if (((types != null) && (types.Length > 0)) && (types[0] != null))
{
writer.WriteLine("[assembly:System.Reflection.AssemblyVersionAttribute(\"" + types[0].Assembly.GetName().Version.ToString() + "\")]");
}
if ((assembly != null) && (types.Length > 0))
{
for (int num3 = 0; num3 < types.Length; num3++)
{
Type type2 = types[num3];
if ((type2 != null) && DynamicAssemblies.IsTypeDynamic(type2))
{
throw new InvalidOperationException(Res.GetString("XmlPregenTypeDynamic", new object[] { types[num3].FullName }));
}
}
writer.Write("[assembly:");
writer.Write(typeof(XmlSerializerVersionAttribute).FullName);
writer.Write("(");
writer.Write("ParentAssemblyId=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, GenerateAssemblyId(types[0]));
writer.Write(", Version=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, "4.0.0.0");
if (defaultNamespace != null)
{
writer.Write(", Namespace=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, defaultNamespace);
}
writer.WriteLine(")]");
}
CodeIdentifiers classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string str2 = null;
if (((types != null) && (types.Length == 1)) && (types[0] != null))
{
str2 = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
str2 = str2 + "Array";
}
}
writer.WriteLine("namespace Microsoft.Xml.Serialization.GeneratedAssembly {");
writer.Indent++;
writer.WriteLine();
string identifier = "XmlSerializationWriter" + str2;
identifier = classes.AddUnique(identifier, identifier);
XmlSerializationWriterCodeGen gen = new XmlSerializationWriterCodeGen(writer, array, "public", identifier);
gen.GenerateBegin();
string[] writerMethods = new string[xmlMappings.Length];
for (int k = 0; k < xmlMappings.Length; k++)
{
writerMethods[k] = gen.GenerateElement(xmlMappings[k]);
}
gen.GenerateEnd();
writer.WriteLine();
string str4 = "XmlSerializationReader" + str2;
str4 = classes.AddUnique(str4, str4);
XmlSerializationReaderCodeGen gen2 = new XmlSerializationReaderCodeGen(writer, array, "public", str4);
gen2.GenerateBegin();
string[] methods = new string[xmlMappings.Length];
for (int m = 0; m < xmlMappings.Length; m++)
{
methods[m] = gen2.GenerateElement(xmlMappings[m]);
}
gen2.GenerateEnd(methods, xmlMappings, types);
string baseSerializer = gen2.GenerateBaseSerializer("XmlSerializer1", str4, identifier, classes);
Hashtable serializers = new Hashtable();
for (int n = 0; n < xmlMappings.Length; n++)
{
if (serializers[xmlMappings[n].Key] == null)
{
serializers[xmlMappings[n].Key] = gen2.GenerateTypedSerializer(methods[n], writerMethods[n], xmlMappings[n], classes, baseSerializer, str4, identifier);
}
}
gen2.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, str4, methods, identifier, writerMethods, serializers);
writer.Indent--;
writer.WriteLine("}");
assembly3 = compiler.Compile(assembly, defaultNamespace, parameters, evidence);
}
finally
{
compiler.Close();
}
return assembly3;
}
