GenerateSerializerToStream()

static bool System.Xml.Serialization.TempAssembly.GenerateSerializerToStream ( XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Assembly assembly, Hashtable assemblies, Stream stream )

inlinestaticpackage

Definition at line 272 of file TempAssembly.cs.

    {
        Compiler compiler = new Compiler();
        try
        {
            Hashtable hashtable = new Hashtable();
            foreach (XmlMapping xmlMapping in xmlMappings)
            {
                hashtable[xmlMapping.Scope] = xmlMapping;
            }
            TypeScope[] array = new TypeScope[hashtable.Keys.Count];
            hashtable.Keys.CopyTo(array, 0);
            assemblies.Clear();
            Hashtable types2 = new Hashtable();
            TypeScope[] array2 = array;
            foreach (TypeScope typeScope in array2)
            {
                foreach (Type type3 in typeScope.Types)
                {
                    compiler.AddImport(type3, types2);
                    Assembly assembly2 = type3.Assembly;
                    string fullName = assembly2.FullName;
                    if (assemblies[fullName] == null)
                    {
                        assemblies[fullName] = assembly2;
                    }
                }
            }
            for (int k = 0; k < types.Length; k++)
            {
                compiler.AddImport(types[k], types2);
            }
            compiler.AddImport(typeof(object).Assembly);
            compiler.AddImport(typeof(XmlSerializer).Assembly);
            IndentedWriter indentedWriter = new IndentedWriter(compiler.Source, compact: false);
            indentedWriter.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
            indentedWriter.WriteLine("[assembly:System.Security.SecurityTransparent()]");
            indentedWriter.WriteLine("[assembly:System.Security.SecurityRules(System.Security.SecurityRuleSet.Level1)]");
            if (assembly != null && types.Length != 0)
            {
                for (int l = 0; l < types.Length; l++)
                {
                    Type type2 = types[l];
                    if (!(type2 == null) && DynamicAssemblies.IsTypeDynamic(type2))
                    {
                        throw new InvalidOperationException(System.SR.Format(System.SR.XmlPregenTypeDynamic, types[l].FullName));
                    }
                }
                indentedWriter.Write("[assembly:");
                indentedWriter.Write(typeof(XmlSerializerVersionAttribute).FullName);
                indentedWriter.Write("(");
                indentedWriter.Write("ParentAssemblyId=");
                ReflectionAwareCodeGen.WriteQuotedCSharpString(indentedWriter, GenerateAssemblyId(types[0]));
                indentedWriter.Write(", Version=");
                ReflectionAwareCodeGen.WriteQuotedCSharpString(indentedWriter, "1.0.0.0");
                if (defaultNamespace != null)
                {
                    indentedWriter.Write(", Namespace=");
                    ReflectionAwareCodeGen.WriteQuotedCSharpString(indentedWriter, defaultNamespace);
                }
                indentedWriter.WriteLine(")]");
            }
            CodeIdentifiers codeIdentifiers = new CodeIdentifiers();
            codeIdentifiers.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
            codeIdentifiers.AddUnique("XmlSerializationReader", "XmlSerializationReader");
            string text = null;
            if (types != null && types.Length == 1 && types[0] != null)
            {
                text = CodeIdentifier.MakeValid(types[0].Name);
                if (types[0].IsArray)
                {
                    text += "Array";
                }
            }
            indentedWriter.WriteLine("namespace Microsoft.Xml.Serialization.GeneratedAssembly {");
            indentedWriter.Indent++;
            indentedWriter.WriteLine();
            string text2 = "XmlSerializationWriter" + text;
            text2 = codeIdentifiers.AddUnique(text2, text2);
            XmlSerializationWriterCodeGen xmlSerializationWriterCodeGen = new XmlSerializationWriterCodeGen(indentedWriter, array, "public", text2);
            xmlSerializationWriterCodeGen.GenerateBegin();
            string[] array3 = new string[xmlMappings.Length];
            for (int m = 0; m < xmlMappings.Length; m++)
            {
                array3[m] = xmlSerializationWriterCodeGen.GenerateElement(xmlMappings[m]);
            }
            xmlSerializationWriterCodeGen.GenerateEnd();
            indentedWriter.WriteLine();
            string text3 = "XmlSerializationReader" + text;
            text3 = codeIdentifiers.AddUnique(text3, text3);
            XmlSerializationReaderCodeGen xmlSerializationReaderCodeGen = new XmlSerializationReaderCodeGen(indentedWriter, array, "public", text3);
            xmlSerializationReaderCodeGen.GenerateBegin();
            string[] array4 = new string[xmlMappings.Length];
            for (int n = 0; n < xmlMappings.Length; n++)
            {
                array4[n] = xmlSerializationReaderCodeGen.GenerateElement(xmlMappings[n]);
            }
            xmlSerializationReaderCodeGen.GenerateEnd(array4, xmlMappings, types);
            string baseSerializer = xmlSerializationReaderCodeGen.GenerateBaseSerializer("XmlSerializer1", text3, text2, codeIdentifiers);
            Hashtable hashtable2 = new Hashtable();
            for (int num = 0; num < xmlMappings.Length; num++)
            {
                if (hashtable2[xmlMappings[num].Key] == null)
                {
                    hashtable2[xmlMappings[num].Key] = xmlSerializationReaderCodeGen.GenerateTypedSerializer(array4[num], array3[num], xmlMappings[num], codeIdentifiers, baseSerializer, text3, text2);
                }
            }
            xmlSerializationReaderCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, text3, array4, text2, array3, hashtable2);
            indentedWriter.Indent--;
            indentedWriter.WriteLine("}");
            string s = compiler.Source.ToString();
            byte[] bytes = new UTF8Encoding(encoderShouldEmitUTF8Identifier: true).GetBytes(s);
            stream.Write(bytes, 0, bytes.Length);
            stream.Flush();
            return true;
        }
        finally
        {
            compiler.Close();
        }
    }

References System.array, System.bytes, System.Collections.Generic.Dictionary< TKey, TValue >.Clear(), System.Xml.Dictionary, System.SR.Format(), System.FullName, System.Xml.Serialization.TempAssembly.GenerateAssemblyId(), System.Reflection.Emit.IsArray, System.Xml.Serialization.DynamicAssemblies.IsTypeDynamic(), System.Xml.Serialization.CodeIdentifier.MakeValid(), System.Xml.Name, System.s, System.stream, System.text, System.Xml.Serialization.ReflectionAwareCodeGen.WriteQuotedCSharpString(), and System.SR.XmlPregenTypeDynamic.

Referenced by System.Xml.Serialization.XmlSerializer.GenerateSerializer().