C# Serialization.TempAssembly類代碼示例

 /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public XmlSerializer(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace) {
     XmlReflectionImporter importer = new XmlReflectionImporter(overrides, defaultNamespace);
     for (int i = 0; i < extraTypes.Length; i++)
         importer.IncludeType(extraTypes[i]);
     tempAssembly = GenerateTempAssembly(importer.ImportTypeMapping(type, root));
     this.events.sender = this;
 }

 public XmlSerializer CreateSerializer(Type type, string defaultNamespace)
 {
     if (type == null)
     {
         throw new ArgumentNullException("type");
     }
     TempAssembly assembly = cache[defaultNamespace, type];
     XmlTypeMapping xmlMapping = null;
     if (assembly == null)
     {
         lock (cache)
         {
             assembly = cache[defaultNamespace, type];
             if (assembly == null)
             {
                 XmlSerializerImplementation implementation;
                 if (TempAssembly.LoadGeneratedAssembly(type, defaultNamespace, out implementation) == null)
                 {
                     xmlMapping = new XmlReflectionImporter(defaultNamespace).ImportTypeMapping(type, null, defaultNamespace);
                     assembly = XmlSerializer.GenerateTempAssembly(xmlMapping, type, defaultNamespace);
                 }
                 else
                 {
                     assembly = new TempAssembly(implementation);
                 }
                 cache.Add(defaultNamespace, type, assembly);
             }
         }
     }
     if (xmlMapping == null)
     {
         xmlMapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
     }
     return assembly.Contract.GetSerializer(type);
 }

 // this method must be called before any generated serialization methods are called
 internal void Init(XmlWriter w, XmlSerializerNamespaces namespaces, string encodingStyle, string idBase, TempAssembly tempAssembly) {
     this.w = w;
     this.namespaces = namespaces;
     this.soap12 = (encodingStyle == Soap12.Encoding);
     this.idBase = idBase;
     Init(tempAssembly);
 }

 internal void Init(TempAssembly tempAssembly)
 {
     this.tempAssembly = tempAssembly;
     if ((tempAssembly != null) && tempAssembly.NeedAssembyResolve)
     {
         this.threadCode = Thread.CurrentThread.GetHashCode();
         this.assemblyResolver = new ResolveEventHandler(this.OnAssemblyResolve);
         AppDomain.CurrentDomain.AssemblyResolve += this.assemblyResolver;
     }
 }

 internal void Init(TempAssembly tempAssembly) {
     this.tempAssembly = tempAssembly;
     // only hook the assembly resolver if we have something to help us do the resolution
     if (tempAssembly != null && tempAssembly.NeedAssembyResolve) {
         // we save the threadcode to make sure we don't handle any resolve events for any other threads
         threadCode = Thread.CurrentThread.GetHashCode();
         assemblyResolver = new ResolveEventHandler(OnAssemblyResolve);
         AppDomain.CurrentDomain.AssemblyResolve += assemblyResolver;
     }
 }

 internal void Add(string ns, object o, TempAssembly assembly)
 {
     TempAssemblyCacheKey key = new TempAssemblyCacheKey(ns, o);
     lock (this)
     {
         if (this.cache[key] != assembly)
         {
             Hashtable hashtable = new Hashtable();
             foreach (object obj2 in this.cache.Keys)
             {
                 hashtable.Add(obj2, this.cache[obj2]);
             }
             this.cache = hashtable;
             this.cache[key] = assembly;
         }
     }
 }

 /// <include file='doc\XmlSerializerFactory.uex' path='docs/doc[@for="XmlSerializerFactory.CreateSerializer1"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public XmlSerializer CreateSerializer(Type type, string defaultNamespace)
 {
     if (type == null)
         throw new ArgumentNullException(nameof(type));
     TempAssembly tempAssembly = s_cache[defaultNamespace, type];
     XmlTypeMapping mapping = null;
     if (tempAssembly == null)
     {
         lock (s_cache)
         {
             tempAssembly = s_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);
                     mapping = importer.ImportTypeMapping(type, null, defaultNamespace);
                     tempAssembly = XmlSerializer.GenerateTempAssembly(mapping, type, defaultNamespace);
                 }
                 else
                 {
                     tempAssembly = new TempAssembly(contract);
                 }
                 s_cache.Add(defaultNamespace, type, tempAssembly);
             }
         }
     }
     if (mapping == null)
     {
         mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
     }
     return (XmlSerializer)tempAssembly.Contract.GetSerializer(type);
 }

 internal void SetTempAssembly(TempAssembly tempAssembly, XmlMapping mapping)
 {
     _tempAssembly = tempAssembly;
     _mapping = mapping;
     _typedSerializer = true;
 }

        private void Init(Type type, string defaultNamespace)
        {
            if (type == null)
                throw new ArgumentNullException(nameof(type));

            DefaultNamespace = defaultNamespace;
            rootType = type;

            _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);
            }
            else if (ReflectionMethodEnabled)
            {
                var importer = new XmlReflectionImporter(defaultNamespace);
                _mapping = importer.ImportTypeMapping(type, null, defaultNamespace);

                if (_mapping == null)
                {
                    _mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
                }
            }
#endif
        }

        /// <devdoc>
        ///    <para>[To be supplied.]</para>
        /// </devdoc>
        public static XmlSerializer[] FromMappings(XmlMapping[] mappings, Type type)
        {
            if (mappings == null || mappings.Length == 0) return Array.Empty<XmlSerializer>();

#if NET_NATIVE
            var serializers = new XmlSerializer[mappings.Length];
            for(int i=0;i<mappings.Length;i++)
            {
                serializers[i] = new XmlSerializer();
                serializers[i].rootType = type;
                serializers[i]._mapping = mappings[i];
            }

            return serializers;
#else
            XmlSerializerImplementation contract = null;
            TempAssembly tempAssembly = null;
            {
                if (XmlMapping.IsShallow(mappings))
                {
                    return Array.Empty<XmlSerializer>();
                }
                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.TypedSerializers[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);
                    }
                }
            }
#endif
        }

 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);
     for (int i = 0; i < extraTypes.Length; i++)
         importer.IncludeType(extraTypes[i]);
     this.mapping = importer.ImportTypeMapping(type, root, defaultNamespace);
     tempAssembly = GenerateTempAssembly(this.mapping, type, defaultNamespace, location, evidence);
 }

 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;
 }

        /// <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, string location, Evidence 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 (location != null || evidence != null)
            {
                DemandForUserLocationOrEvidence();
            }

#if !NET_NATIVE
            _tempAssembly = GenerateTempAssembly(_mapping, type, defaultNamespace, location, evidence);
#endif
        }

 /// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.FromMappings"]/*' />
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public static XmlSerializer[] FromMappings(XmlMapping[] mappings) {
     if (mappings.Length == 0) return new XmlSerializer[0];
     TempAssembly tempAssembly = new TempAssembly(mappings);
     XmlSerializer[] serializers = new XmlSerializer[mappings.Length];
     for (int i = 0; i < serializers.Length; i++)
         serializers[i] = new XmlSerializer(tempAssembly, i);
     return serializers;
 }

 internal void Add(string ns, object o, TempAssembly assembly) {
     TempAssemblyCacheKey key = new TempAssemblyCacheKey(ns, o);
     lock(this) {
         if (cache[key] == assembly) return;
         Hashtable clone = new Hashtable();
         foreach (object k in cache.Keys) {
             clone.Add(k, cache[k]);
         }
         cache = clone;
         cache[key] = assembly;
     }
 }