The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting.MetadataServices \ XMLNamespace

  1. // ==++==
  2. //
  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. //
  14. // ==--==
  15. //============================================================
  16. //
  17. // File: SudsWriter.cs
  18. // Summary: Defines SUDSParser that parses a given SUDS document
  19. // and generates types defined in it.
  20. //
  21. // Date: April 01, 2000
  22. // Revised: November 15, 2000 (Wsdl)
  23. //
  24. //============================================================
  25. namespace System.Runtime.Remoting.MetadataServices
  26. {
  27.     using System;
  28.     using System.Threading;
  29.     using System.Collections;
  30.     using System.Reflection;
  31.     using System.Xml;
  32.     using System.Diagnostics;
  33.     using System.IO;
  34.     using System.Text;
  35.     using System.Net;
  36.     using System.Runtime.Remoting.Messaging;
  37.     using System.Runtime.Remoting.Metadata;
  38.     using System.Runtime.Remoting.Channels;
  39.     // This is so we can get the resource strings.
  40.     // This class generates SUDS documents
  41.     internal class SdlGenerator
  42.     {
  43.         // Constructor
  44.         internal SdlGenerator(Type[] types, TextWriter output)
  45.         {
  46.             Util.Log("SdlGenerator.SdlGenerator 1");
  47.             _textWriter = output;
  48.             _queue = new Queue();
  49.             _name = null;
  50.             _namespaces = new ArrayList();
  51.             _dynamicAssembly = null;
  52.             _serviceEndpoint = null;
  53.             for (int i = 0; i < types.Length; i++) {
  54.                 if (types[i] != null) {
  55.                     if (types[i].BaseType != null)
  56.                         _queue.Enqueue(types[i]);
  57.                 }
  58.             }
  59.         }
  60.        
  61.         // Constructor
  62.         internal SdlGenerator(Type[] types, SdlType sdlType, TextWriter output)
  63.         {
  64.             Util.Log("SdlGenerator.SdlGenerator 2");
  65.             _textWriter = output;
  66.             _queue = new Queue();
  67.             _name = null;
  68.             _namespaces = new ArrayList();
  69.             _dynamicAssembly = null;
  70.             _serviceEndpoint = null;
  71.             _sdlType = sdlType;
  72.             for (int i = 0; i < types.Length; i++) {
  73.                 if (types[i] != null) {
  74.                     if (types[i].BaseType != null)
  75.                         _queue.Enqueue(types[i]);
  76.                 }
  77.             }
  78.         }
  79.        
  80.         // Constructor
  81.         internal SdlGenerator(Type[] types, TextWriter output, Assembly assembly, string url) : this(types, output)
  82.         {
  83.             Util.Log("SdlGenerator.SdlGenerator 3 " + url);
  84.             _dynamicAssembly = assembly;
  85.             _serviceEndpoint = url;
  86.         }
  87.        
  88.         // Constructor
  89.         internal SdlGenerator(Type[] types, SdlType sdlType, TextWriter output, Assembly assembly, string url) : this(types, output)
  90.         {
  91.             Util.Log("SdlGenerator.SdlGenerator 4 " + url);
  92.             _dynamicAssembly = assembly;
  93.             _serviceEndpoint = url;
  94.             _sdlType = sdlType;
  95.         }
  96.        
  97.         internal SdlGenerator(ServiceType[] serviceTypes, SdlType sdlType, TextWriter output)
  98.         {
  99.             Util.Log("SdlGenerator.SdlGenerator 5 ");
  100.             _textWriter = output;
  101.             _queue = new Queue();
  102.             _name = null;
  103.             _namespaces = new ArrayList();
  104.             _dynamicAssembly = null;
  105.             _serviceEndpoint = null;
  106.             _sdlType = sdlType;
  107.            
  108.             for (int i = 0; i < serviceTypes.Length; i++) {
  109.                 if (serviceTypes[i] != null) {
  110.                     if (serviceTypes[i].ObjectType.BaseType != null)
  111.                         _queue.Enqueue(serviceTypes[i].ObjectType);
  112.                 }
  113.                
  114.                 // Associate serviceEndpoint with type. A type can have multiple serviceEndpoints
  115.                 if (serviceTypes[i].Url != null) {
  116.                     if (_typeToServiceEndpoint == null)
  117.                         _typeToServiceEndpoint = new Hashtable(10);
  118.                     if (_typeToServiceEndpoint.ContainsKey(serviceTypes[i].ObjectType.Name)) {
  119.                         ArrayList serviceEndpoints = (ArrayList)_typeToServiceEndpoint[serviceTypes[i].ObjectType.Name];
  120.                         serviceEndpoints.Add(serviceTypes[i].Url);
  121.                     }
  122.                     else {
  123.                         ArrayList serviceEndpoints = new ArrayList(10);
  124.                         serviceEndpoints.Add(serviceTypes[i].Url);
  125.                         _typeToServiceEndpoint[serviceTypes[i].ObjectType.Name] = serviceEndpoints;
  126.                     }
  127.                    
  128.                 }
  129.             }
  130.         }
  131.        
  132.        
  133.         // Generates SUDS
  134.         internal void Generate()
  135.         {
  136.             Util.Log("SdlGenerator.Generate");
  137.             // Generate the trasitive closure of the types reachable from
  138.             // the supplied types
  139.             while (_queue.Count > 0) {
  140.                 // Dequeue from not yet seen queue
  141.                 Type type = (Type)_queue.Dequeue();
  142.                
  143.                 // Check if the type was encountered earlier
  144.                 string ns;
  145.                 Assembly assem;
  146.                 bool bInteropType = GetNSAndAssembly(type, out ns, out assem);
  147.                 Util.Log("SdlGenerator.Generate Dequeue " + type + " ns " + ns + " assem " + assem);
  148.                 XMLNamespace xns = LookupNamespace(ns, assem);
  149.                 if (xns != null) {
  150.                     if (xns.LookupSchemaType(type.Name) != null) {
  151.                         continue;
  152.                     }
  153.                 }
  154.                 else {
  155.                     xns = AddNamespace(ns, assem, bInteropType);
  156.                 }
  157.                
  158.                 // Check if type needs to be represented as a SimpleSchemaType
  159.                 SimpleSchemaType ssType = SimpleSchemaType.GetSimpleSchemaType(type, xns, false);
  160.                 if (ssType != null) {
  161.                     // Add to namespace as a SimpleSchemaType
  162.                     xns.AddSimpleSchemaType(ssType);
  163.                 }
  164.                 else {
  165.                     // Check for the first MarshalByRef type
  166.                     bool bUnique = false;
  167.                     string connectURL = null;
  168.                     Hashtable connectTypeToServiceEndpoint = null;
  169.                     if ((_name == null) && s_marshalByRefType.IsAssignableFrom(type)) {
  170.                         _name = type.Name;
  171.                         _targetNS = xns.Namespace;
  172.                         connectURL = _serviceEndpoint;
  173.                         connectTypeToServiceEndpoint = _typeToServiceEndpoint;
  174.                         bUnique = true;
  175.                     }
  176.                     RealSchemaType rsType = new RealSchemaType(type, xns, connectURL, connectTypeToServiceEndpoint, bUnique);
  177.                    
  178.                     // Add to namespace as a RealSchemaType
  179.                     xns.AddRealSchemaType(rsType);
  180.                    
  181.                     // Enqueue types reachable from this type
  182.                     EnqueueReachableTypes(rsType);
  183.                 }
  184.             }
  185.            
  186.             // At this point we have the complete list of types
  187.             // to be processed. Resolve cross references between
  188.             // them
  189.             Resolve();
  190.            
  191.             // At this stage, we are ready to print the schemas
  192.             PrintSdl();
  193.            
  194.             // Flush cached buffers
  195.             _textWriter.Flush();
  196.            
  197.             return;
  198.         }
  199.        
  200.         // Adds types reachable from the given type
  201.         private void EnqueueReachableTypes(RealSchemaType rsType)
  202.         {
  203.             Util.Log("SdlGenerator.EnqueueReachableTypes ");
  204.             // Get the XML namespace object
  205.             XMLNamespace xns = rsType.XNS;
  206.            
  207.             // Process base type
  208.             if (rsType.Type.BaseType != null)
  209.                 AddType(rsType.Type.BaseType, xns);
  210.            
  211.             // Check if this is a suds type
  212.             bool bSUDSType = rsType.Type.IsInterface || s_marshalByRefType.IsAssignableFrom(rsType.Type) || s_delegateType.IsAssignableFrom(rsType.Type);
  213.             if (bSUDSType) {
  214.                 // Process implemented interfaces
  215.                 Type[] interfaces = rsType.GetIntroducedInterfaces();
  216.                 if (interfaces.Length > 0) {
  217.                     for (int i = 0; i < interfaces.Length; i++) {
  218.                         Util.Log("SdlGenerator.EnqueueReachableTypes Interfaces " + interfaces[i].Name + " " + xns.Name);
  219.                         AddType(interfaces[i], xns);
  220.                     }
  221.                 }
  222.                
  223.                 // Process methods
  224.                 MethodInfo[] methods = rsType.GetIntroducedMethods();
  225.                 if (methods.Length > 0) {
  226.                     string methodNSString = null;
  227.                     XMLNamespace methodXNS = null;
  228.                    
  229.                     if (xns.IsInteropType) {
  230.                         methodNSString = xns.Name;
  231.                         methodXNS = xns;
  232.                     }
  233.                     else {
  234.                         StringBuilder sb = new StringBuilder();
  235.                         sb.Append(xns.Name);
  236.                         sb.Append('.');
  237.                         sb.Append(rsType.Name);
  238.                         methodNSString = sb.ToString();
  239.                         methodXNS = AddNamespace(methodNSString, xns.Assem);
  240.                         xns.DependsOnSchemaNS(methodXNS);
  241.                     }
  242.                    
  243.                     for (int i = 0; i < methods.Length; i++) {
  244.                         MethodInfo method = methods[i];
  245.                         Util.Log("SdlGenerator.EnqueueReachableTypes methods " + method.Name + " " + methodXNS.Name);
  246.                         AddType(method.ReturnType, methodXNS);
  247.                         ParameterInfo[] parameters = method.GetParameters();
  248.                         for (int j = 0; j < parameters.Length; j++)
  249.                             AddType(parameters[j].ParameterType, methodXNS);
  250.                     }
  251.                 }
  252.             }
  253.             else {
  254.                 // Process fields
  255.                 FieldInfo[] fields = rsType.GetInstanceFields();
  256.                 for (int i = 0; i < fields.Length; i++) {
  257.                     if (fields[i].FieldType == null)
  258.                         continue;
  259.                     AddType(fields[i].FieldType, xns);
  260.                 }
  261.             }
  262.            
  263.             return;
  264.         }
  265.        
  266.         // Adds the given type if it has not been encountered before
  267.         private void AddType(Type type, XMLNamespace xns)
  268.         {
  269.             Util.Log("SdlGenerator.AddTypes " + type);
  270.             // System.Array says that it has element type, but returns null
  271.             // when asked for the element type.
  272.             if (type.HasElementType) {
  273.                 Type eType = type.GetElementType();
  274.                 if (eType != null) {
  275.                     type = eType;
  276.                     while (type.HasElementType)
  277.                         type = type.GetElementType();
  278.                 }
  279.             }
  280.            
  281.             if (type.IsPrimitive == false) {
  282.                 string ns;
  283.                 Assembly assem;
  284.                 bool bInteropType = GetNSAndAssembly(type, out ns, out assem);
  285.                
  286.                 // Lookup the namespace
  287.                 XMLNamespace dependsOnNS = LookupNamespace(ns, assem);
  288.                 // Create a new namespace if neccessary
  289.                 if (dependsOnNS == null)
  290.                     dependsOnNS = AddNamespace(ns, assem, bInteropType);
  291.                
  292.                 // The supplied namespace depends directly on the namespace of the type
  293.                 xns.DependsOnSchemaNS(dependsOnNS);
  294.                
  295.                 // Enqueue the type if it does not belong to system namespace
  296.                 if ((ns == null) || !ns.StartsWith("System")) {
  297.                     _queue.Enqueue(type);
  298.                 }
  299.             }
  300.            
  301.             return;
  302.         }
  303.        
  304.         private static bool GetNSAndAssembly(Type type, out string ns, out Assembly assem)
  305.         {
  306.             Util.Log("SdlGenerator.GetNSAndAssembly " + type);
  307.            
  308.             string xmlNamespace = null;
  309.             string xmlElement = null;
  310.             bool bInterop = false;
  311.             SoapServices.GetXmlElementForInteropType(type, out xmlElement, out xmlNamespace);
  312.             if (xmlNamespace != null) {
  313.                 ns = xmlNamespace;
  314.                 assem = null;
  315.                 bInterop = true;
  316.             }
  317.             else {
  318.                 // Return the namespace and assembly in which the type is defined
  319.                 ns = type.Namespace;
  320.                 assem = type.Module.Assembly;
  321.                 bInterop = false;
  322.             }
  323.             return bInterop;
  324.         }
  325.        
  326.         private XMLNamespace LookupNamespace(string name, Assembly assem)
  327.         {
  328.             Util.Log("SdlGenerator.LookupNamespace " + name);
  329.             for (int i = 0; i < _namespaces.Count; i++) {
  330.                 XMLNamespace xns = (XMLNamespace)_namespaces[i];
  331.                 if ((name == xns.Name) && (assem == xns.Assem))
  332.                     return (xns);
  333.             }
  334.            
  335.             return (null);
  336.         }
  337.        
  338.         private XMLNamespace AddNamespace(string name, Assembly assem)
  339.         {
  340.             return AddNamespace(name, assem, false);
  341.         }
  342.        
  343.         private XMLNamespace AddNamespace(string name, Assembly assem, bool bInteropType)
  344.         {
  345.             Util.Log("SdlGenerator.AddNamespace " + name);
  346.             Debug.Assert(LookupNamespace(name, assem) == null, "Duplicate Type found");
  347.            
  348.                 //(assem == _dynamicAssembly) ? _serviceEndpoint : null,
  349.             XMLNamespace xns = new XMLNamespace(name, assem, _serviceEndpoint, _typeToServiceEndpoint, "ns" + _namespaces.Count, bInteropType);
  350.             _namespaces.Add(xns);
  351.            
  352.             return (xns);
  353.         }
  354.        
  355.         // Maps schema types to schema types
  356.         private static string MapURTTypesToSchemaTypes(string typeName)
  357.         {
  358.             Util.Log("SdlGenerator.MapURTTypesToSchemaTypes " + typeName);
  359.             string newTypeName = typeName;
  360.             if (typeName == "SByte")
  361.                 newTypeName = "byte";
  362.             else if (typeName == "Byte")
  363.                 newTypeName = "unsigned-byte";
  364.             else if (typeName == "Int16")
  365.                 newTypeName = "short";
  366.             else if (typeName == "UInt16")
  367.                 newTypeName = "unsigned-short";
  368.             else if (typeName == "Int32")
  369.                 newTypeName = "int";
  370.             else if (typeName == "UInt32")
  371.                 newTypeName = "unsigned-int";
  372.             else if (typeName == "Int64")
  373.                 newTypeName = "long";
  374.             else if (typeName == "UInt64")
  375.                 newTypeName = "unsigned-long";
  376.             else if (typeName == "Char")
  377.                 newTypeName = "character";
  378.             else if (typeName == "Single")
  379.                 newTypeName = "float";
  380.             else if (typeName == "Double")
  381.                 newTypeName = "double";
  382.             else if (typeName == "Boolean")
  383.                 newTypeName = "boolean";
  384.             else if (typeName == "DateTime")
  385.                 newTypeName = "timeInstant";
  386.            
  387.             return (newTypeName);
  388.         }
  389.        
  390.         private void Resolve()
  391.         {
  392.             Util.Log("SdlGenerator.Resolve ");
  393.             for (int i = 0; i < _namespaces.Count; i++)
  394.                 ((XMLNamespace)_namespaces[i]).Resolve();
  395.            
  396.             return;
  397.         }
  398.        
  399.         private void PrintSdl()
  400.         {
  401.             Util.Log("SdlGenerator.PrintSdl");
  402.             string indent = "";
  403.             string indent1 = IndentP(indent);
  404.             _textWriter.WriteLine("<?xml version='1.0' encoding='UTF-8'?>");
  405.             _textWriter.Write("<serviceDescription ");
  406.             if (_name != null) {
  407.                 _textWriter.Write("name='");
  408.                 _textWriter.Write(_name);
  409.                 _textWriter.WriteLine('\'');
  410.                 _textWriter.Write(" targetNamespace='");
  411.                 _textWriter.Write(_targetNS);
  412.                 _textWriter.WriteLine('\'');
  413.                 _textWriter.Write(" ");
  414.             }
  415.             _textWriter.WriteLine("xmlns='urn:schemas-xmlsoap-org:sdl.2000-01-25'>");
  416.             for (int i = 0; i < _namespaces.Count; i++)
  417.                 ((XMLNamespace)_namespaces[i]).PrintSdl(_textWriter, indent1);
  418.             _textWriter.WriteLine("</serviceDescription>");
  419.            
  420.             return;
  421.         }
  422.        
  423.        
  424.        
  425.         // Private fields
  426.         private TextWriter _textWriter;
  427.         private Queue _queue;
  428.         private string _name;
  429.         private string _targetNS;
  430.         private ArrayList _namespaces;
  431.         private Assembly _dynamicAssembly;
  432.         private string _serviceEndpoint;
  433.         //service endpoint for all types
  434.         private SdlType _sdlType = SdlType.Sdl;
  435.         internal Hashtable _typeToServiceEndpoint;
  436.         //service endpoint for each type
  437.         private static Type s_marshalByRefType = typeof(System.MarshalByRefObject);
  438.         private static Type s_contextBoundType = typeof(System.ContextBoundObject);
  439.         private static Type s_delegateType = typeof(System.Delegate);
  440.        
  441.         private static Type s_remotingClientProxyType = typeof(System.Runtime.Remoting.Services.RemotingClientProxy);
  442.         private static SchemaBlockType blockDefault = SchemaBlockType.SEQUENCE;
  443.        
  444. /***************************************************************
  445. **
  446. ** Private classes used by SUDS generator
  447. **
  448. ***************************************************************/       
  449.         private interface IAbstractElement
  450.         {
  451.             void Print(TextWriter textWriter, StringBuilder sb, string indent);
  452.         }
  453.        
  454.         private class EnumElement : IAbstractElement
  455.         {
  456.             internal EnumElement(string value)
  457.             {
  458.                 Util.Log("EnumElement.EnumElement " + value);
  459.                 _value = value;
  460.             }
  461.            
  462.             public void Print(TextWriter textWriter, StringBuilder sb, string indent)
  463.             {
  464.                 Util.Log("EnumElement.Print");
  465.                 sb.Length = 0;
  466.                 sb.Append(indent);
  467.                 sb.Append("<enumeration value='");
  468.                 sb.Append(_value);
  469.                 sb.Append("'/>");
  470.                 textWriter.WriteLine(sb);
  471.                 return;
  472.             }
  473.            
  474.             // Fields
  475.             private string _value;
  476.         }
  477.        
  478.         private class EncodingElement : IAbstractElement
  479.         {
  480.             public EncodingElement(string value)
  481.             {
  482.                 Util.Log("EncodingElement.EncodingElement " + value);
  483.                 _value = value;
  484.             }
  485.            
  486.             public void Print(TextWriter textWriter, StringBuilder sb, string indent)
  487.             {
  488.                 Util.Log("EncodingElement.Print");
  489.                 sb.Length = 0;
  490.                 sb.Append(indent);
  491.                 sb.Append("<encoding value='");
  492.                 sb.Append(_value);
  493.                 sb.Append("'/>");
  494.                 textWriter.WriteLine(sb);
  495.                 return;
  496.             }
  497.            
  498.             // Fields
  499.             private string _value;
  500.         }
  501.        
  502.         private class SchemaAttribute : IAbstractElement
  503.         {
  504.             internal SchemaAttribute(string name, string type)
  505.             {
  506.                 Util.Log("SchemaAttribute " + name + " type " + type);
  507.                 _name = name;
  508.                 _type = type;
  509.             }
  510.            
  511.             public void Print(TextWriter textWriter, StringBuilder sb, string indent)
  512.             {
  513.                 Util.Log("SchemaAttribute.Print");
  514.                 sb.Length = 0;
  515.                 sb.Append(indent);
  516.                 sb.Append("<attribute name='");
  517.                 sb.Append(_name);
  518.                 sb.Append("' type='");
  519.                 sb.Append(_type);
  520.                 sb.Append("'/>");
  521.                 textWriter.WriteLine(sb);
  522.                
  523.                 return;
  524.             }
  525.            
  526.             // Fields
  527.             private string _name;
  528.             private string _type;
  529.         }
  530.        
  531.         private abstract class Particle : IAbstractElement
  532.         {
  533.             protected Particle()
  534.             {
  535.             }
  536.             public abstract void Print(TextWriter textWriter, StringBuilder sb, string indent);
  537.         }
  538.        
  539.         private class SchemaElement : Particle
  540.         {
  541.             internal SchemaElement(string name, Type type, bool bEmbedded, XMLNamespace xns) : base()
  542.             {
  543.                 Util.Log("SchemaElement.SchemaElement Particle " + name + " type " + type + " bEmbedded " + bEmbedded);
  544.                 _name = name;
  545.                 _typeString = null;
  546.                 _schemaType = SimpleSchemaType.GetSimpleSchemaType(type, xns, true);
  547.                 if (_schemaType == null)
  548.                     _typeString = RealSchemaType.TypeName(type, bEmbedded, xns);
  549.             }
  550.            
  551.             public override void Print(TextWriter textWriter, StringBuilder sb, string indent)
  552.             {
  553.                 Util.Log("SchemaElement.Print");
  554.                 sb.Length = 0;
  555.                 sb.Append(indent);
  556.                 sb.Append("<element name='");
  557.                 sb.Append(_name);
  558.                 if (_schemaType != null) {
  559.                     sb.Append("'>");
  560.                     textWriter.WriteLine(sb);
  561.                     _schemaType.PrintSchemaType(textWriter, sb, IndentP(indent), true);
  562.                    
  563.                     sb.Length = 0;
  564.                     sb.Append(indent);
  565.                     sb.Append("</element>");
  566.                 }
  567.                 else {
  568.                     if (_typeString != null) {
  569.                         sb.Append("' type='");
  570.                         sb.Append(_typeString);
  571.                         sb.Append('\'');
  572.                     }
  573.                     sb.Append("/>");
  574.                 }
  575.                 textWriter.WriteLine(sb);
  576.                
  577.                 return;
  578.             }
  579.            
  580.             // Fields
  581.             private string _name;
  582.             private string _typeString;
  583.             private SchemaType _schemaType;
  584.         }
  585.        
  586.         private abstract class SchemaType
  587.         {
  588.             internal abstract void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous);
  589.         }
  590.        
  591.         private class SimpleSchemaType : SchemaType
  592.         {
  593.             private SimpleSchemaType(Type type, XMLNamespace xns)
  594.             {
  595.                 Util.Log("SimpleSchemaType.SimpleSchemaType " + type + " xns " + ((xns != null) ? xns.Name : "Null"));
  596.                 _type = type;
  597.                 _xns = xns;
  598.                 _abstractElms = new ArrayList();
  599.             }
  600.            
  601.             internal Type Type {
  602.                 get { return (_type); }
  603.             }
  604.            
  605.             internal string BaseName {
  606.                 get { return (_baseName); }
  607.             }
  608.            
  609.             internal XMLNamespace XNS {
  610.                 get { return (_xns); }
  611.             }
  612.            
  613.             internal override void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous)
  614.             {
  615.                 Util.Log("SimpleSchemaType.PrintSchemaType");
  616.                 sb.Length = 0;
  617.                 sb.Append(indent);
  618.                 if (bAnonymous == false) {
  619.                     sb.Append("<simpleType name='");
  620.                     sb.Append(_type.Name);
  621.                     sb.Append("' base='");
  622.                 }
  623.                 else {
  624.                     sb.Append("<simpleType base='");
  625.                 }
  626.                 sb.Append(BaseName);
  627.                 bool bEmpty = _abstractElms.Count == 0;
  628.                 if (bEmpty)
  629.                     sb.Append("'/>");
  630.                 else
  631.                     sb.Append("'>");
  632.                 textWriter.WriteLine(sb);
  633.                 if (bEmpty)
  634.                     return;
  635.                
  636.                 if (_abstractElms.Count > 0) {
  637.                     for (int i = 0; i < _abstractElms.Count; i++)
  638.                         ((IAbstractElement)_abstractElms[i]).Print(textWriter, sb, IndentP(indent));
  639.                 }
  640.                
  641.                 textWriter.Write(indent);
  642.                 textWriter.WriteLine("</simpleType>");
  643.                
  644.                 return;
  645.             }
  646.            
  647.             static internal SimpleSchemaType GetSimpleSchemaType(Type type, XMLNamespace xns, bool fInline)
  648.             {
  649.                 Util.Log("SimpleSchemaType.GetSimpleSchemaType " + type + " xns " + xns.Name);
  650.                 SimpleSchemaType ssType = null;
  651.                 if (fInline) {
  652.                     if ((type.IsArray == true) && (type.GetArrayRank() == 1) && (type.GetElementType() == typeof(byte))) {
  653.                         if (_byteArraySchemaType == null) {
  654.                             _byteArraySchemaType = new SimpleSchemaType(type, null);
  655.                             _byteArraySchemaType._baseName = "xsd:binary";
  656.                             _byteArraySchemaType._abstractElms.Add(new EncodingElement("base64"));
  657.                         }
  658.                         ssType = _byteArraySchemaType;
  659.                     }
  660.                 }
  661.                 else {
  662.                     if (type.IsEnum) {
  663.                         ssType = new SimpleSchemaType(type, xns);
  664.                         ssType._baseName = RealSchemaType.TypeName(Enum.GetUnderlyingType(type), true, null);
  665.                         string[] values = Enum.GetNames(type);
  666.                         for (int i = 0; i < values.Length; i++)
  667.                             ssType._abstractElms.Add(new EnumElement(values[i]));
  668.                     }
  669.                     else {
  670.                     }
  671.                 }
  672.                
  673.                 return (ssType);
  674.             }
  675.            
  676.             private Type _type;
  677.             private string _baseName;
  678.             private XMLNamespace _xns;
  679.             private ArrayList _abstractElms;
  680.            
  681.             private static SimpleSchemaType _byteArraySchemaType = null;
  682.         }
  683.        
  684.         private abstract class ComplexSchemaType : SchemaType
  685.         {
  686.             internal ComplexSchemaType(string name, bool bSealed)
  687.             {
  688.                 Util.Log("ComplexSchemaType.ComplexSchemaType " + name + " bSealed " + bSealed);
  689.                 _name = name;
  690.                 _baseName = null;
  691.                 _elementName = name;
  692.                 _bSealed = bSealed;
  693.                 _blockType = SchemaBlockType.ALL;
  694.                 _particles = new ArrayList();
  695.                 _abstractElms = new ArrayList();
  696.             }
  697.            
  698.             internal string Name {
  699.                 get { return (_name); }
  700.                 set { _name = value; }
  701.             }
  702.            
  703.             protected string BaseName {
  704.                 get { return (_baseName); }
  705.                 set { _baseName = value; }
  706.             }
  707.            
  708.             internal string ElementName {
  709.                 get { return (_elementName); }
  710.                 set { _elementName = value; }
  711.             }
  712.            
  713.             protected SchemaBlockType BlockType {
  714.                 get { return (_blockType); }
  715.                 set { _blockType = value; }
  716.             }
  717.            
  718.             protected bool IsSealed {
  719.                 get { return (_bSealed); }
  720.             }
  721.            
  722.             protected bool IsEmpty {
  723.                 get { return ((_abstractElms.Count == 0) && (_particles.Count == 0)); }
  724.             }
  725.            
  726.             internal void AddParticle(Particle particle)
  727.             {
  728.                 Util.Log("SimpleSchemaType.AddParticle");
  729.                 _particles.Add(particle);
  730.             }
  731.            
  732.             internal void AddAbstractElement(IAbstractElement elm)
  733.             {
  734.                 Util.Log("SimpleSchemaType.AddAbstractElement");
  735.                 _abstractElms.Add(elm);
  736.             }
  737.            
  738.             protected void PrintBody(TextWriter textWriter, StringBuilder sb, string indent)
  739.             {
  740.                 Util.Log("SimpleSchemaType.PrintBody");
  741.                 int particleCount = _particles.Count;
  742.                 string indent1 = IndentP(indent);
  743.                 if (particleCount > 0) {
  744.                         /*(particleCount > 1) && */                    bool bPrintBlockElms = (SdlGenerator.blockDefault != _blockType);
  745.                     if (bPrintBlockElms) {
  746.                         sb.Length = 0;
  747.                         sb.Append(indent);
  748.                         sb.Append(schemaBlockBegin[(int)_blockType]);
  749.                         textWriter.WriteLine(sb);
  750.                     }
  751.                    
  752.                     for (int i = 0; i < particleCount; i++)
  753.                         ((Particle)_particles[i]).Print(textWriter, sb, IndentP(indent1));
  754.                    
  755.                     if (bPrintBlockElms) {
  756.                         sb.Length = 0;
  757.                         sb.Append(indent);
  758.                         sb.Append(schemaBlockEnd[(int)_blockType]);
  759.                         textWriter.WriteLine(sb);
  760.                     }
  761.                 }
  762.                
  763.                 int abstractElmCount = _abstractElms.Count;
  764.                 for (int i = 0; i < abstractElmCount; i++)
  765.                     ((IAbstractElement)_abstractElms[i]).Print(textWriter, sb, IndentP(indent));
  766.                
  767.                 return;
  768.             }
  769.            
  770.             private string _name;
  771.             private string _baseName;
  772.             private string _elementName;
  773.             private bool _bSealed;
  774.             private SchemaBlockType _blockType;
  775.             private ArrayList _particles;
  776.             private ArrayList _abstractElms;
  777.            
  778.             private static string[] schemaBlockBegin = {"<all>", "<sequence>", "<choice>"};
  779.             private static string[] schemaBlockEnd = {"</all>", "</sequence>", "</choice>"};
  780.         }
  781.        
  782.         private class PhonySchemaType : ComplexSchemaType
  783.         {
  784.             internal PhonySchemaType(string name) : base(name, true)
  785.             {
  786.                 Util.Log("PhonySchemaType.PhonySchemaType " + name);
  787.                 _numOverloadedTypes = 0;
  788.             }
  789.            
  790.             internal int OverloadedType()
  791.             {
  792.                 Util.Log("PhonySchemaType.OverLoadedTypeType");
  793.                 return (++_numOverloadedTypes);
  794.             }
  795.            
  796.             internal override void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous)
  797.             {
  798.                 Util.Log("PhonySchemaType.PrintSchemaType");
  799.                 Debug.Assert(bAnonymous == true, "PhonySchemaType should always be printed as anonymous types");
  800.                 string indent1 = IndentP(indent);
  801.                 string indent2 = IndentP(indent1);
  802.                 sb.Length = 0;
  803.                 sb.Append(indent);
  804.                 sb.Append("<element name='");
  805.                 sb.Append(ElementName);
  806.                 sb.Append("'>");
  807.                 textWriter.WriteLine(sb);
  808.                
  809.                 sb.Length = 0;
  810.                 sb.Append(indent1);
  811.                 sb.Append("<complexType");
  812.                 if (BaseName != null) {
  813.                     sb.Append(" base='");
  814.                     sb.Append(BaseName);
  815.                     sb.Append('\'');
  816.                 }
  817.                 bool bEmpty = IsEmpty;
  818.                 if (bEmpty)
  819.                     sb.Append("/>");
  820.                 else
  821.                     sb.Append('>');
  822.                 textWriter.WriteLine(sb);
  823.                
  824.                 if (bEmpty == false) {
  825.                     base.PrintBody(textWriter, sb, indent2);
  826.                    
  827.                     textWriter.Write(indent1);
  828.                     textWriter.WriteLine("</complexType>");
  829.                 }
  830.                
  831.                 textWriter.Write(indent);
  832.                 textWriter.WriteLine("</element>");
  833.                
  834.                 return;
  835.             }
  836.            
  837.             private int _numOverloadedTypes;
  838.         }
  839.        
  840.         private class RealSchemaType : ComplexSchemaType
  841.         {
  842.             internal RealSchemaType(Type type, XMLNamespace xns, string serviceEndpoint, Hashtable typeToServiceEndpoint, bool bUnique) : base(type.Name, type.IsSealed)
  843.             {
  844.                 Util.Log("RealSchemaType.RealSchemaType " + type + " xns " + xns.Name + " serviceEndpoint " + serviceEndpoint + " bUnique " + bUnique);
  845.                 _type = type;
  846.                 _serviceEndpoint = serviceEndpoint;
  847.                 _typeToServiceEndpoint = typeToServiceEndpoint;
  848.                 _bUnique = bUnique;
  849.                 _bStruct = type.IsValueType;
  850.                 _xns = xns;
  851.                 _implIFaces = null;
  852.                 _iFaces = null;
  853.                 _methods = null;
  854.                 _fields = null;
  855.                 _methodTypes = null;
  856.             }
  857.            
  858.             internal Type Type {
  859.                 get { return (_type); }
  860.             }
  861.            
  862.             internal XMLNamespace XNS {
  863.                 get { return (_xns); }
  864.             }
  865.            
  866.             internal bool IsStruct {
  867.                 get { return (_bStruct); }
  868.             }
  869.            
  870.             internal bool IsUnique {
  871.                 get { return (_bUnique); }
  872.             }
  873.            
  874.             internal bool IsSUDSType {
  875.                 get { return ((_fields == null) && ((_iFaces.Length > 0) || (_methods.Length > 0) || (_type.IsInterface) || (s_delegateType.IsAssignableFrom(_type)))); }
  876.             }
  877.            
  878.             internal Type[] GetIntroducedInterfaces()
  879.             {
  880.                 Util.Log("RealSchemaType.GetIntroducedInterfaces");
  881.                 Debug.Assert(_iFaces == null, "variable set");
  882.                 _iFaces = GetIntroducedInterfaces(_type);
  883.                 return (_iFaces);
  884.             }
  885.            
  886.             internal MethodInfo[] GetIntroducedMethods()
  887.             {
  888.                 Util.Log("RealSchemaType.GetIntroducedMethods");
  889.                 Debug.Assert(_methods == null, "variable set");
  890.                 _methods = GetIntroducedMethods(_type);
  891.                 _methodTypes = new string[2 * _methods.Length];
  892.                 return (_methods);
  893.             }
  894.            
  895.             internal FieldInfo[] GetInstanceFields()
  896.             {
  897.                 Util.Log("RealSchemaType.GetInstanceFields");
  898.                 Debug.Assert(_fields == null, "variable set");
  899.                 Debug.Assert(!SdlGenerator.s_marshalByRefType.IsAssignableFrom(_type), "Invalid Type");
  900.                 _fields = GetInstanceFields(_type);
  901.                 return (_fields);
  902.             }
  903.            
  904.             internal void Resolve(StringBuilder sb)
  905.             {
  906.                 Util.Log("RealSchemaType.Resolve");
  907.                 sb.Length = 0;
  908.                
  909.                 // Check if this is a suds type
  910.                 bool bSUDSType = IsSUDSType;
  911.                
  912.                 // Resolve base type eliminating system defined roots of the class heirarchy
  913.                 if (!_type.IsInterface && !_type.IsValueType && (_type.BaseType.BaseType != null) && (_type.BaseType != SdlGenerator.s_marshalByRefType) && (_type.BaseType != SdlGenerator.s_contextBoundType) && (_type.BaseType != SdlGenerator.s_remotingClientProxyType) && ((_type.IsCOMObject == false) || (_type.BaseType.BaseType.IsCOMObject == true))) {
  914.                     string ns;
  915.                     Assembly assem;
  916.                     Util.Log("RealSchemaType.Resolve Not System Defined root " + _type.BaseType);
  917.                     bool InteropType = SdlGenerator.GetNSAndAssembly(_type.BaseType, out ns, out assem);
  918.                     XMLNamespace xns = _xns.LookupSchemaNamespace(ns, assem);
  919.                     Debug.Assert(xns != null, "Namespace should have been found");
  920.                     sb.Append(xns.Prefix);
  921.                     sb.Append(':');
  922.                     sb.Append(_type.BaseType.Name);
  923.                     BaseName = sb.ToString();
  924.                     if (bSUDSType)
  925.                         _xns.DependsOnSUDSNS(xns);
  926.                 }
  927.                
  928.                 // The element definition of this type depends on itself
  929.                 _xns.DependsOnSchemaNS(_xns);
  930.                
  931.                 if (bSUDSType) {
  932.                     Util.Log("RealSchemaType.Resolve AddRealSUDSType " + _type);
  933.                     _xns.AddRealSUDSType(this);
  934.                    
  935.                     // Resolve interfaces introduced by this type
  936.                     if (_iFaces.Length > 0) {
  937.                         _implIFaces = new string[_iFaces.Length];
  938.                         for (int i = 0; i < _iFaces.Length; i++) {
  939.                             string ns;
  940.                             Assembly assem;
  941.                             Util.Log("RealSchemaType.Resolve iFace " + _iFaces[i].Name);
  942.                             bool bInteropType = SdlGenerator.GetNSAndAssembly(_iFaces[i], out ns, out assem);
  943.                             XMLNamespace xns = _xns.LookupSchemaNamespace(ns, assem);
  944.                             Debug.Assert(xns != null, "SchemaType should have been found");
  945.                             sb.Length = 0;
  946.                             sb.Append(xns.Prefix);
  947.                             sb.Append(':');
  948.                             sb.Append(_iFaces[i].Name);
  949.                             _implIFaces[i] = sb.ToString();
  950.                             _xns.DependsOnSUDSNS(xns);
  951.                         }
  952.                     }
  953.                    
  954.                     // Resolve methods introduced by this type
  955.                     if (_methods.Length > 0) {
  956.                         string useNS = null;
  957.                         if (_xns.IsInteropType)
  958.                             useNS = _xns.Name;
  959.                         else {
  960.                             sb.Length = 0;
  961.                             sb.Append(_xns.Name);
  962.                             sb.Append('.');
  963.                             sb.Append(Name);
  964.                             useNS = sb.ToString();
  965.                         }
  966.                         XMLNamespace methodXNS = _xns.LookupSchemaNamespace(useNS, _xns.Assem);
  967.                         Debug.Assert(methodXNS != null, "Namespace is null");
  968.                         _xns.DependsOnSUDSNS(methodXNS);
  969.                         for (int i = 0; i < _methods.Length; i++) {
  970.                             // Process the request
  971.                             MethodInfo method = _methods[i];
  972.                             string methodRequestName = method.Name;
  973.                             Util.Log("RealSchemaType.Resolve Phony " + methodRequestName);
  974.                             PhonySchemaType methodRequest = new PhonySchemaType(methodRequestName);
  975.                             ParameterInfo[] parameters = method.GetParameters();
  976.                             for (int j = 0; j < parameters.Length; j++) {
  977.                                 ParameterInfo parameter = parameters[j];
  978.                                 if (!parameter.IsOut)
  979.                                     methodRequest.AddParticle(new SchemaElement(parameter.Name, parameter.ParameterType, false, methodXNS));
  980.                             }
  981.                             methodXNS.AddPhonySchemaType(methodRequest);
  982.                             _methodTypes[2 * i] = methodRequest.ElementName;
  983.                            
  984.                             if (!RemotingServices.IsOneWay(method)) {
  985.                                 // Process response (look at custom attributes to get values
  986.                                
  987.                                 string returnName = null;
  988.                                 SoapMethodAttribute soapAttribute = (SoapMethodAttribute)InternalRemotingServices.GetCachedSoapAttribute(method);
  989.                                 if (soapAttribute.ReturnXmlElementName != null)
  990.                                     returnName = soapAttribute.ReturnXmlElementName;
  991.                                 else
  992.                                     returnName = "__return";
  993.                                
  994.                                 string responseName = null;
  995.                                 if (soapAttribute.ResponseXmlElementName != null)
  996.                                     responseName = soapAttribute.ResponseXmlElementName;
  997.                                 else
  998.                                     responseName = methodRequestName + "Response";
  999.                                
  1000.                                 Util.Log("RealSchemaType.Resolve Phony " + responseName);
  1001.                                 PhonySchemaType methodResponse = new PhonySchemaType(responseName);
  1002.                                 // Handle a void method that has an out parameter. This can only
  1003.                                 // be handled through parameterOrder attribute
  1004.                                 if (method.ReturnType.FullName != "System.Void")
  1005.                                     methodResponse.AddParticle(new SchemaElement(returnName, method.ReturnType, false, methodXNS));
  1006.                                
  1007.                                 for (int j = 0; j < parameters.Length; j++) {
  1008.                                     ParameterInfo parameter = parameters[j];
  1009.                                     /*if(!parameter.IsIn &&
  1010. (parameter.ParameterType.IsByRef ||
  1011. (!parameter.ParameterType.IsPrimitive &&
  1012. parameter.ParameterType.FullName != "System.String")))*/                                   
  1013. if (parameter.IsOut || parameter.ParameterType.IsByRef)
  1014.                                         methodResponse.AddParticle(new SchemaElement(parameter.Name, parameter.ParameterType, false, methodXNS));
  1015.                                 }
  1016.                                 methodXNS.AddPhonySchemaType(methodResponse);
  1017.                                 _methodTypes[2 * i + 1] = methodResponse.ElementName;
  1018.                             }
  1019.                         }
  1020.                     }
  1021.                 }
  1022.                
  1023.                 // Resolve fields
  1024.                 if (_fields != null) {
  1025.                     for (int i = 0; i < _fields.Length; i++) {
  1026.                         FieldInfo field = _fields[i];
  1027.                         Debug.Assert(!field.IsStatic, "Static field");
  1028.                         Type fieldType = field.FieldType;
  1029.                         if (fieldType == null)
  1030.                             fieldType = typeof(object);
  1031.                         Util.Log("RealSchemaType.Resolve fields " + field.Name + " type " + fieldType);
  1032.                         AddParticle(new SchemaElement(field.Name, fieldType, false, _xns));
  1033.                     }
  1034.                 }
  1035.                
  1036.                 // Resolve attribute elements
  1037.                 if (_bStruct == false)
  1038.                     AddAbstractElement(new SchemaAttribute("id", "xsd:ID"));
  1039.                
  1040.                 return;
  1041.             }
  1042.            
  1043.             internal override void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous)
  1044.             {
  1045.                 Util.Log("RealSchemaType.PrintSchemaType");
  1046.                 if (bAnonymous == false) {
  1047.                     sb.Length = 0;
  1048.                     sb.Append(indent);
  1049.                     sb.Append("<element name='");
  1050.                     sb.Append(ElementName);
  1051.                     sb.Append("' type='");
  1052.                     sb.Append(_xns.Prefix);
  1053.                     sb.Append(':');
  1054.                     sb.Append(Name);
  1055.                     sb.Append("'/>");
  1056.                     textWriter.WriteLine(sb);
  1057.                 }
  1058.                
  1059.                 sb.Length = 0;
  1060.                 sb.Append(indent);
  1061.                 if (bAnonymous == false) {
  1062.                     sb.Append("<complexType name='");
  1063.                     sb.Append(Name);
  1064.                     sb.Append('\'');
  1065.                 }
  1066.                 else {
  1067.                     sb.Append("<complexType ");
  1068.                 }
  1069.                 if (BaseName != null) {
  1070.                     sb.Append(" base='");
  1071.                     sb.Append(BaseName);
  1072.                     sb.Append('\'');
  1073.                 }
  1074.                 if ((IsSealed == true) && (bAnonymous == false))
  1075.                     sb.Append(" final='#all'");
  1076.                 bool bEmpty = IsEmpty;
  1077.                 if (bEmpty)
  1078.                     sb.Append("/>");
  1079.                 else
  1080.                     sb.Append('>');
  1081.                 textWriter.WriteLine(sb);
  1082.                 if (bEmpty)
  1083.                     return;
  1084.                
  1085.                 base.PrintBody(textWriter, sb, indent);
  1086.                
  1087.                 textWriter.Write(indent);
  1088.                 textWriter.WriteLine("</complexType>");
  1089.                
  1090.                 return;
  1091.             }
  1092.            
  1093.            
  1094.             internal void PrintSUDSType(TextWriter textWriter, StringBuilder sb, string indent)
  1095.             {
  1096.                 Util.Log("RealSchemaType.PrintSUDSType");
  1097.                 string elementTag = "<service name='";
  1098.                 string implTag = "<implements name='";
  1099.                 string indent1 = IndentP(indent);
  1100.                 string indent2 = IndentP(indent1);
  1101.                 if (_type.IsInterface) {
  1102.                     elementTag = "<interface name='";
  1103.                     implTag = "<extends name='";
  1104.                 }
  1105.                
  1106.                 sb.Length = 0;
  1107.                 sb.Append(indent);
  1108.                 if (_bUnique) {
  1109.                     sb.Append("<service");
  1110.                 }
  1111.                 else {
  1112.                     sb.Append(elementTag);
  1113.                     sb.Append(Name);
  1114.                 }
  1115.                
  1116.                 bool bExtendsElm = (BaseName != null);
  1117.                 if ((bExtendsElm == false) && (_implIFaces == null) && (_methods.Length == 0)) {
  1118.                     if (_bUnique)
  1119.                         sb.Append("/>");
  1120.                     else
  1121.                         sb.Append("'/>");
  1122.                     textWriter.WriteLine(sb);
  1123.                     return;
  1124.                 }
  1125.                 if (_bUnique)
  1126.                     sb.Append('>');
  1127.                 else
  1128.                     sb.Append("'>");
  1129.                 textWriter.WriteLine(sb);
  1130.                
  1131.                 if (bExtendsElm) {
  1132.                     sb.Length = 0;
  1133.                     sb.Append(indent1);
  1134.                     sb.Append("<extends name='");
  1135.                     sb.Append(BaseName);
  1136.                     sb.Append("'/>");
  1137.                     textWriter.WriteLine(sb);
  1138.                 }
  1139.                 if (_implIFaces != null) {
  1140.                     for (int i = 0; i < _implIFaces.Length; i++) {
  1141.                         if (_implIFaces[i] != String.Empty) {
  1142.                             sb.Length = 0;
  1143.                             sb.Append(indent1);
  1144.                             sb.Append(implTag);
  1145.                             sb.Append(_implIFaces[i]);
  1146.                             sb.Append("'/>");
  1147.                             textWriter.WriteLine(sb);
  1148.                         }
  1149.                     }
  1150.                 }
  1151.                
  1152.                 if (_methods.Length > 0) {
  1153.                     string useNS = null;
  1154.                     if (_xns.IsInteropType)
  1155.                         useNS = _xns.Name;
  1156.                     else {
  1157.                         sb.Length = 0;
  1158.                         sb.Append(_xns.Name);
  1159.                         sb.Append('.');
  1160.                         sb.Append(Name);
  1161.                         useNS = sb.ToString();
  1162.                     }
  1163.                     XMLNamespace methodXns = _xns.LookupSchemaNamespace(useNS, _xns.Assem);
  1164.                     string ns = methodXns.Namespace;
  1165.                     string nsPrefix = methodXns.Prefix;
  1166.                     for (int i = 0; i < _methods.Length; i++) {
  1167.                         MethodInfo method = _methods[i];
  1168.                         bool bOneWay = RemotingServices.IsOneWay(method);
  1169.                         string methodName = method.Name;
  1170.                         sb.Length = 0;
  1171.                         sb.Append(indent1);
  1172.                         if (bOneWay)
  1173.                             sb.Append("<oneway name='");
  1174.                         else
  1175.                             sb.Append("<requestResponse name='");
  1176.                         sb.Append(methodName);
  1177.                         sb.Append("'>");
  1178.                         textWriter.WriteLine(sb);
  1179.                         sb.Length = 0;
  1180.                         sb.Append(indent2);
  1181.                         sb.Append("<soap:operation soapAction='");
  1182.                        
  1183.                         string soapAction = SoapServices.GetSoapActionFromMethodBase(method);
  1184.                         if ((soapAction != null) || (soapAction.Length > 0)) {
  1185.                             sb.Append(soapAction);
  1186.                         }
  1187.                         else {
  1188.                             sb.Append(ns);
  1189.                             sb.Append('#');
  1190.                             sb.Append(methodName);
  1191.                         }
  1192.                         sb.Append("'/>");
  1193.                         textWriter.WriteLine(sb);
  1194.                        
  1195.                         sb.Length = 0;
  1196.                         sb.Append(indent2);
  1197.                         sb.Append("<request ref='");
  1198.                         sb.Append(nsPrefix);
  1199.                         sb.Append(':');
  1200.                         sb.Append(_methodTypes[2 * i]);
  1201.                         sb.Append("'/>");
  1202.                         textWriter.WriteLine(sb);
  1203.                        
  1204.                         if (!bOneWay) {
  1205.                             sb.Length = 0;
  1206.                             sb.Append(indent2);
  1207.                             sb.Append("<response ref='");
  1208.                             sb.Append(nsPrefix);
  1209.                             sb.Append(':');
  1210.                             sb.Append(_methodTypes[2 * i + 1]);
  1211.                             sb.Append("'/>");
  1212.                             textWriter.WriteLine(sb);
  1213.                         }
  1214.                        
  1215.                         textWriter.Write(indent1);
  1216.                         if (bOneWay)
  1217.                             textWriter.WriteLine("</oneway>");
  1218.                         else
  1219.                             textWriter.WriteLine("</requestResponse>");
  1220.                     }
  1221.                 }
  1222.                
  1223.                 if ((_typeToServiceEndpoint != null) && (_typeToServiceEndpoint.ContainsKey(_type.Name))) {
  1224.                     textWriter.Write(indent1);
  1225.                     textWriter.WriteLine("<addresses>");
  1226.                     foreach (string url in (ArrayList)_typeToServiceEndpoint[_type.Name]) {
  1227.                         sb.Length = 0;
  1228.                         sb.Append(indent2);
  1229.                         sb.Append("<address uri='");
  1230.                         sb.Append(url);
  1231.                         sb.Append("'/>");
  1232.                         textWriter.WriteLine(sb);
  1233.                     }
  1234.                     textWriter.Write(indent1);
  1235.                     textWriter.WriteLine("</addresses>");
  1236.                 }
  1237.                 else if (_serviceEndpoint != null) {
  1238.                     textWriter.Write(indent1);
  1239.                     textWriter.WriteLine("<addresses>");
  1240.                     sb.Length = 0;
  1241.                     sb.Append(indent2);
  1242.                     sb.Append("<address uri='");
  1243.                     sb.Append(_serviceEndpoint);
  1244.                     sb.Append("'/>");
  1245.                     textWriter.WriteLine(sb);
  1246.                     textWriter.Write(indent1);
  1247.                     textWriter.WriteLine("</addresses>");
  1248.                 }
  1249.                
  1250.                 textWriter.Write(indent);
  1251.                 textWriter.WriteLine(_type.IsInterface ? "</interface>" : "</service>");
  1252.                 return;
  1253.             }
  1254.            
  1255.             static internal string TypeName(Type type, bool bEmbedded, XMLNamespace thisxns)
  1256.             {
  1257.                 Util.Log("RealSchemaType.TypeName " + type + " bEmbedded " + bEmbedded);
  1258.                 string typeName;
  1259.                 Type uType;
  1260.                 if (type.HasElementType && ((uType = type.GetElementType()) != null)) {
  1261.                     while (uType.HasElementType)
  1262.                         uType = uType.GetElementType();
  1263.                     string uTypeName = TypeName(uType, type.IsArray, thisxns);
  1264.                     string suffix = type.Name.Substring(uType.Name.Length);
  1265.                     // Escape the compiler warning
  1266.                     typeName = " suds:refType='";
  1267.                     if (type.IsArray) {
  1268.                         StringBuilder sb = new StringBuilder(256);
  1269.                         if (bEmbedded)
  1270.                             sb.Append("soap:Array'");
  1271.                         else
  1272.                             sb.Append("soap:Reference'");
  1273.                         sb.Append(typeName);
  1274.                         sb.Append(uTypeName);
  1275.                         sb.Append(suffix);
  1276.                         typeName = sb.ToString();
  1277.                     }
  1278.                     else if (type.IsByRef) {
  1279.                         typeName = uTypeName;
  1280.                     }
  1281.                     else if (type.IsPointer) {
  1282.                         typeName = uTypeName;
  1283.                     }
  1284.                     else {
  1285.                         Debug.Assert(false, "Should not have reached here");
  1286.                     }
  1287.                 }
  1288.                 else if (type.IsPrimitive) {
  1289.                     typeName = "xsd:" + MapURTTypesToSchemaTypes(type.Name);
  1290.                 }
  1291.                 else if (type.FullName == "System.String") {
  1292.                     typeName = "xsd:string";
  1293.                 }
  1294.                 else if (type.FullName == "System.Object") {
  1295.                     if (bEmbedded)
  1296.                         typeName = "xsd:ur-type";
  1297.                     else
  1298.                         //null;
  1299.                         typeName = "soap:Reference' suds:refType='xsd:ur-type";
  1300.                 }
  1301.                 else if (type.FullName == "System.Void") {
  1302.                     typeName = "void";
  1303.                 }
  1304.                 else {
  1305.                     string ns = type.Namespace;
  1306.                     Assembly assem = type.Module.Assembly;
  1307.                     XMLNamespace xns = thisxns.LookupSchemaNamespace(ns, assem);
  1308.                     StringBuilder sb = new StringBuilder(256);
  1309.                     if (bEmbedded == false && type.IsValueType == false)
  1310.                         sb.Append("soap:Reference' suds:refType='");
  1311.                     sb.Append(xns.Prefix);
  1312.                     sb.Append(':');
  1313.                     sb.Append(type.Name);
  1314.                     typeName = sb.ToString();
  1315.                 }
  1316.                
  1317.                 return (typeName);
  1318.             }
  1319.            
  1320.             private static Type[] GetIntroducedInterfaces(Type type)
  1321.             {
  1322.                 Util.Log("RealSchemaType.GetIntroducedInterfaces " + type);
  1323.                 // Count of all implemented interfaces
  1324.                 Type[] intfs = type.GetInterfaces();
  1325.                 int actualLength = intfs.Length;
  1326.                 if (actualLength == 0)
  1327.                     return (emptyTypeSet);
  1328.                 if (type.IsInterface == false) {
  1329.                     // Remove the interfaces implemented by its base type
  1330.                     Type[] baseIntfs = type.BaseType.GetInterfaces();
  1331.                     for (int i = 0; i < baseIntfs.Length; i++) {
  1332.                         for (int j = 0; j < intfs.Length; j++) {
  1333.                             if (intfs[j] == baseIntfs[i]) {
  1334.                                 --actualLength;
  1335.                                 intfs[j] = intfs[actualLength];
  1336.                                 intfs[actualLength] = null;
  1337.                                 break;
  1338.                             }
  1339.                         }
  1340.                     }
  1341.                 }
  1342.                
  1343.                 // Remove interfaces implemented by the given type
  1344.                 // through interface inheritence
  1345.                 for (int i = 0; i < actualLength; i++) {
  1346.                     Type[] inheritedIntfs = intfs[i].GetInterfaces();
  1347.                     for (int j = 0; j < inheritedIntfs.Length; j++) {
  1348.                         for (int k = 0; k < actualLength; k++) {
  1349.                             if (intfs[k] == inheritedIntfs[j]) {
  1350.                                 if (k <= i) {
  1351.                                     intfs[k] = intfs[i];
  1352.                                     k = i;
  1353.                                     --i;
  1354.                                 }
  1355.                                 --actualLength;
  1356.                                 intfs[k] = intfs[actualLength];
  1357.                                 intfs[actualLength] = null;
  1358.                                 break;
  1359.                             }
  1360.                         }
  1361.                     }
  1362.                 }
  1363.                
  1364.                 for (int i = 0; i < intfs.Length; i++) {
  1365.                     if (i < actualLength)
  1366.                         Debug.Assert(intfs[i] != null, "Invariant failure");
  1367.                     else
  1368.                         Debug.Assert(intfs[i] == null, "Invariant failure");
  1369.                 }
  1370.                
  1371.                 if (actualLength < intfs.Length) {
  1372.                     //Array.Clear(intfs, actualLength, intfs.Length - actualLength);
  1373.                     Type[] iFaces = new Type[actualLength];
  1374.                     Array.Copy(intfs, iFaces, actualLength);
  1375.                     return (iFaces);
  1376.                 }
  1377.                
  1378.                 return (intfs);
  1379.             }
  1380.            
  1381.             private static MethodInfo[] GetIntroducedMethods(Type type)
  1382.             {
  1383.                 Util.Log("RealSchemaType.GetIntroducedMethods " + type);
  1384.                 // Count of implemented methods
  1385.                 BindingFlags bFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public;
  1386.                 // | BindingFlags.NonPublic;
  1387.                 MethodInfo[] methods = type.GetMethods(bFlags);
  1388.                 int actualLength = methods.Length;
  1389.                 if (actualLength == 0)
  1390.                     return (emptyMethodSet);
  1391.                 if (type.IsInterface)
  1392.                     return (methods);
  1393.                
  1394.                 // Eliminate interface methods
  1395.                 Type[] iFaces = type.GetInterfaces();
  1396.                 for (int i = 0; i < iFaces.Length; i++) {
  1397.                     InterfaceMapping map = type.GetInterfaceMap(iFaces[i]);
  1398.                     for (int j = 0; j < map.TargetMethods.Length; j++) {
  1399.                         for (int k = 0; k < actualLength; k++) {
  1400.                             if (methods[k] == map.TargetMethods[j]) {
  1401.                                 --actualLength;
  1402.                                 methods[k] = methods[actualLength];
  1403.                                 methods[actualLength] = null;
  1404.                                 break;
  1405.                             }
  1406.                         }
  1407.                     }
  1408.                 }
  1409.                
  1410.                 if (actualLength < methods.Length) {
  1411.                     MethodInfo[] imethods = new MethodInfo[actualLength];
  1412.                     Array.Copy(methods, imethods, actualLength);
  1413.                     return (imethods);
  1414.                 }
  1415.                
  1416.                 return (methods);
  1417.             }
  1418.            
  1419.             private static FieldInfo[] GetInstanceFields(Type type)
  1420.             {
  1421.                 Util.Log("RealSchemaType.GetIntroducedFields " + type);
  1422.                 BindingFlags bFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
  1423.                 FieldInfo[] fields = type.GetFields(bFlags);
  1424.                 int actualLength = fields.Length;
  1425.                 if (actualLength == 0)
  1426.                     return (emptyFieldSet);
  1427.                
  1428.                 for (int i = 0; i < fields.Length; i++) {
  1429.                     if (fields[i].IsStatic) {
  1430.                         Debug.Assert(false, "Static Field");
  1431.                         --actualLength;
  1432.                         fields[i] = fields[actualLength];
  1433.                         fields[actualLength] = null;
  1434.                     }
  1435.                 }
  1436.                
  1437.                 if (actualLength < fields.Length) {
  1438.                     FieldInfo[] ifields = new FieldInfo[actualLength];
  1439.                     Array.Copy(fields, ifields, actualLength);
  1440.                     return (ifields);
  1441.                 }
  1442.                
  1443.                 return (fields);
  1444.             }
  1445.            
  1446.             // Instance fields
  1447.             private Type _type;
  1448.             private string _serviceEndpoint;
  1449.             private Hashtable _typeToServiceEndpoint;
  1450.             private bool _bUnique;
  1451.             private XMLNamespace _xns;
  1452.             private bool _bStruct;
  1453.             private string[] _implIFaces;
  1454.            
  1455.             private Type[] _iFaces;
  1456.             private MethodInfo[] _methods;
  1457.             private string[] _methodTypes;
  1458.             private FieldInfo[] _fields;
  1459.            
  1460.             // Static fields
  1461.             private static Type[] emptyTypeSet = new Type[0];
  1462.             private static MethodInfo[] emptyMethodSet = new MethodInfo[0];
  1463.             private static FieldInfo[] emptyFieldSet = new FieldInfo[0];
  1464.         }
  1465.         // End RealSchema
  1466.         private class XMLNamespace
  1467.         {
  1468.             internal XMLNamespace(string name, Assembly assem, string serviceEndpoint, Hashtable typeToServiceEndpoint, string prefix, bool bInteropType)
  1469.             {
  1470.                 Util.Log("XMLNamespace.XMLNamespace " + name + " serviceEndpoint " + serviceEndpoint + " prefix " + prefix + " bInteropType " + bInteropType);
  1471.                 _name = name;
  1472.                 _assem = assem;
  1473.                 _bUnique = false;
  1474.                 _bInteropType = bInteropType;
  1475.                 StringBuilder sb = new StringBuilder(256);
  1476.                 Assembly systemAssembly = typeof(string).Module.Assembly;
  1477.                
  1478.                 if (assem == systemAssembly) {
  1479.                     sb.Append(SoapServices.CodeXmlNamespaceForClrTypeNamespace(name, null));
  1480.                 }
  1481.                 else if (assem != null) {
  1482.                     sb.Append(SoapServices.CodeXmlNamespaceForClrTypeNamespace(name, assem.GetName().Name));
  1483.                 }
  1484.                 else {
  1485.                     sb.Append(name);
  1486.                 }
  1487.                
  1488.                 _namespace = sb.ToString();
  1489.                 _prefix = prefix;
  1490.                 _dependsOnSchemaNS = new ArrayList();
  1491.                 _realSUDSTypes = new ArrayList();
  1492.                 _dependsOnSUDSNS = new ArrayList();
  1493.                 _realSchemaTypes = new ArrayList();
  1494.                 _phonySchemaTypes = new ArrayList();
  1495.                 _simpleSchemaTypes = new ArrayList();
  1496.                 _serviceEndpoint = serviceEndpoint;
  1497.                 _typeToServiceEndpoint = typeToServiceEndpoint;
  1498.             }
  1499.            
  1500.            
  1501.             internal string Name {
  1502.                 get { return (_name); }
  1503.             }
  1504.             internal Assembly Assem {
  1505.                 get { return (_assem); }
  1506.             }
  1507.             internal string Prefix {
  1508.                 get { return (_prefix); }
  1509.             }
  1510.             internal string Namespace {
  1511.                 get { return (_namespace); }
  1512.             }
  1513.            
  1514.             internal bool IsInteropType {
  1515.                 get { return (_bInteropType); }
  1516.             }
  1517.            
  1518.            
  1519.             internal Type LookupSchemaType(string name)
  1520.             {
  1521.                 Util.Log("XMLNamespace.LookupSchemaType " + name);
  1522.                 RealSchemaType rsType = LookupRealSchemaType(name);
  1523.                 if (rsType != null)
  1524.                     return (rsType.Type);
  1525.                
  1526.                 SimpleSchemaType ssType = LookupSimpleSchemaType(name);
  1527.                 if (ssType != null)
  1528.                     return (ssType.Type);
  1529.                
  1530.                 return (null);
  1531.             }
  1532.            
  1533.             internal SimpleSchemaType LookupSimpleSchemaType(string name)
  1534.             {
  1535.                 Util.Log("XMLNamespace.LookupSimpleSchemaType " + name);
  1536.                 for (int i = 0; i < _simpleSchemaTypes.Count; i++) {
  1537.                     SimpleSchemaType ssType = (SimpleSchemaType)_simpleSchemaTypes[i];
  1538.                     if (ssType.Type.Name == name)
  1539.                         return (ssType);
  1540.                 }
  1541.                
  1542.                 return (null);
  1543.             }
  1544.            
  1545.             internal RealSchemaType LookupRealSchemaType(string name)
  1546.             {
  1547.                 Util.Log("XMLNamespace.LookupRealSchemaType " + name);
  1548.                 Debug.Assert(_phonySchemaTypes.Count == 0, "PhonyTypes present");
  1549.                 for (int i = 0; i < _realSchemaTypes.Count; i++) {
  1550.                     RealSchemaType rsType = (RealSchemaType)_realSchemaTypes[i];
  1551.                     if (rsType.Name == name)
  1552.                         return (rsType);
  1553.                 }
  1554.                
  1555.                 return (null);
  1556.             }
  1557.            
  1558.             internal void AddRealSUDSType(RealSchemaType rsType)
  1559.             {
  1560.                 Util.Log("XMLNamespace.AddRealSUDSType ");
  1561.                 _realSUDSTypes.Add(rsType);
  1562.                 return;
  1563.             }
  1564.            
  1565.             internal void AddRealSchemaType(RealSchemaType rsType)
  1566.             {
  1567.                 Debug.Assert(LookupRealSchemaType(rsType.Name) == null, "Duplicate Type found");
  1568.                 _realSchemaTypes.Add(rsType);
  1569.                 if (rsType.IsUnique)
  1570.                     _bUnique = true;
  1571.                
  1572.                 return;
  1573.             }
  1574.            
  1575.             internal void AddSimpleSchemaType(SimpleSchemaType ssType)
  1576.             {
  1577.                 Util.Log("XMLNamespace.AddSimpleSchemaType ");
  1578.                 Debug.Assert(LookupSimpleSchemaType(ssType.Type.Name) == null, "Duplicate Type found");
  1579.                 _simpleSchemaTypes.Add(ssType);
  1580.                
  1581.                 return;
  1582.             }
  1583.            
  1584.             private PhonySchemaType LookupPhonySchemaType(string name)
  1585.             {
  1586.                 Util.Log("XMLNamespace.LookupPhonySchemaType " + name);
  1587.                 for (int i = 0; i < _phonySchemaTypes.Count; i++) {
  1588.                     PhonySchemaType type = (PhonySchemaType)_phonySchemaTypes[i];
  1589.                     if (type.Name == name)
  1590.                         return (type);
  1591.                 }
  1592.                
  1593.                 return (null);
  1594.             }
  1595.            
  1596.             internal void AddPhonySchemaType(PhonySchemaType phType)
  1597.             {
  1598.                 Util.Log("XMLNamespace.AddPhonySchemaType ");
  1599.                 PhonySchemaType overloadedType = LookupPhonySchemaType(phType.Name);
  1600.                 if (overloadedType != null)
  1601.                     phType.ElementName = phType.Name + overloadedType.OverloadedType();
  1602.                 _phonySchemaTypes.Add(phType);
  1603.                
  1604.                 return;
  1605.             }
  1606.            
  1607.             internal XMLNamespace LookupSchemaNamespace(string ns, Assembly assem)
  1608.             {
  1609.                 Util.Log("XMLNamespace.LookupSchemaNamespace " + ns);
  1610.                 for (int i = 0; i < _dependsOnSchemaNS.Count; i++) {
  1611.                     XMLNamespace xns = (XMLNamespace)_dependsOnSchemaNS[i];
  1612.                     if ((xns.Name == ns) && (xns.Assem == assem))
  1613.                         return (xns);
  1614.                 }
  1615.                
  1616.                 return (null);
  1617.             }
  1618.            
  1619.             internal void DependsOnSchemaNS(XMLNamespace xns)
  1620.             {
  1621.                 Util.Log("XMLNamespace.DependsOnSchemaNS ");
  1622.                 if (LookupSchemaNamespace(xns.Name, xns.Assem) != null)
  1623.                     return;
  1624.                
  1625.                 _dependsOnSchemaNS.Add(xns);
  1626.                 return;
  1627.             }
  1628.            
  1629.             private XMLNamespace LookupSUDSNamespace(string ns, Assembly assem)
  1630.             {
  1631.                 Util.Log("XMLNamespace.LookupSUDSNamespace " + ns);
  1632.                 for (int i = 0; i < _dependsOnSUDSNS.Count; i++) {
  1633.                     XMLNamespace xns = (XMLNamespace)_dependsOnSUDSNS[i];
  1634.                     if ((xns.Name == ns) && (xns.Assem == assem))
  1635.                         return (xns);
  1636.                 }
  1637.                
  1638.                 return (null);
  1639.             }
  1640.            
  1641.             internal void DependsOnSUDSNS(XMLNamespace xns)
  1642.             {
  1643.                 Util.Log("XMLNamespace.DpendsOnSUDSNS " + xns.Name + " " + xns.Assem);
  1644.                 if (LookupSUDSNamespace(xns.Name, xns.Assem) != null)
  1645.                     return;
  1646.                
  1647.                 _dependsOnSUDSNS.Add(xns);
  1648.                 return;
  1649.             }
  1650.            
  1651.             internal void Resolve()
  1652.             {
  1653.                 Util.Log("XMLNamespace.Resolve");
  1654.                 StringBuilder sb = new StringBuilder(256);
  1655.                 for (int i = 0; i < _realSchemaTypes.Count; i++)
  1656.                     ((RealSchemaType)_realSchemaTypes[i]).Resolve(sb);
  1657.                
  1658.                 return;
  1659.             }
  1660.            
  1661.             internal void PrintDependsOn(TextWriter textWriter, StringBuilder sb, string indent)
  1662.             {
  1663.                 if (_realSchemaTypes.Count > 0 || _phonySchemaTypes.Count > 0 || _simpleSchemaTypes.Count > 0) {
  1664.                     Util.Log("XMLNamespace.PrintDependsOn " + _name + " targetNameSpace " + Namespace);
  1665.                     if (_dependsOnSchemaNS.Count > 0) {
  1666.                         for (int i = 0; i < _dependsOnSchemaNS.Count; i++) {
  1667.                             XMLNamespace xns = (XMLNamespace)_dependsOnSchemaNS[i];
  1668.                             sb.Length = 0;
  1669.                             sb.Append(indent);
  1670.                             sb.Append("xmlns:");
  1671.                             sb.Append(xns.Prefix);
  1672.                             sb.Append("='");
  1673.                             sb.Append(xns.Namespace);
  1674.                             sb.Append("'");
  1675.                             textWriter.WriteLine(sb);
  1676.                         }
  1677.                     }
  1678.                 }
  1679.             }
  1680.            
  1681.             internal void PrintSdl(TextWriter textWriter, string indent)
  1682.             {
  1683.                 Util.Log("XMLNamespace.PrintSdl ");
  1684.                 StringBuilder sb = new StringBuilder(256);
  1685.                 string endSuds = null;
  1686.                
  1687.                 sb.Append(indent);
  1688.                 // Print suds types
  1689.                 if (_realSUDSTypes.Count > 0) {
  1690.                     //endSuds = indentation + "</suds>";
  1691.                     endSuds = indent + "</soap>";
  1692.                     indent = IndentP(indent);
  1693.                     if (_bUnique) {
  1694.                         sb.Append("<soap xmlns='urn:schemas-xmlsoap-org:soap-sdl-2000-01-25'");
  1695.                     }
  1696.                     else {
  1697.                         //sb.Append("<suds targetNamespace='");
  1698.                         sb.Append("<soap targetNamespace='");
  1699.                         sb.Append(Namespace);
  1700.                         sb.Append('\'');
  1701.                         textWriter.WriteLine(sb);
  1702.                        
  1703.                         sb.Length = 0;
  1704.                         sb.Append(indent);
  1705.                         //sb.Append("xmlns='urn:schemas-xmlsoap-org:suds.v1'");
  1706.                         sb.Append("xmlns='urn:schemas-xmlsoap-org:soap-sdl-2000-01-25'");
  1707.                     }
  1708.                     textWriter.WriteLine(sb);
  1709.                    
  1710.                     sb.Length = 0;
  1711.                     sb.Append(indent);
  1712.                     sb.Append("xmlns:soap='urn:schemas-xmlsoap-org:soap.v1'");
  1713.                     textWriter.WriteLine(sb);
  1714.                    
  1715.                     for (int i = 0; i < _dependsOnSUDSNS.Count; i++) {
  1716.                         XMLNamespace xns = (XMLNamespace)_dependsOnSUDSNS[i];
  1717.                         sb.Length = indent.Length;
  1718.                         sb.Append("xmlns:");
  1719.                         sb.Append(xns.Prefix);
  1720.                         sb.Append("='");
  1721.                         sb.Append(xns.Namespace);
  1722.                         if (i == _dependsOnSUDSNS.Count - 1)
  1723.                             sb.Append("'>");
  1724.                         else
  1725.                             sb.Append('\'');
  1726.                        
  1727.                         textWriter.WriteLine(sb);
  1728.                     }
  1729.                    
  1730.                     for (int i = 0; i < _realSUDSTypes.Count; i++)
  1731.                         ((RealSchemaType)_realSUDSTypes[i]).PrintSUDSType(textWriter, sb, indent);
  1732.                    
  1733.                 }
  1734.                
  1735.                 bool bReal = false;
  1736.                 for (int i = 0; i < _realSchemaTypes.Count; i++) {
  1737.                     RealSchemaType rsType = (RealSchemaType)_realSchemaTypes[i];
  1738.                     if (!rsType.Type.IsInterface && !rsType.IsSUDSType)
  1739.                         bReal = true;
  1740.                 }
  1741.                
  1742.                 // Print schema types
  1743.                 if (bReal || _phonySchemaTypes.Count > 0 || _simpleSchemaTypes.Count > 0) {
  1744.                    
  1745.                     sb.Length = indent.Length;
  1746.                     sb.Append("<schema targetNamespace='");
  1747.                     sb.Append(Namespace);
  1748.                     sb.Append('\'');
  1749.                     textWriter.WriteLine(sb);
  1750.                    
  1751.                     string endSchema = indent + "</schema>";
  1752.                     indent = IndentP(indent);
  1753.                    
  1754.                     sb.Length = 0;
  1755.                     sb.Append(indent);
  1756.                     sb.Append("xmlns='http://www.w3.org/2000/10/XMLSchema'");
  1757.                     textWriter.WriteLine(sb);
  1758.                    
  1759.                     sb.Length = 0;
  1760.                     sb.Append(indent);
  1761.                     sb.Append("xmlns:xsd='http://www.w3.org/2000/10/XMLSchema'");
  1762.                     textWriter.WriteLine(sb);
  1763.                    
  1764.                     sb.Length = indent.Length;
  1765.                     sb.Append("xmlns:xsi='http://www.w3.org/2000/10/XMLSchema-instance'");
  1766.                     textWriter.WriteLine(sb);
  1767.                    
  1768.                     sb.Length = indent.Length;
  1769.                     sb.Append("xmlns:suds='urn:schemas-xmlsoap-org:soap-sdl-2000-01-25'");
  1770.                     textWriter.WriteLine(sb);
  1771.                    
  1772.                     sb.Length = indent.Length;
  1773.                     sb.Append("xmlns:soap='urn:schemas-xmlsoap-org:soap.v1'");
  1774.                     textWriter.Write(sb);
  1775.                    
  1776.                     if (_dependsOnSchemaNS.Count > 0) {
  1777.                         sb.Length = 0;
  1778.                         sb.Append(textWriter.NewLine);
  1779.                         sb.Append(indent);
  1780.                         sb.Append("xmlns:");
  1781.                         string cachedString = sb.ToString();
  1782.                         for (int i = 0; i < _dependsOnSchemaNS.Count; i++) {
  1783.                             XMLNamespace xns = (XMLNamespace)_dependsOnSchemaNS[i];
  1784.                             sb.Length = cachedString.Length;
  1785.                             sb.Append(xns.Prefix);
  1786.                             sb.Append("='");
  1787.                             sb.Append(xns.Namespace);
  1788.                             sb.Append('\'');
  1789.                             textWriter.Write(sb);
  1790.                         }
  1791.                     }
  1792.                     textWriter.WriteLine(" elementFormDefault='unqualified' attributeFormDefault='unqualified'>");
  1793.                    
  1794.                     for (int i = 0; i < _simpleSchemaTypes.Count; i++) {
  1795.                         SimpleSchemaType ssType = (SimpleSchemaType)_simpleSchemaTypes[i];
  1796.                         ssType.PrintSchemaType(textWriter, sb, indent, false);
  1797.                     }
  1798.                    
  1799.                     for (int i = 0; i < _realSchemaTypes.Count; i++) {
  1800.                         RealSchemaType rsType = (RealSchemaType)_realSchemaTypes[i];
  1801.                         if (!rsType.Type.IsInterface && !rsType.IsSUDSType)
  1802.                             rsType.PrintSchemaType(textWriter, sb, indent, false);
  1803.                     }
  1804.                    
  1805.                     for (int i = 0; i < _phonySchemaTypes.Count; i++) {
  1806.                         PhonySchemaType psType = (PhonySchemaType)_phonySchemaTypes[i];
  1807.                         psType.PrintSchemaType(textWriter, sb, indent, true);
  1808.                     }
  1809.                    
  1810.                     textWriter.WriteLine(endSchema);
  1811.                 }
  1812.                
  1813.                 if (endSuds != null)
  1814.                     textWriter.WriteLine(endSuds);
  1815.                
  1816.                 return;
  1817.             }
  1818.            
  1819.             // Fields
  1820.             private string _name;
  1821.             private Assembly _assem;
  1822.             private string _namespace;
  1823.             private string _prefix;
  1824.             private bool _bUnique;
  1825.             private ArrayList _dependsOnSUDSNS;
  1826.             private ArrayList _realSUDSTypes;
  1827.             private ArrayList _dependsOnSchemaNS;
  1828.             private ArrayList _realSchemaTypes;
  1829.             private ArrayList _phonySchemaTypes;
  1830.             private ArrayList _simpleSchemaTypes;
  1831.             private bool _bInteropType;
  1832.             private string _serviceEndpoint;
  1833.             private Hashtable _typeToServiceEndpoint;
  1834.            
  1835.         }
  1836.        
  1837.         static internal string IndentP(string indentStr)
  1838.         {
  1839.             return indentStr + " ";
  1840.         }
  1841.        
  1842.         static internal string IndentM(string indentStr)
  1843.         {
  1844.             return indentStr.Substring(0, indentStr.Length - 4);
  1845.         }
  1846.     }
  1847. }

Developer Fusion