The Labs \ Source Viewer \ SSCLI \ System.Xml.Serialization.Advanced \ MappedTypeDesc

  1. //------------------------------------------------------------------------------
  2. // <copyright file="IXmlSerializable.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. // <owner current="true" primary="true">ElenaK</owner>
  15. //------------------------------------------------------------------------------
  16. namespace System.Xml.Serialization.Advanced
  17. {
  18.    
  19.     using System.Xml.Schema;
  20.     using System.Xml;
  21.     using System.Collections;
  22.     using System.Collections.Specialized;
  23.     using System.CodeDom;
  24.     using System.CodeDom.Compiler;
  25.     using System.Xml.Serialization;
  26.    
  27.     /// <include file='doc\SchemaImporterExtension.uex' path='docs/doc[@for="SchemaImporterExtension"]/*' />
  28.     ///<internalonly/>
  29.     /// <devdoc>
  30.     /// <para>[To be supplied.]</para>
  31.     /// </devdoc>
  32.     public abstract class SchemaImporterExtension
  33.     {
  34.         /// <include file='doc\SchemaImporterExtension.uex' path='docs/doc[@for="SchemaImporterExtension.ImportSchemaType"]/*' />
  35.         public virtual string ImportSchemaType(string name, string ns, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider)
  36.         {
  37.             return null;
  38.         }
  39.        
  40.         /// <include file='doc\SchemaImporterExtension.uex' path='docs/doc[@for="SchemaImporterExtension.ImportSchemaType1"]/*' />
  41.         public virtual string ImportSchemaType(XmlSchemaType type, XmlSchemaObject context, XmlSchemas schemas, XmlSchemaImporter importer, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider)
  42.         {
  43.             return null;
  44.         }
  45.        
  46.         /// <include file='doc\SchemaImporterExtension.uex' path='docs/doc[@for="SchemaImporterExtension.ImportSchemaType1"]/*' />
  47.         public virtual string ImportAnyElement(XmlSchemaAny any, bool mixed, XmlSchemas schemas, XmlSchemaImporter importer, CodeCompileUnit compileUnit, CodeNamespace mainNamespace, CodeGenerationOptions options, CodeDomProvider codeProvider)
  48.         {
  49.             return null;
  50.         }
  51.        
  52.         /// <include file='doc\SchemaImporterExtension.uex' path='docs/doc[@for="SchemaImporterExtension.ImportDefaultValue"]/*' />
  53.         public virtual CodeExpression ImportDefaultValue(string value, string type)
  54.         {
  55.             return null;
  56.         }
  57.     }
  58.    
  59.     public class SchemaImporterExtensionCollection : CollectionBase
  60.     {
  61.         Hashtable exNames;
  62.        
  63.         internal Hashtable Names {
  64.             get {
  65.                 if (exNames == null)
  66.                     exNames = new Hashtable();
  67.                 return exNames;
  68.             }
  69.         }
  70.        
  71.         public int Add(SchemaImporterExtension extension)
  72.         {
  73.             return Add(extension.GetType().FullName, extension);
  74.         }
  75.        
  76.         public int Add(string name, Type type)
  77.         {
  78.             if (type.IsSubclassOf(typeof(SchemaImporterExtension))) {
  79.                 return Add(name, (SchemaImporterExtension)Activator.CreateInstance(type));
  80.             }
  81.             else {
  82.                 throw new ArgumentException(Res.GetString(Res.XmlInvalidSchemaExtension, type));
  83.             }
  84.         }
  85.        
  86.         public void Remove(string name)
  87.         {
  88.             if (Names[name] != null) {
  89.                 List.Remove(Names[name]);
  90.                 Names[name] = null;
  91.             }
  92.         }
  93.        
  94.         public new void Clear()
  95.         {
  96.             Names.Clear();
  97.             List.Clear();
  98.         }
  99.        
  100.         internal SchemaImporterExtensionCollection Clone()
  101.         {
  102.             SchemaImporterExtensionCollection clone = new SchemaImporterExtensionCollection();
  103.             clone.exNames = (Hashtable)this.Names.Clone();
  104.             foreach (object o in this.List) {
  105.                 clone.List.Add(o);
  106.             }
  107.             return clone;
  108.         }
  109.        
  110.         public SchemaImporterExtension this[int index]
  111.         {
  112.             get { return (SchemaImporterExtension)List[index]; }
  113.             set { List[index] = value; }
  114.         }
  115.        
  116.         internal int Add(string name, SchemaImporterExtension extension)
  117.         {
  118.             if (Names[name] != null) {
  119.                 if (Names[name].GetType() != extension.GetType()) {
  120.                     throw new InvalidOperationException(Res.GetString(Res.XmlConfigurationDuplicateExtension, name));
  121.                 }
  122.                 return -1;
  123.             }
  124.             Names[name] = extension;
  125.             return List.Add(extension);
  126.         }
  127.        
  128.         public void Insert(int index, SchemaImporterExtension extension)
  129.         {
  130.             List.Insert(index, extension);
  131.         }
  132.        
  133.         public int IndexOf(SchemaImporterExtension extension)
  134.         {
  135.             return List.IndexOf(extension);
  136.         }
  137.        
  138.         public bool Contains(SchemaImporterExtension extension)
  139.         {
  140.             return List.Contains(extension);
  141.         }
  142.        
  143.         public void Remove(SchemaImporterExtension extension)
  144.         {
  145.             List.Remove(extension);
  146.         }
  147.        
  148.         public void CopyTo(SchemaImporterExtension[] array, int index)
  149.         {
  150.             List.CopyTo(array, index);
  151.         }
  152.     }
  153.    
  154.     internal class MappedTypeDesc
  155.     {
  156.         string name;
  157.         string ns;
  158.         XmlSchemaType xsdType;
  159.         XmlSchemaObject context;
  160.         string clrType;
  161.         SchemaImporterExtension extension;
  162.         CodeNamespace code;
  163.         bool exported = false;
  164.         StringCollection references;
  165.        
  166.         internal MappedTypeDesc(string clrType, string name, string ns, XmlSchemaType xsdType, XmlSchemaObject context, SchemaImporterExtension extension, CodeNamespace code, StringCollection references)
  167.         {
  168.             this.clrType = clrType.Replace('+', '.');
  169.             this.name = name;
  170.             this.ns = ns;
  171.             this.xsdType = xsdType;
  172.             this.context = context;
  173.             this.code = code;
  174.             this.references = references;
  175.             this.extension = extension;
  176.         }
  177.        
  178.         internal SchemaImporterExtension Extension {
  179.             get { return extension; }
  180.         }
  181.         internal string Name {
  182.             get { return clrType; }
  183.         }
  184.        
  185.         internal StringCollection ReferencedAssemblies {
  186.             get {
  187.                 if (references == null)
  188.                     references = new StringCollection();
  189.                 return references;
  190.             }
  191.         }
  192.        
  193.         internal CodeTypeDeclaration ExportTypeDefinition(CodeNamespace codeNamespace, CodeCompileUnit codeCompileUnit)
  194.         {
  195.             if (exported)
  196.                 return null;
  197.             exported = true;
  198.            
  199.             foreach (CodeNamespaceImport import in code.Imports) {
  200.                 codeNamespace.Imports.Add(import);
  201.             }
  202.             CodeTypeDeclaration codeClass = null;
  203.             string comment = Res.GetString(Res.XmlExtensionComment, extension.GetType().FullName);
  204.             foreach (CodeTypeDeclaration type in code.Types) {
  205.                 if (clrType == type.Name) {
  206.                     if (codeClass != null)
  207.                         throw new InvalidOperationException(Res.GetString(Res.XmlExtensionDuplicateDefinition, extension.GetType().FullName, clrType));
  208.                     codeClass = type;
  209.                 }
  210.                 type.Comments.Add(new CodeCommentStatement(comment, false));
  211.                 codeNamespace.Types.Add(type);
  212.             }
  213.             if (codeCompileUnit != null) {
  214.                 foreach (string reference in ReferencedAssemblies) {
  215.                     if (codeCompileUnit.ReferencedAssemblies.Contains(reference))
  216.                         continue;
  217.                     codeCompileUnit.ReferencedAssemblies.Add(reference);
  218.                 }
  219.             }
  220.             return codeClass;
  221.         }
  222.     }
  223. }

Developer Fusion