The Labs \ Source Viewer \ SSCLI \ System.Xml.Serialization \ SchemaImporter

  1. //------------------------------------------------------------------------------
  2. // <copyright file="SchemaImporter.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Xml.Serialization
  16. {
  17.    
  18.     using System;
  19.     using System.Xml.Schema;
  20.     using System.Collections;
  21.     using System.ComponentModel;
  22.     using System.Reflection;
  23.     using System.Configuration;
  24.     using System.Xml.Serialization.Configuration;
  25.     using System.CodeDom;
  26.     using System.CodeDom.Compiler;
  27.     using System.Security.Permissions;
  28.     using System.Xml.Serialization.Advanced;
  29.    
  30.     #if DEBUG
  31.     using System.Diagnostics;
  32.     #endif
  33.    
  34.     /// <include file='doc\SchemaImporter.uex' path='docs/doc[@for="SchemaImporter"]/*' />
  35.     ///<internalonly/>
  36.     /// <devdoc>
  37.     /// <para>[To be supplied.]</para>
  38.     /// </devdoc>
  39.     [PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")]
  40.     public abstract class SchemaImporter
  41.     {
  42.         XmlSchemas schemas;
  43.         StructMapping root;
  44.         CodeGenerationOptions options;
  45.         CodeDomProvider codeProvider;
  46.         TypeScope scope;
  47.         ImportContext context;
  48.         bool rootImported;
  49.         NameTable typesInUse;
  50.         NameTable groupsInUse;
  51.         SchemaImporterExtensionCollection extensions;
  52.        
  53.         internal SchemaImporter(XmlSchemas schemas, CodeGenerationOptions options, CodeDomProvider codeProvider, ImportContext context)
  54.         {
  55.             if (!schemas.Contains(XmlSchema.Namespace)) {
  56.                 schemas.AddReference(XmlSchemas.XsdSchema);
  57.                 schemas.SchemaSet.Add(XmlSchemas.XsdSchema);
  58.             }
  59.             if (!schemas.Contains(XmlReservedNs.NsXml)) {
  60.                 schemas.AddReference(XmlSchemas.XmlSchema);
  61.                 schemas.SchemaSet.Add(XmlSchemas.XmlSchema);
  62.             }
  63.             this.schemas = schemas;
  64.             this.options = options;
  65.             this.codeProvider = codeProvider;
  66.             this.context = context;
  67.             Schemas.SetCache(Context.Cache, Context.ShareTypes);
  68.            
  69.             SchemaImporterExtensionsSection section = PrivilegedConfigurationManager.GetSection(ConfigurationStrings.SchemaImporterExtensionsSectionPath) as SchemaImporterExtensionsSection;
  70.             if (section != null)
  71.                 extensions = section.SchemaImporterExtensionsInternal;
  72.             else
  73.                 extensions = new SchemaImporterExtensionCollection();
  74.         }
  75.        
  76.         internal ImportContext Context {
  77.             get {
  78.                 if (context == null)
  79.                     context = new ImportContext();
  80.                 return context;
  81.             }
  82.         }
  83.        
  84.         internal CodeDomProvider CodeProvider {
  85.             get {
  86.                 if (codeProvider == null)
  87.                     codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
  88.                 return codeProvider;
  89.             }
  90.         }
  91.        
  92.         public SchemaImporterExtensionCollection Extensions {
  93.             get {
  94.                 if (extensions == null)
  95.                     extensions = new SchemaImporterExtensionCollection();
  96.                 return extensions;
  97.             }
  98.         }
  99.        
  100.         internal Hashtable ImportedElements {
  101.             get { return Context.Elements; }
  102.         }
  103.        
  104.         internal Hashtable ImportedMappings {
  105.             get { return Context.Mappings; }
  106.         }
  107.        
  108.         internal CodeIdentifiers TypeIdentifiers {
  109.             get { return Context.TypeIdentifiers; }
  110.         }
  111.        
  112.         internal XmlSchemas Schemas {
  113.             get {
  114.                 if (schemas == null)
  115.                     schemas = new XmlSchemas();
  116.                 return schemas;
  117.             }
  118.         }
  119.        
  120.         internal TypeScope Scope {
  121.             get {
  122.                 if (scope == null)
  123.                     scope = new TypeScope();
  124.                 return scope;
  125.             }
  126.         }
  127.        
  128.         internal NameTable GroupsInUse {
  129.             get {
  130.                 if (groupsInUse == null)
  131.                     groupsInUse = new NameTable();
  132.                 return groupsInUse;
  133.             }
  134.         }
  135.        
  136.         internal NameTable TypesInUse {
  137.             get {
  138.                 if (typesInUse == null)
  139.                     typesInUse = new NameTable();
  140.                 return typesInUse;
  141.             }
  142.         }
  143.        
  144.         internal CodeGenerationOptions Options {
  145.             get { return options; }
  146.         }
  147.        
  148.         internal void MakeDerived(StructMapping structMapping, Type baseType, bool baseTypeCanBeIndirect)
  149.         {
  150.             structMapping.ReferencedByTopLevelElement = true;
  151.             TypeDesc baseTypeDesc;
  152.             if (baseType != null) {
  153.                 baseTypeDesc = Scope.GetTypeDesc(baseType);
  154.                 if (baseTypeDesc != null) {
  155.                     TypeDesc typeDescToChange = structMapping.TypeDesc;
  156.                     if (baseTypeCanBeIndirect) {
  157.                         // if baseTypeCanBeIndirect is true, we apply the supplied baseType to the top of the
  158.                         // inheritance chain, not necessarily directly to the imported type.
  159.                         while (typeDescToChange.BaseTypeDesc != null && typeDescToChange.BaseTypeDesc != baseTypeDesc)
  160.                             typeDescToChange = typeDescToChange.BaseTypeDesc;
  161.                     }
  162.                     if (typeDescToChange.BaseTypeDesc != null && typeDescToChange.BaseTypeDesc != baseTypeDesc)
  163.                         throw new InvalidOperationException(Res.GetString(Res.XmlInvalidBaseType, structMapping.TypeDesc.FullName, baseType.FullName, typeDescToChange.BaseTypeDesc.FullName));
  164.                     typeDescToChange.BaseTypeDesc = baseTypeDesc;
  165.                 }
  166.             }
  167.         }
  168.        
  169.         internal string GenerateUniqueTypeName(string typeName)
  170.         {
  171.             typeName = CodeIdentifier.MakeValid(typeName);
  172.             return TypeIdentifiers.AddUnique(typeName, typeName);
  173.         }
  174.        
  175.         StructMapping CreateRootMapping()
  176.         {
  177.             TypeDesc typeDesc = Scope.GetTypeDesc(typeof(object));
  178.             StructMapping mapping = new StructMapping();
  179.             mapping.TypeDesc = typeDesc;
  180.             mapping.Members = new MemberMapping[0];
  181.             mapping.IncludeInSchema = false;
  182.             mapping.TypeName = Soap.UrType;
  183.             mapping.Namespace = XmlSchema.Namespace;
  184.            
  185.             return mapping;
  186.         }
  187.        
  188.         internal StructMapping GetRootMapping()
  189.         {
  190.             if (root == null)
  191.                 root = CreateRootMapping();
  192.             return root;
  193.         }
  194.        
  195.         internal StructMapping ImportRootMapping()
  196.         {
  197.             if (!rootImported) {
  198.                 rootImported = true;
  199.                 ImportDerivedTypes(XmlQualifiedName.Empty);
  200.             }
  201.             return GetRootMapping();
  202.         }
  203.        
  204.         internal abstract void ImportDerivedTypes(XmlQualifiedName baseName);
  205.        
  206.         internal void AddReference(XmlQualifiedName name, NameTable references, string error)
  207.         {
  208.             if (name.Namespace == XmlSchema.Namespace)
  209.                 return;
  210.             if (references[name] != null) {
  211.                 throw new InvalidOperationException(Res.GetString(error, name.Name, name.Namespace));
  212.             }
  213.             references[name] = name;
  214.         }
  215.        
  216.         internal void RemoveReference(XmlQualifiedName name, NameTable references)
  217.         {
  218.             references[name] = null;
  219.         }
  220.        
  221.         internal void AddReservedIdentifiersForDataBinding(CodeIdentifiers scope)
  222.         {
  223.             if ((options & CodeGenerationOptions.EnableDataBinding) != 0) {
  224.                 scope.AddReserved(CodeExporter.PropertyChangedEvent.Name);
  225.                 scope.AddReserved(CodeExporter.RaisePropertyChangedEventMethod.Name);
  226.             }
  227.         }
  228.        
  229.     }
  230. }

Developer Fusion