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

  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: WsdlWriter.cs
  18. // Purpose: Defines WsdlWriter that parses a given Wsdl document
  19. // and generates types defined in it.
  20. //
  21. // Date: November 15, 2000
  22. //
  23. //============================================================
  24. namespace System.Runtime.Remoting.MetadataServices
  25. {
  26.     using System;
  27.     using System.Threading;
  28.     using System.Collections;
  29.     using System.Reflection;
  30.     using System.Xml;
  31.     using System.Diagnostics;
  32.     using System.IO;
  33.     using System.Text;
  34.     using System.Net;
  35.     using System.Runtime.Remoting.Messaging;
  36.     using System.Runtime.Remoting.Metadata;
  37.     using System.Runtime.Serialization;
  38.     using System.Runtime.Remoting.Channels;
  39.     // This is so we can get the resource strings.
  40.     using System.Globalization;
  41.    
  42.     // This class generates SUDS documents
  43.     internal class WsdlGenerator
  44.     {
  45.         // Constructor
  46.         internal WsdlGenerator(Type[] types, TextWriter output)
  47.         {
  48.             Util.Log("WsdlGenerator.WsdlGenerator 1");
  49.             _textWriter = output;
  50.             _queue = new Queue();
  51.             _name = null;
  52.             _namespaces = new ArrayList();
  53.             _dynamicAssembly = null;
  54.             _serviceEndpoint = null;
  55.             for (int i = 0; i < types.Length; i++) {
  56.                 if (types[i] != null) {
  57.                     if (types[i].BaseType != null) {
  58.                         Util.Log("WsdlGenerator.WsdlGenerator ProcessTypeAttributes 1 " + types[i]);
  59.                         ProcessTypeAttributes(types[i]);
  60.                         _queue.Enqueue(types[i]);
  61.                     }
  62.                 }
  63.             }
  64.         }
  65.        
  66.         // Constructor
  67.         internal WsdlGenerator(Type[] types, SdlType sdlType, TextWriter output)
  68.         {
  69.             Util.Log("WsdlGenerator.WsdlGenerator 2");
  70.             _textWriter = output;
  71.             _queue = new Queue();
  72.             _name = null;
  73.             _namespaces = new ArrayList();
  74.             _dynamicAssembly = null;
  75.             _serviceEndpoint = null;
  76.             for (int i = 0; i < types.Length; i++) {
  77.                 if (types[i] != null) {
  78.                     if (types[i].BaseType != null) {
  79.                         Util.Log("WsdlGenerator.WsdlGenerator ProcessTypeAttributes 2 " + types[i].BaseType);
  80.                         ProcessTypeAttributes(types[i]);
  81.                         _queue.Enqueue(types[i]);
  82.                     }
  83.                 }
  84.             }
  85.         }
  86.        
  87.         // Constructor
  88.         internal WsdlGenerator(Type[] types, TextWriter output, Assembly assembly, string url) : this(types, output)
  89.         {
  90.             Util.Log("WsdlGenerator.WsdlGenerator 3 " + url);
  91.             _dynamicAssembly = assembly;
  92.             _serviceEndpoint = url;
  93.         }
  94.        
  95.         // Constructor
  96.         internal WsdlGenerator(Type[] types, SdlType sdlType, TextWriter output, Assembly assembly, string url) : this(types, output)
  97.         {
  98.             Util.Log("WsdlGenerator.WsdlGenerator 4 " + url);
  99.             _dynamicAssembly = assembly;
  100.             _serviceEndpoint = url;
  101.         }
  102.        
  103.         internal WsdlGenerator(ServiceType[] serviceTypes, SdlType sdlType, TextWriter output)
  104.         {
  105.             Util.Log("WsdlGenerator.WsdlGenerator 5 ");
  106.             _textWriter = output;
  107.             _queue = new Queue();
  108.             _name = null;
  109.             _namespaces = new ArrayList();
  110.             _dynamicAssembly = null;
  111.             _serviceEndpoint = null;
  112.            
  113.             for (int i = 0; i < serviceTypes.Length; i++) {
  114.                 if (serviceTypes[i] != null) {
  115.                     if (serviceTypes[i].ObjectType.BaseType != null) {
  116.                         Util.Log("WsdlGenerator.WsdlGenerator ProcessTypeAttributes 3 objectType " + serviceTypes[i].ObjectType + " basetype " + serviceTypes[i].ObjectType.BaseType);
  117.                         ProcessTypeAttributes(serviceTypes[i].ObjectType);
  118.                         _queue.Enqueue(serviceTypes[i].ObjectType);
  119.                     }
  120.                 }
  121.                
  122.                 // Associate serviceEndpoint with type. A type can have multiple serviceEndpoints
  123.                 if (serviceTypes[i].Url != null) {
  124.                     if (_typeToServiceEndpoint == null)
  125.                         _typeToServiceEndpoint = new Hashtable(10);
  126.                     if (_typeToServiceEndpoint.ContainsKey(serviceTypes[i].ObjectType.Name)) {
  127.                         ArrayList serviceEndpoints = (ArrayList)_typeToServiceEndpoint[serviceTypes[i].ObjectType.Name];
  128.                         serviceEndpoints.Add(serviceTypes[i].Url);
  129.                     }
  130.                     else {
  131.                         ArrayList serviceEndpoints = new ArrayList(10);
  132.                         serviceEndpoints.Add(serviceTypes[i].Url);
  133.                         _typeToServiceEndpoint[serviceTypes[i].ObjectType.Name] = serviceEndpoints;
  134.                     }
  135.                    
  136.                 }
  137.             }
  138.         }
  139.        
  140.         static internal void QualifyName(StringBuilder sb, string ns, string name)
  141.         {
  142.             if (!(ns == null || ns.Length == 0)) {
  143.                 sb.Append(ns);
  144.                 sb.Append('.');
  145.             }
  146.             sb.Append(name);
  147.         }
  148.        
  149.        
  150.         static internal string RefName(Type type)
  151.         {
  152.             string refName = type.Name;
  153.            
  154.             if (!(type.IsPublic || type.IsNotPublic)) {
  155.                 Util.Log("WsdlGenerator.WsdlGenerator RefName nested " + type);
  156.                 // nested name
  157.                 refName = type.FullName;
  158.                 int index = refName.LastIndexOf('.');
  159.                 if (index > 0) {
  160.                     // nested type, type.Name returns full type rather then simple type
  161.                     refName = refName.Substring(index + 1);
  162.                 }
  163.                 refName = refName.Replace('+', '.');
  164.             }
  165.            
  166.             return refName;
  167.         }
  168.        
  169.         internal void ProcessTypeAttributes(Type type)
  170.         {
  171.             // Check to see if the xsd and xsi schema types should be 1999 instead of 2000. This is a temporary fix for an interop problem
  172.             SoapTypeAttribute att = InternalRemotingServices.GetCachedSoapAttribute(type) as SoapTypeAttribute;
  173.             if (att != null) {
  174.                 SoapOption soapOption = att.SoapOptions;
  175.                 if ((soapOption &= SoapOption.Option1) == SoapOption.Option1)
  176.                     _xsdVersion = XsdVersion.V1999;
  177.                 else if ((soapOption &= SoapOption.Option2) == SoapOption.Option2)
  178.                     _xsdVersion = XsdVersion.V2000;
  179.                 else
  180.                     _xsdVersion = XsdVersion.V2001;
  181.             }
  182.             Util.Log("WsdlGenerator.ProcessTypeAttributes " + type + " SoapOptions " + ((Enum)att.SoapOptions).ToString() + " _xsdVersion " + ((Enum)_xsdVersion).ToString());
  183.            
  184.         }
  185.        
  186.        
  187.         // Generates SUDS
  188.         internal void Generate()
  189.         {
  190.             Util.Log("WsdlGenerator.Generate");
  191.             // Generate the trasitive closure of the types reachable from
  192.             // the supplied types
  193.             while (_queue.Count > 0) {
  194.                 // Dequeue from not yet seen queue
  195.                 Type type = (Type)_queue.Dequeue();
  196.                 ProcessType(type);
  197.             }
  198.            
  199.             // At this point we have the complete list of types
  200.             // to be processed. Resolve cross references between
  201.             // them
  202.             Resolve();
  203.            
  204.             // At this stage, we are ready to print the schemas
  205.             PrintWsdl();
  206.            
  207.             // Flush cached buffers
  208.             _textWriter.Flush();
  209.            
  210.             return;
  211.         }
  212.        
  213.         internal void ProcessType(Type type)
  214.         {
  215.             // Check if the type was encountered earlier
  216.             string ns;
  217.             Assembly assem;
  218.             bool bInteropType = GetNSAndAssembly(type, out ns, out assem);
  219.             Util.Log("WsdlGenerator.ProcessType Dequeue " + type + " ns " + ns + " assem " + assem);
  220.             XMLNamespace xns = LookupNamespace(ns, assem);
  221.             if (xns != null) {
  222.                 string searchName = WsdlGenerator.RefName(type);
  223.                
  224.                 if (xns.LookupSchemaType(searchName) != null) {
  225.                     return;
  226.                 }
  227.             }
  228.             else {
  229.                 xns = AddNamespace(ns, assem, bInteropType);
  230.             }
  231.             _typeToInteropNS[type] = xns;
  232.            
  233.             if (!type.IsArray) {
  234.                 // Check if type needs to be represented as a SimpleSchemaType
  235.                 SimpleSchemaType ssType = SimpleSchemaType.GetSimpleSchemaType(type, xns, false);
  236.                 Util.Log("WsdlGenerator.ProcessType simpleType " + ssType);
  237.                
  238.                 if (ssType != null) {
  239.                     // Add to namespace as a SimpleSchemaType
  240.                     xns.AddSimpleSchemaType(ssType);
  241.                 }
  242.                 else {
  243.                     // Check for the first MarshalByRef type
  244.                     bool bUnique = false;
  245.                     string connectURL = null;
  246.                     Hashtable connectTypeToServiceEndpoint = null;
  247.                     if (_name == null && s_marshalByRefType.IsAssignableFrom(type)) {
  248.                         Util.Log("WsdlGenerator.ProcessType need new type " + type + " typename " + type.Name);
  249.                         _name = type.Name;
  250.                         _targetNS = xns.Namespace;
  251.                         _targetNSPrefix = xns.Prefix;
  252.                         connectURL = _serviceEndpoint;
  253.                         connectTypeToServiceEndpoint = _typeToServiceEndpoint;
  254.                         bUnique = true;
  255.                     }
  256.                    
  257.                     RealSchemaType rsType = new RealSchemaType(type, xns, connectURL, connectTypeToServiceEndpoint, bUnique, this);
  258.                     // Add to namespace as a RealSchemaType
  259.                     xns.AddRealSchemaType(rsType);
  260.                     // Enqueue types reachable from this type
  261.                     EnqueueReachableTypes(rsType);
  262.                 }
  263.             }
  264.         }
  265.        
  266.         // Adds types reachable from the given type
  267.         private void EnqueueReachableTypes(RealSchemaType rsType)
  268.         {
  269.             Util.Log("WsdlGenerator.EnqueueReachableTypes " + rsType.Name + " " + rsType.XNS.Name);
  270.             // Get the XML namespace object
  271.             XMLNamespace xns = rsType.XNS;
  272.            
  273.             // Process base type
  274.             if (rsType.Type.BaseType != null) {
  275.                 if (rsType.Type.BaseType != s_valueType || rsType.Type.BaseType != s_objectType)
  276.                     AddType(rsType.Type.BaseType, GetNamespace(rsType.Type.BaseType));
  277.             }
  278.            
  279.             // Check if this is a suds type
  280.             bool bSUDSType = rsType.Type.IsInterface || s_marshalByRefType.IsAssignableFrom(rsType.Type) || rsType.Type.IsSerializable || s_delegateType.IsAssignableFrom(rsType.Type);
  281.             if (bSUDSType) {
  282.                 Util.Log("WsdlGenerator.EnqueueReachableTypes suds type " + rsType.Name + " " + rsType.XNS.Name);
  283.                 // Process fields
  284.                 FieldInfo[] fields = rsType.GetInstanceFields();
  285.                 for (int i = 0; i < fields.Length; i++) {
  286.                     if (fields[i].FieldType == null)
  287.                         continue;
  288.                     AddType(fields[i].FieldType, xns);
  289.                 }
  290.                
  291.                 // Process implemented interfaces
  292.                 Type[] interfaces = rsType.GetIntroducedInterfaces();
  293.                 if (interfaces.Length > 0) {
  294.                     for (int i = 0; i < interfaces.Length; i++) {
  295.                         Util.Log("WsdlGenerator.EnqueueReachableTypes Interfaces " + interfaces[i].Name + " " + xns.Name);
  296.                         AddType(interfaces[i], xns);
  297.                     }
  298.                 }
  299.                
  300.                 ProcessMethods(rsType);
  301.                
  302.             }
  303.             else {
  304.                 // Process fields
  305.                 FieldInfo[] fields = rsType.GetInstanceFields();
  306.                 for (int i = 0; i < fields.Length; i++) {
  307.                     if (fields[i].FieldType == null)
  308.                         continue;
  309.                     AddType(fields[i].FieldType, xns);
  310.                 }
  311.             }
  312.            
  313.             return;
  314.         }
  315.        
  316.         private void ProcessMethods(RealSchemaType rsType)
  317.         {
  318.             Util.Log("WsdlGenerator.ProcessMethods " + rsType);
  319.             XMLNamespace xns = rsType.XNS;
  320.             MethodInfo[] methods = rsType.GetIntroducedMethods();
  321.             if (methods.Length > 0) {
  322.                 string methodNSString = null;
  323.                 XMLNamespace methodXNS = null;
  324.                
  325.                 if (xns.IsInteropType) {
  326.                     methodNSString = xns.Name;
  327.                     methodXNS = xns;
  328.                 }
  329.                 else {
  330.                     StringBuilder sb = new StringBuilder();
  331.                     WsdlGenerator.QualifyName(sb, xns.Name, rsType.Name);
  332.                     methodNSString = sb.ToString();
  333.                     methodXNS = AddNamespace(methodNSString, xns.Assem);
  334.                     xns.DependsOnSchemaNS(methodXNS, false);
  335.                 }
  336.                
  337.                 for (int i = 0; i < methods.Length; i++) {
  338.                     MethodInfo method = methods[i];
  339.                     Util.Log("WsdlGenerator.ProcessMethods methods " + method.Name + " " + methodXNS.Name);
  340.                     AddType(method.ReturnType, methodXNS);
  341.                     ParameterInfo[] parameters = method.GetParameters();
  342.                     for (int j = 0; j < parameters.Length; j++)
  343.                         AddType(parameters[j].ParameterType, methodXNS);
  344.                 }
  345.             }
  346.         }
  347.        
  348.        
  349.         // Adds the given type if it has not been encountered before
  350.         private void AddType(Type type, XMLNamespace xns)
  351.         {
  352.             Util.Log("WsdlGenerator.AddType " + type + " ns " + xns.Namespace);
  353.             // System.Array says that it has element type, but returns null
  354.             // when asked for the element type.
  355.            
  356.            
  357.             // Need to get underlying element type
  358.             // For arrays of arrays, want element, not embedded array
  359.             Type elementType = type.GetElementType();
  360.             Type nextelementType = elementType;
  361.             while (nextelementType != null) {
  362.                 nextelementType = elementType.GetElementType();
  363.                 if (nextelementType != null)
  364.                     elementType = nextelementType;
  365.                
  366.             }
  367.             Util.Log("WsdlGenerator.AddType elementType " + type + " elementType " + elementType);
  368.            
  369.             if (elementType != null)
  370.                 EnqueueType(elementType, xns);
  371.            
  372.            
  373.             if (!type.IsArray && !type.IsByRef)
  374.                 EnqueueType(type, xns);
  375.            
  376.             if (!(type.IsPublic || type.IsNotPublic)) {
  377.                 // nested type, enqueue parent
  378.                 string refTypeName = type.FullName;
  379.                 int index = refTypeName.IndexOf("+");
  380.                 if (index > 0) {
  381.                     string parentName = refTypeName.Substring(0, index);
  382.                     Assembly assembly = type.Module.Assembly;
  383.                     Util.Log("WsdlGenerator.AddType parentName " + parentName + " assembly " + assembly);
  384.                     Type parentType = assembly.GetType(parentName, true);
  385.                     Util.Log("WsdlGenerator.AddType parentType " + parentType);
  386.                     if (parentType == null) {
  387.                         //Error nested type
  388.                     }
  389.                     EnqueueType(parentType, xns);
  390.                 }
  391.             }
  392.         }
  393.        
  394.         private void EnqueueType(Type type, XMLNamespace xns)
  395.         {
  396.             Util.Log("WsdlGenerator.EnqueueType " + type + " ns " + xns.Namespace);
  397.             //char is not a xsd type
  398.             if (!type.IsPrimitive || type == s_charType) {
  399.                 string ns;
  400.                 Assembly assem;
  401.                 XMLNamespace dependsOnNS = null;
  402.                
  403.                 bool bInteropType = GetNSAndAssembly(type, out ns, out assem);
  404.                
  405.                 // Lookup the namespace
  406.                 dependsOnNS = LookupNamespace(ns, assem);
  407.                 // Creat a new namespace if neccessary
  408.                 if (dependsOnNS == null)
  409.                     dependsOnNS = AddNamespace(ns, assem, bInteropType);
  410.                
  411.                 // The supplied namespace depends directly on the namespace of the type
  412.                 string typeString = SudsConverter.MapClrTypeToXsdType(type);
  413.                 //see if this is a xsd type
  414.                 if (type.IsInterface || typeString != null || type == s_voidType) {
  415.                     // Interfaces aren't in schema section
  416.                     // Any xsd type
  417.                     xns.DependsOnSchemaNS(dependsOnNS, false);
  418.                 }
  419.                 else
  420.                     xns.DependsOnSchemaNS(dependsOnNS, true);
  421.                
  422.                
  423.                
  424.                 // Enqueue the type if does not belong to system namespace
  425.                 if (!type.FullName.StartsWith("System.")) {
  426.                     Util.Log("WsdlGenerator.EnqueueType place on queue " + type + " ns " + xns.Namespace);
  427.                     _queue.Enqueue(type);
  428.                 }
  429.             }
  430.         }
  431.        
  432.         private static bool GetNSAndAssembly(Type type, out string ns, out Assembly assem)
  433.         {
  434.             Util.Log("WsdlGenerator.GetNSAndAssembly enter " + type);
  435.            
  436.             string xmlNamespace = null;
  437.             string xmlElement = null;
  438.             bool bInterop = false;
  439.             SoapServices.GetXmlElementForInteropType(type, out xmlElement, out xmlNamespace);
  440.             if (xmlNamespace != null) {
  441.                 ns = xmlNamespace;
  442.                 assem = type.Module.Assembly;
  443.                 bInterop = true;
  444.             }
  445.             else {
  446.                 // Return the namespace and assembly in which the type is defined
  447.                 ns = type.Namespace;
  448.                 assem = type.Module.Assembly;
  449.                 bInterop = false;
  450.             }
  451.            
  452.             Util.Log("WsdlGenerator.GetNSAndAssembly exit ns " + ns + " assem " + assem + " bInterop " + bInterop);
  453.             return bInterop;
  454.         }
  455.        
  456.         private XMLNamespace LookupNamespace(string name, Assembly assem)
  457.         {
  458.             Util.Log("WsdlGenerator.LookupNamespace " + name);
  459.             for (int i = 0; i < _namespaces.Count; i++) {
  460.                 XMLNamespace xns = (XMLNamespace)_namespaces[i];
  461.                 if (name == xns.Name)
  462.                     return (xns);
  463.             }
  464.            
  465.             return (null);
  466.         }
  467.        
  468.         private XMLNamespace AddNamespace(string name, Assembly assem)
  469.         {
  470.             return AddNamespace(name, assem, false);
  471.         }
  472.        
  473.         private XMLNamespace AddNamespace(string name, Assembly assem, bool bInteropType)
  474.         {
  475.             Util.Log("WsdlGenerator.AddNamespace " + name);
  476.             Debug.Assert(LookupNamespace(name, assem) == null, "Duplicate Type found");
  477.            
  478.             XMLNamespace xns = new XMLNamespace(name, assem, _serviceEndpoint, _typeToServiceEndpoint, "ns" + _namespaces.Count, bInteropType, this);
  479.             _namespaces.Add(xns);
  480.            
  481.             return (xns);
  482.         }
  483.        
  484.         private XMLNamespace GetNamespace(Type type)
  485.         {
  486.             Util.Log("WsdlGenerator.GetNamespace " + type);
  487.             string ns = null;
  488.             Assembly assem = null;
  489.             bool bInteropType = GetNSAndAssembly(type, out ns, out assem);
  490.            
  491.             XMLNamespace xns = LookupNamespace(ns, assem);
  492.             if (xns == null) {
  493.                 xns = AddNamespace(ns, assem, bInteropType);
  494.             }
  495.             return xns;
  496.         }
  497.        
  498.        
  499.         private void Resolve()
  500.         {
  501.             Util.Log("WsdlGenerator.Resolve ");
  502.             for (int i = 0; i < _namespaces.Count; i++)
  503.                 ((XMLNamespace)_namespaces[i]).Resolve();
  504.            
  505.             return;
  506.         }
  507.        
  508.         private void PrintWsdl()
  509.         {
  510.             if (_targetNS == null || _targetNS.Length == 0) {
  511.                 // No marshalbyRef object so use another target
  512.                 // Find a namespace
  513.                 if (_namespaces.Count > 0)
  514.                     _targetNS = ((XMLNamespace)_namespaces[0]).Namespace;
  515.                 else
  516.                     _targetNS = "http://schemas.xmlsoap.org/wsdl/";
  517.             }
  518.            
  519.             string indent = "";
  520.             string indent1 = IndentP(indent);
  521.             string indent2 = IndentP(indent1);
  522.             string indent3 = IndentP(indent2);
  523.             string indent4 = IndentP(indent3);
  524.            
  525.             StringBuilder sb = new StringBuilder(256);
  526.             Util.Log("WsdlGenerator.PrintWsdl");
  527.             _textWriter.WriteLine("<?xml version='1.0' encoding='UTF-8'?>");
  528.             sb.Length = 0;
  529.             sb.Append("<definitions ");
  530.             if (_name != null) {
  531.                 sb.Append("name='");
  532.                 sb.Append(_name);
  533.                 sb.Append("' ");
  534.             }
  535.             sb.Append("targetNamespace='");
  536.             sb.Append(_targetNS);
  537.             sb.Append("'");
  538.             _textWriter.WriteLine(sb);
  539.            
  540.             PrintWsdlNamespaces(_textWriter, sb, indent3);
  541.             // See if there are any schema information to print.
  542.            
  543.             bool bPrintTypeSection = false;
  544.             for (int i = 0; i < _namespaces.Count; i++) {
  545.                 if (((XMLNamespace)_namespaces[i]).CheckForSchemaContent()) {
  546.                     bPrintTypeSection = true;
  547.                     break;
  548.                 }
  549.             }
  550.            
  551.            
  552.             if (bPrintTypeSection) {
  553.                 PrintTypesBeginWsdl(_textWriter, sb, indent1);
  554.                
  555.                 for (int i = 0; i < _namespaces.Count; i++) {
  556.                     if (((XMLNamespace)_namespaces[i]).CheckForSchemaContent()) {
  557.                         Util.Log("WsdlGenerator.PrintWsdl call PrintWsdlNamespaces " + ((XMLNamespace)_namespaces[i]).Namespace);
  558.                         ((XMLNamespace)_namespaces[i]).PrintSchemaWsdl(_textWriter, sb, indent2);
  559.                     }
  560.                 }
  561.                
  562.                 PrintTypesEndWsdl(_textWriter, sb, indent1);
  563.             }
  564.            
  565.             ArrayList refNames = new ArrayList(25);
  566.            
  567.             for (int i = 0; i < _namespaces.Count; i++)
  568.                 ((XMLNamespace)_namespaces[i]).PrintMessageWsdl(_textWriter, sb, indent1, refNames);
  569.            
  570.             PrintServiceWsdl(_textWriter, sb, indent1, refNames);
  571.            
  572.             _textWriter.WriteLine("</definitions>");
  573.            
  574.             return;
  575.         }
  576.        
  577.        
  578.         private void PrintWsdlNamespaces(TextWriter textWriter, StringBuilder sb, string indent)
  579.         {
  580.             Util.Log("WsdlGenerator.PrintWsdlNamespaces");
  581.             sb.Length = 0;
  582.             sb.Append(indent);
  583.             sb.Append("xmlns='http://schemas.xmlsoap.org/wsdl/'");
  584.             textWriter.WriteLine(sb);
  585.            
  586.             sb.Length = 0;
  587.             sb.Append(indent);
  588.             sb.Append("xmlns:tns='");
  589.             sb.Append(_targetNS);
  590.             sb.Append("'");
  591.             textWriter.WriteLine(sb);
  592.            
  593.             sb.Length = 0;
  594.             sb.Append(indent);
  595.             sb.Append("xmlns:xsd='");
  596.             sb.Append(SudsConverter.GetXsdVersion(_xsdVersion));
  597.             sb.Append("'");
  598.             textWriter.WriteLine(sb);
  599.            
  600.             sb.Length = 0;
  601.             sb.Append(indent);
  602.             sb.Append("xmlns:xsi='");
  603.             sb.Append(SudsConverter.GetXsiVersion(_xsdVersion));
  604.             sb.Append("'");
  605.             textWriter.WriteLine(sb);
  606.            
  607.             sb.Length = 0;
  608.             sb.Append(indent);
  609.             sb.Append("xmlns:suds='http://www.w3.org/2000/wsdl/suds'");
  610.             textWriter.WriteLine(sb);
  611.            
  612.             sb.Length = 0;
  613.             sb.Append(indent);
  614.             sb.Append("xmlns:wsdl='http://schemas.xmlsoap.org/wsdl/'");
  615.             textWriter.WriteLine(sb);
  616.            
  617.             sb.Length = 0;
  618.             sb.Append(indent);
  619.             sb.Append("xmlns:soapenc='http://schemas.xmlsoap.org/soap/encoding/'");
  620.             textWriter.WriteLine(sb);
  621.            
  622.            
  623.             Hashtable usedNames = new Hashtable(10);
  624.             for (int i = 0; i < _namespaces.Count; i++)
  625.                 ((XMLNamespace)_namespaces[i]).PrintDependsOnWsdl(_textWriter, sb, indent, usedNames);
  626.            
  627.             // This should be last because it closes off the definitions element
  628.             sb.Length = 0;
  629.             sb.Append(indent);
  630.             sb.Append("xmlns:soap='http://schemas.xmlsoap.org/wsdl/soap/'>");
  631.             textWriter.WriteLine(sb);
  632.            
  633.            
  634.         }
  635.        
  636.         private void PrintTypesBeginWsdl(TextWriter textWriter, StringBuilder sb, string indent)
  637.         {
  638.             Util.Log("WsdlGenerator.PrintTypesBeginWsdl");
  639.             sb.Length = 0;
  640.             sb.Append(indent);
  641.             sb.Append("<types>");
  642.             textWriter.WriteLine(sb);
  643.         }
  644.        
  645.         private void PrintTypesEndWsdl(TextWriter textWriter, StringBuilder sb, string indent)
  646.         {
  647.             Util.Log("WsdlGenerator.PrintTypesEndWsdl");
  648.             sb.Length = 0;
  649.             sb.Append(indent);
  650.             sb.Append("</types>");
  651.             textWriter.WriteLine(sb);
  652.         }
  653.        
  654.         internal void PrintServiceWsdl(TextWriter textWriter, StringBuilder sb, string indent, ArrayList refNames)
  655.         {
  656.             Util.Log("WsdlGenerator.PrintServiceWsdl");
  657.             string indent1 = IndentP(indent);
  658.             string indent2 = IndentP(indent1);
  659.             string indent3 = IndentP(indent2);
  660.             sb.Length = 0;
  661.             sb.Append("\n");
  662.             sb.Append(indent);
  663.             sb.Append("<service name='");
  664.             sb.Append(_name);
  665.             sb.Append("Service'");
  666.             sb.Append(">");
  667.             textWriter.WriteLine(sb);
  668.            
  669.             for (int i = 0; i < refNames.Count; i++) {
  670.                 if (((_typeToServiceEndpoint != null) && (_typeToServiceEndpoint.ContainsKey(refNames[i]))) || (_serviceEndpoint != null)) {
  671.                    
  672.                     sb.Length = 0;
  673.                     sb.Append(indent1);
  674.                     sb.Append("<port name='");
  675.                     sb.Append(refNames[i]);
  676.                     sb.Append("Port'");
  677.                     sb.Append(" ");
  678.                     sb.Append("binding='tns:");
  679.                     sb.Append(refNames[i]);
  680.                     sb.Append("Binding");
  681.                     sb.Append("'>");
  682.                     textWriter.WriteLine(sb);
  683.                    
  684.                     if ((_typeToServiceEndpoint != null) && (_typeToServiceEndpoint.ContainsKey(refNames[i]))) {
  685.                         foreach (string url in (ArrayList)_typeToServiceEndpoint[refNames[i]]) {
  686.                             sb.Length = 0;
  687.                             sb.Append(indent2);
  688.                             sb.Append("<soap:address location='");
  689.                             sb.Append(UrlEncode(url));
  690.                             sb.Append("'/>");
  691.                             textWriter.WriteLine(sb);
  692.                         }
  693.                        
  694.                     }
  695.                     else if (_serviceEndpoint != null) {
  696.                         sb.Length = 0;
  697.                         sb.Append(indent2);
  698.                         sb.Append("<soap:address location='");
  699.                         sb.Append(_serviceEndpoint);
  700.                         sb.Append("'/>");
  701.                         textWriter.WriteLine(sb);
  702.                     }
  703.                    
  704.                     sb.Length = 0;
  705.                     sb.Append(indent1);
  706.                     sb.Append("</port>");
  707.                     textWriter.WriteLine(sb);
  708.                 }
  709.             }
  710.             sb.Length = 0;
  711.             sb.Append(indent);
  712.             sb.Append("</service>");
  713.             textWriter.WriteLine(sb);
  714.         }
  715.        
  716.         private string UrlEncode(string url)
  717.         {
  718.             if (url == null || url.Length == 0)
  719.                 return url;
  720.            
  721.             int index = url.IndexOf("&amp;");
  722.             if (index > -1) {
  723.                 // Assume it's encoded
  724.                 return url;
  725.             }
  726.            
  727.             index = url.IndexOf('&');
  728.             if (index > -1) {
  729.                 return url.Replace("&", "&amp;");
  730.             }
  731.            
  732.             return url;
  733.         }
  734.        
  735.        
  736.         // Private fields
  737.         private TextWriter _textWriter;
  738.         internal Queue _queue;
  739.         private string _name;
  740.         private string _targetNS;
  741.         private string _targetNSPrefix;
  742.         private ArrayList _namespaces;
  743.         private Assembly _dynamicAssembly;
  744.         private string _serviceEndpoint;
  745.         //service endpoint for all types
  746.         private XsdVersion _xsdVersion;
  747.         // Temporary, specifies what xsd and xsi schema to put out
  748.         internal Hashtable _typeToServiceEndpoint;
  749.         //service endpoint for each type
  750.         internal Hashtable _typeToInteropNS = new Hashtable();
  751.         // If interop type, then XMLNamespace the type is in.
  752.         private static Type s_marshalByRefType = typeof(System.MarshalByRefObject);
  753.         private static Type s_contextBoundType = typeof(System.ContextBoundObject);
  754.         private static Type s_delegateType = typeof(System.Delegate);
  755.         private static Type s_valueType = typeof(System.ValueType);
  756.         private static Type s_objectType = typeof(object);
  757.         private static Type s_charType = typeof(char);
  758.         private static Type s_voidType = typeof(void);
  759.        
  760.         private static Type s_remotingClientProxyType = typeof(System.Runtime.Remoting.Services.RemotingClientProxy);
  761.         private static SchemaBlockType blockDefault = SchemaBlockType.SEQUENCE;
  762.        
  763. /***************************************************************
  764.         **
  765.         ** Private classes used by SUDS generator
  766.         **
  767.         ***************************************************************/       
  768.         private interface IAbstractElement
  769.         {
  770.             void Print(TextWriter textWriter, StringBuilder sb, string indent);
  771.         }
  772.        
  773.         private class EnumElement : IAbstractElement
  774.         {
  775.             internal EnumElement(string value)
  776.             {
  777.                 Util.Log("EnumElement.EnumElement " + value);
  778.                 _value = value;
  779.             }
  780.            
  781.             public void Print(TextWriter textWriter, StringBuilder sb, string indent)
  782.             {
  783.                 Util.Log("EnumElement.Print");
  784.                 sb.Length = 0;
  785.                 sb.Append(indent);
  786.                 sb.Append("<enumeration value='");
  787.                 sb.Append(_value);
  788.                 sb.Append("'/>");
  789.                 textWriter.WriteLine(sb);
  790.                 return;
  791.             }
  792.            
  793.             // Fields
  794.             private string _value;
  795.         }
  796.        
  797. /*
  798.         private class ComplexContent : IAbstractElement
  799.         {
  800.             internal ComplexContent()
  801.             {
  802.             }
  803.             internal void Add(Restriction restriction)
  804.             {
  805.                 _restriction = restriction;
  806.             }
  807.             public void Print(TextWriter textWriter, StringBuilder sb, String indent)
  808.             {
  809.                 Util.Log("EnumElement.Print");
  810.                 sb.Length = 0;
  811.                 sb.Append(indent);
  812.                 sb.Append("<enumeration value='");
  813.                 sb.Append(_value);
  814.                 sb.Append("'/>");
  815.                 textWriter.WriteLine(sb);
  816.                 return;
  817.             }
  818.             Restriction _restriction;
  819.         }
  820.         */       
  821.        
  822.        
  823.         private class Restriction : Particle
  824.         {
  825.             internal enum RestrictionType
  826.             {
  827.                 None = 0,
  828.                 Array = 1,
  829.                 Enum = 2
  830.             }
  831.            
  832.             internal Restriction()
  833.             {
  834.                 Util.Log("Restriction.Restriction ");
  835.             }
  836.            
  837.             internal Restriction(string baseName, XMLNamespace baseNS)
  838.             {
  839.                 Util.Log("Restriction.Restriction " + baseName + " " + baseNS.Namespace);
  840.                 _baseName = baseName;
  841.                 _baseNS = baseNS;
  842.             }
  843.            
  844.             internal void AddArray(SchemaAttribute attribute)
  845.             {
  846.                 Util.Log("Restriction.AddArray ");
  847.                 _rtype = RestrictionType.Array;
  848.                 _attribute = attribute;
  849.             }
  850.            
  851.             public override string Name()
  852.             {
  853.                 return _baseName;
  854.             }
  855.            
  856.             public override void Print(TextWriter textWriter, StringBuilder sb, string indent)
  857.             {
  858.                 Util.Log("Restriction.Print " + _baseName);
  859.                 string indent1 = IndentP(indent);
  860.                 sb.Length = 0;
  861.                 sb.Append(indent);
  862.                 if (_rtype == RestrictionType.Array)
  863.                     sb.Append("<restriction base='soapenc:Array'>");
  864.                 else if (_rtype == RestrictionType.Enum) {
  865.                     sb.Append("<restriction base='xsd:string'>");
  866.                 }
  867.                 else {
  868.                     sb.Append("<restriction base='");
  869.                     sb.Append(_baseNS.Prefix);
  870.                     sb.Append(':');
  871.                     sb.Append(_baseName);
  872.                     sb.Append("'>");
  873.                 }
  874.                 textWriter.WriteLine(sb);
  875.                 foreach (IAbstractElement elem in _abstractElms)
  876.                     elem.Print(textWriter, sb, IndentP(indent1));
  877.                
  878.                 if (_attribute != null)
  879.                     _attribute.Print(textWriter, sb, IndentP(indent1));
  880.                 sb.Length = 0;
  881.                 sb.Append(indent);
  882.                 sb.Append("</restriction>");
  883.                 textWriter.WriteLine(sb);
  884.             }
  885.            
  886.             string _baseName;
  887.             XMLNamespace _baseNS;
  888.             internal RestrictionType _rtype;
  889.             SchemaAttribute _attribute;
  890.             internal ArrayList _abstractElms = new ArrayList();
  891.         }
  892.        
  893.         private class SchemaAttribute : IAbstractElement
  894.         {
  895.             internal SchemaAttribute()
  896.             {
  897.                 Util.Log("SchemaAttribute ");
  898.             }
  899.            
  900.             internal void AddArray(string wireQname)
  901.             {
  902.                 Util.Log("SchemaAttribute wireQname " + wireQname);
  903.                 _wireQname = wireQname;
  904.             }
  905.            
  906.             public void Print(TextWriter textWriter, StringBuilder sb, string indent)
  907.             {
  908.                 sb.Length = 0;
  909.                 sb.Append(indent);
  910.                 sb.Append("<attribute ref='soapenc:arrayType'");
  911.                 sb.Append(" wsdl:arrayType ='");
  912.                 sb.Append(_wireQname);
  913.                 sb.Append("'/>");
  914.                 textWriter.WriteLine(sb);
  915.                 return;
  916.             }
  917.            
  918.             // Fields
  919.             private string _wireQname;
  920.            
  921.         }
  922.        
  923.         private abstract class Particle : IAbstractElement
  924.         {
  925.             protected Particle()
  926.             {
  927.             }
  928.             public abstract string Name();
  929.             public abstract void Print(TextWriter textWriter, StringBuilder sb, string indent);
  930.         }
  931.        
  932.         private class SchemaElement : Particle
  933.         {
  934.             internal SchemaElement(string name, Type type, bool bEmbedded, XMLNamespace xns) : base()
  935.             {
  936.                 Util.Log("SchemaElement.SchemaElement Particle " + name + " type " + type + " bEmbedded " + bEmbedded);
  937.                 _name = name;
  938.                 _typeString = null;
  939.                 _schemaType = SimpleSchemaType.GetSimpleSchemaType(type, xns, true);
  940.                 _typeString = RealSchemaType.TypeName(type, bEmbedded, xns);
  941.             }
  942.            
  943.             public override string Name()
  944.             {
  945.                 return _name;
  946.             }
  947.            
  948.             public override void Print(TextWriter textWriter, StringBuilder sb, string indent)
  949.             {
  950.                 Util.Log("SchemaElement.Print " + _name + " _schemaType " + _schemaType + " _typeString " + _typeString);
  951.                 string indent1 = IndentP(indent);
  952.                 sb.Length = 0;
  953.                 sb.Append(indent);
  954.                 sb.Append("<element name='");
  955.                 sb.Append(_name);
  956.                 if (_schemaType != null && !(_schemaType is SimpleSchemaType && ((SimpleSchemaType)_schemaType).Type.IsEnum)) {
  957.                     sb.Append("'>");
  958.                     textWriter.WriteLine(sb);
  959.                     _schemaType.PrintSchemaType(textWriter, sb, IndentP(indent1), true);
  960.                    
  961.                     sb.Length = 0;
  962.                     sb.Append(indent);
  963.                     sb.Append("</element>");
  964.                 }
  965.                 else {
  966.                     if (_typeString != null) {
  967.                         sb.Append("' type='");
  968.                         sb.Append(_typeString);
  969.                         sb.Append('\'');
  970.                     }
  971.                     sb.Append("/>");
  972.                 }
  973.                 textWriter.WriteLine(sb);
  974.                
  975.                 return;
  976.             }
  977.            
  978.             // Fields
  979.             private string _name;
  980.             private string _typeString;
  981.             private SchemaType _schemaType;
  982.         }
  983.        
  984.         private abstract class SchemaType
  985.         {
  986.             internal abstract void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous);
  987.         }
  988.        
  989.         private class SimpleSchemaType : SchemaType
  990.         {
  991.             private SimpleSchemaType(Type type, XMLNamespace xns)
  992.             {
  993.                 Util.Log("SimpleSchemaType.SimpleSchemaType " + type + " xns " + ((xns != null) ? xns.Name : "Null"));
  994.                 _type = type;
  995.                 _xns = xns;
  996.                 _abstractElms = new ArrayList();
  997.                
  998.                 _fullRefName = WsdlGenerator.RefName(type);
  999.             }
  1000.            
  1001.             internal Type Type {
  1002.                 get { return (_type); }
  1003.             }
  1004.            
  1005.             internal string FullRefName {
  1006.                 get { return _fullRefName; }
  1007.             }
  1008.            
  1009.             internal string BaseName {
  1010.                 get { return (_baseName); }
  1011.             }
  1012.            
  1013.             internal override void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous)
  1014.             {
  1015.                 Util.Log("SimpleSchemaType.PrintSchemaType _type.Name " + _type.Name);
  1016.                 sb.Length = 0;
  1017.                 sb.Append(indent);
  1018.                 if (bAnonymous == false) {
  1019.                     sb.Append("<simpleType name='");
  1020.                     sb.Append(FullRefName);
  1021.                     sb.Append("'");
  1022.                     if (BaseName != null) {
  1023.                         sb.Append(" base='");
  1024.                         sb.Append(BaseName);
  1025.                         sb.Append("'");
  1026.                     }
  1027.                    
  1028.                     if (_restriction._rtype == Restriction.RestrictionType.Enum) {
  1029.                         sb.Append(" suds:enumType='");
  1030.                         sb.Append(_restriction.Name());
  1031.                         sb.Append("'");
  1032.                     }
  1033.                 }
  1034.                 else {
  1035.                     if (BaseName != null) {
  1036.                         sb.Append("<simpleType base='");
  1037.                         sb.Append(BaseName);
  1038.                         sb.Append("'");
  1039.                     }
  1040.                     else
  1041.                         sb.Append("<simpleType");
  1042.                 }
  1043.                
  1044.                 bool bEmpty = (_abstractElms.Count == 0 && _restriction == null);
  1045.                 if (bEmpty)
  1046.                     sb.Append("/>");
  1047.                 else
  1048.                     sb.Append(">");
  1049.                 textWriter.WriteLine(sb);
  1050.                 if (bEmpty)
  1051.                     return;
  1052.                
  1053.                 if (_abstractElms.Count > 0) {
  1054.                     for (int i = 0; i < _abstractElms.Count; i++)
  1055.                         ((IAbstractElement)_abstractElms[i]).Print(textWriter, sb, IndentP(indent));
  1056.                 }
  1057.                
  1058.                 if (_restriction != null)
  1059.                     _restriction.Print(textWriter, sb, IndentP(indent));
  1060.                
  1061.                 textWriter.Write(indent);
  1062.                 textWriter.WriteLine("</simpleType>");
  1063.                
  1064.                 return;
  1065.             }
  1066.            
  1067.            
  1068.             static internal SimpleSchemaType GetSimpleSchemaType(Type type, XMLNamespace xns, bool fInline)
  1069.             {
  1070.                 Util.Log("SimpleSchemaType.GetSimpleSchemaType " + type + " xns " + xns.Name);
  1071.                
  1072.                 SimpleSchemaType ssType = null;
  1073.                 if (type.IsEnum) {
  1074.                     ssType = new SimpleSchemaType(type, xns);
  1075.                     string baseName = RealSchemaType.TypeName(Enum.GetUnderlyingType(type), true, xns);
  1076.                     ssType._restriction = new Restriction(baseName, xns);
  1077.                     string[] values = Enum.GetNames(type);
  1078.                     for (int i = 0; i < values.Length; i++)
  1079.                         ssType._restriction._abstractElms.Add(new EnumElement(values[i]));
  1080.                     ssType._restriction._rtype = Restriction.RestrictionType.Enum;
  1081.                 }
  1082.                 else {
  1083.                 }
  1084.                 return (ssType);
  1085.             }
  1086.            
  1087.            
  1088.             private Type _type;
  1089.             internal string _baseName = null;
  1090.             //get rid of warning, not used for now
  1091.             private XMLNamespace _xns;
  1092.             internal Restriction _restriction;
  1093.             private string _fullRefName;
  1094.             private ArrayList _abstractElms = new ArrayList();
  1095.         }
  1096.        
  1097.        
  1098.         private abstract class ComplexSchemaType : SchemaType
  1099.         {
  1100.             internal ComplexSchemaType(string name, bool bSealed)
  1101.             {
  1102.                 _name = name;
  1103.                 _fullRefName = _name;
  1104.                 _blockType = SchemaBlockType.ALL;
  1105.                 _baseName = null;
  1106.                 _elementName = name;
  1107.                 _bSealed = bSealed;
  1108.                 _particles = new ArrayList();
  1109.                 _abstractElms = new ArrayList();
  1110.             }
  1111.            
  1112.             internal ComplexSchemaType(string name, SchemaBlockType blockType, bool bSealed)
  1113.             {
  1114.                 _name = name;
  1115.                 _fullRefName = _name;
  1116.                 _blockType = blockType;
  1117.                 _baseName = null;
  1118.                 _elementName = name;
  1119.                 _bSealed = bSealed;
  1120.                 _particles = new ArrayList();
  1121.                 _abstractElms = new ArrayList();
  1122.             }
  1123.            
  1124.             internal ComplexSchemaType(Type type)
  1125.             {
  1126.                 Util.Log("ComplexSchemaType.ComplexSchemaType " + type);
  1127.                 _blockType = SchemaBlockType.ALL;
  1128.                 _type = type;
  1129.                 Init();
  1130.             }
  1131.            
  1132.             private void Init()
  1133.             {
  1134.                 _name = _type.Name;
  1135.                 _bSealed = _type.IsSealed;
  1136.                 _baseName = null;
  1137.                 _elementName = _name;
  1138.                 _particles = new ArrayList();
  1139.                 _abstractElms = new ArrayList();
  1140.                 _fullRefName = WsdlGenerator.RefName(_type);
  1141.             }
  1142.            
  1143.             internal string Name {
  1144.                 get { return (_name); }
  1145.             }
  1146.            
  1147.             internal string FullRefName {
  1148.                 get { return (_fullRefName); }
  1149.             }
  1150.            
  1151.             protected string BaseName {
  1152.                 get { return (_baseName); }
  1153.                 set { _baseName = value; }
  1154.             }
  1155.            
  1156.             internal string ElementName {
  1157.                 get { return (_elementName); }
  1158.                 set { _elementName = value; }
  1159.             }
  1160.            
  1161.            
  1162.             protected bool IsSealed {
  1163.                 get { return (_bSealed); }
  1164.             }
  1165.            
  1166.             protected bool IsEmpty {
  1167.                 get { return ((_abstractElms.Count == 0) && (_particles.Count == 0)); }
  1168.             }
  1169.            
  1170.             internal void AddParticle(Particle particle)
  1171.             {
  1172.                 Util.Log("ComplexSchemaType.AddParticle " + particle.Name());
  1173.                 _particles.Add(particle);
  1174.             }
  1175.            
  1176.             protected void PrintBody(TextWriter textWriter, StringBuilder sb, string indent)
  1177.             {
  1178.                 Util.Log("ComplexSchemaType.PrintBody " + _name);
  1179.                 int particleCount = _particles.Count;
  1180.                 string indent1 = IndentP(indent);
  1181.                 string indent2 = IndentP(indent1);
  1182.                 if (particleCount > 0) {
  1183.                         /*(particleCount > 1) && */                    bool bPrintBlockElms = (WsdlGenerator.blockDefault != _blockType);
  1184.                     if (bPrintBlockElms) {
  1185.                         sb.Length = 0;
  1186.                         sb.Append(indent1);
  1187.                         sb.Append(schemaBlockBegin[(int)_blockType]);
  1188.                         textWriter.WriteLine(sb);
  1189.                     }
  1190.                    
  1191.                     for (int i = 0; i < particleCount; i++)
  1192.                         ((Particle)_particles[i]).Print(textWriter, sb, IndentP(indent2));
  1193.                    
  1194.                     if (bPrintBlockElms) {
  1195.                         sb.Length = 0;
  1196.                         sb.Append(indent1);
  1197.                         sb.Append(schemaBlockEnd[(int)_blockType]);
  1198.                         textWriter.WriteLine(sb);
  1199.                     }
  1200.                 }
  1201.                
  1202.                 int abstractElmCount = _abstractElms.Count;
  1203.                 for (int i = 0; i < abstractElmCount; i++)
  1204.                     ((IAbstractElement)_abstractElms[i]).Print(textWriter, sb, IndentP(indent));
  1205.                
  1206.                 return;
  1207.             }
  1208.            
  1209.             private string _name;
  1210.             private Type _type;
  1211.             private string _fullRefName;
  1212.             private string _baseName;
  1213.             private string _elementName;
  1214.             private bool _bSealed;
  1215.             private SchemaBlockType _blockType;
  1216.             private ArrayList _particles;
  1217.             private ArrayList _abstractElms;
  1218.            
  1219.             private static string[] schemaBlockBegin = {"<all>", "<sequence>", "<choice>", "<complexContent>"};
  1220.             private static string[] schemaBlockEnd = {"</all>", "</sequence>", "</choice>", "</complexContent>"};
  1221.         }
  1222.        
  1223.         private class PhonySchemaType : ComplexSchemaType
  1224.         {
  1225.             internal PhonySchemaType(string name) : base(name, true)
  1226.             {
  1227.                 Util.Log("PhonySchemaType.PhonySchemaType " + name);
  1228.                 _numOverloadedTypes = 0;
  1229.             }
  1230.            
  1231.             internal int OverloadedType()
  1232.             {
  1233.                 Util.Log("PhonySchemaType.OverLoadedTypeType");
  1234.                 return (++_numOverloadedTypes);
  1235.             }
  1236.            
  1237.             internal override void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous)
  1238.             {
  1239.                 Util.Log("PhonySchemaType.PrintSchemaType");
  1240.                 Debug.Assert(bAnonymous == true, "PhonySchemaType should always be printed as anonymous types");
  1241.                
  1242.                 // Wsdl Phony is not printed, instead the message section contains the parameters.
  1243.                 return;
  1244.             }
  1245.             private int _numOverloadedTypes;
  1246.             internal ArrayList _inParamTypes;
  1247.             internal ArrayList _inParamNames;
  1248.             internal ArrayList _outParamTypes;
  1249.             internal ArrayList _outParamNames;
  1250.             internal ArrayList _paramNamesOrder;
  1251.             internal string _returnType;
  1252.             internal string _returnName;
  1253.         }
  1254.        
  1255.         private class ArraySchemaType : ComplexSchemaType
  1256.         {
  1257.             internal ArraySchemaType(Type type, string name, SchemaBlockType blockType, bool bSealed) : base(name, blockType, bSealed)
  1258.             {
  1259.                 Util.Log("ArraySchemaType.ArrayComplexSchemaType");
  1260.                 _type = type;
  1261.             }
  1262.            
  1263.             internal Type Type {
  1264.                 get { return _type; }
  1265.             }
  1266.            
  1267.            
  1268.             internal override void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous)
  1269.             {
  1270.                 Util.Log("ArrayType.PrintSchemaType");
  1271.                 string indent1 = IndentP(indent);
  1272.                 sb.Length = 0;
  1273.                 sb.Append(indent);
  1274.                 sb.Append("<complexType name='");
  1275.                 sb.Append(FullRefName);
  1276.                 sb.Append("'>");
  1277.                 textWriter.WriteLine(sb);
  1278.                 PrintBody(textWriter, sb, indent1);
  1279.                 sb.Length = 0;
  1280.                 sb.Append(indent);
  1281.                 sb.Append("</complexType>");
  1282.                 textWriter.WriteLine(sb);
  1283.                
  1284.                 return;
  1285.             }
  1286.            
  1287.             private Type _type;
  1288.         }
  1289.        
  1290.         private class RealSchemaType : ComplexSchemaType
  1291.         {
  1292.             internal RealSchemaType(Type type, XMLNamespace xns, string serviceEndpoint, Hashtable typeToServiceEndpoint, bool bUnique, WsdlGenerator WsdlGenerator) : base(type)
  1293.             {
  1294.                 Util.Log("RealSchemaType.RealSchemaType " + type + " xns " + xns.Name + " serviceEndpoint " + serviceEndpoint + " bUnique " + bUnique);
  1295.                 _type = type;
  1296.                 _serviceEndpoint = serviceEndpoint;
  1297.                 _typeToServiceEndpoint = typeToServiceEndpoint;
  1298.                 _bUnique = bUnique;
  1299.                 _WsdlGenerator = WsdlGenerator;
  1300.                 _bStruct = type.IsValueType;
  1301.                 _xns = xns;
  1302.                 _implIFaces = null;
  1303.                 _iFaces = null;
  1304.                 _methods = null;
  1305.                 _fields = null;
  1306.                 _methodTypes = null;
  1307.                
  1308.                 _nestedTypes = type.GetNestedTypes();
  1309.                 if (_nestedTypes != null) {
  1310.                     foreach (Type ntype in _nestedTypes) {
  1311.                         Util.Log("RealSchemaType.RealSchemaType nested classes" + ntype);
  1312.                         _WsdlGenerator.AddType(ntype, xns);
  1313.                     }
  1314.                 }
  1315.             }
  1316.            
  1317.             internal Type Type {
  1318.                 get { return (_type); }
  1319.             }
  1320.            
  1321.             internal XMLNamespace XNS {
  1322.                 get { return (_xns); }
  1323.             }
  1324.            
  1325.             internal bool IsUnique {
  1326.                 get { return (_bUnique); }
  1327.             }
  1328.            
  1329.             internal bool IsSUDSType {
  1330. /*
  1331.                 get{ return((_fields == null) &&
  1332.                             ((_iFaces.Length > 0) || (_methods.Length > 0) ||
  1333.                             (_type.IsInterface) || (s_delegateType.IsAssignableFrom(_type))));}
  1334.                             */               
  1335.                 get { return ((_iFaces != null && _iFaces.Length > 0) || (_methods != null && _methods.Length > 0) || (_type != null && _type.IsInterface) || (s_delegateType != null && s_delegateType.IsAssignableFrom(_type))); }
  1336.             }
  1337.            
  1338.             internal Type[] GetIntroducedInterfaces()
  1339.             {
  1340.                 Util.Log("RealSchemaType.GetIntroducedInterfaces");
  1341.                 Debug.Assert(_iFaces == null, "variable set");
  1342.                 _iFaces = GetIntroducedInterfaces(_type);
  1343.                 return (_iFaces);
  1344.             }
  1345.            
  1346.             internal MethodInfo[] GetIntroducedMethods()
  1347.             {
  1348.                 Util.Log("RealSchemaType.GetIntroducedMethods");
  1349.                 Debug.Assert(_methods == null, "variable set");
  1350.                 _methods = GetIntroducedMethods(_type, ref _methodAttributes);
  1351.                 _methodTypes = new string[2 * _methods.Length];
  1352.                 return (_methods);
  1353.             }
  1354.            
  1355.             internal FieldInfo[] GetInstanceFields()
  1356.             {
  1357.                 Util.Log("RealSchemaType.GetInstanceFields");
  1358.                 Debug.Assert(_fields == null, "variable set");
  1359.                 //Debug.Assert(!WsdlGenerator.s_marshalByRefType.IsAssignableFrom(_type), "Invalid Type");
  1360.                 _fields = GetInstanceFields(_type);
  1361.                 return (_fields);
  1362.             }
  1363.            
  1364.             private bool IsNotSystemDefinedRoot(Type type, Type baseType)
  1365.             {
  1366.                 if (!type.IsInterface && !type.IsValueType && baseType != null && baseType.BaseType != null && baseType != WsdlGenerator.s_marshalByRefType && baseType != WsdlGenerator.s_valueType && baseType != WsdlGenerator.s_objectType && baseType != WsdlGenerator.s_contextBoundType && baseType != WsdlGenerator.s_remotingClientProxyType && baseType.FullName != "System.EnterpriseServices.ServicedComponent" && baseType.FullName != "System.__ComObject")
  1367.                     return true;
  1368.                 else
  1369.                     return false;
  1370.             }
  1371.            
  1372.             internal void Resolve(StringBuilder sb)
  1373.             {
  1374.                 Util.Log("RealSchemaType.Resolve " + _type);
  1375.                 sb.Length = 0;
  1376.                
  1377.                 // Check if this is a suds type
  1378.                 bool bSUDSType = IsSUDSType;
  1379.                
  1380.                
  1381.                 // Resolve base type eliminating system defined roots of the class heirarchy
  1382.                
  1383.                 Type baseType = _type.BaseType;
  1384.                 if (IsNotSystemDefinedRoot(_type, baseType)) {
  1385.                     Util.Log("RealSchemaType.Resolve Not System Defined root " + baseType);
  1386.                     XMLNamespace xns = _WsdlGenerator.GetNamespace(baseType);
  1387.                     Debug.Assert(xns != null, "Namespace should have been found");
  1388.                     sb.Append(xns.Prefix);
  1389.                     sb.Append(':');
  1390.                     sb.Append(baseType.Name);
  1391.                     BaseName = sb.ToString();
  1392.                     if (bSUDSType)
  1393.                         _xns.DependsOnSUDSNS(xns);
  1394.                     Type ltype = _type;
  1395.                     Type lbaseType = ltype.BaseType;
  1396.                     while (lbaseType != null && IsNotSystemDefinedRoot(ltype, lbaseType)) {
  1397.                         if (_typeToServiceEndpoint != null && !_typeToServiceEndpoint.ContainsKey(lbaseType.Name) && _typeToServiceEndpoint.ContainsKey(ltype.Name)) {
  1398.                             // type contains endpoints, but baseType doesn't, so assign the type's endpoints to the baseType.
  1399.                             // This is needed when a child has endpoints but the parent doesn't. A cast to the parent won't
  1400.                             // find the object's endpoint
  1401.                             _typeToServiceEndpoint[lbaseType.Name] = _typeToServiceEndpoint[ltype.Name];
  1402.                         }
  1403.                         ltype = lbaseType;
  1404.                         lbaseType = ltype.BaseType;
  1405.                     }
  1406.                    
  1407.                     Util.Log("RealSchemaType.Resolve Not System Defined root BaseName " + BaseName);
  1408.                 }
  1409.                
  1410.                 // The element definition of this type depends on itself
  1411.                 _xns.DependsOnSchemaNS(_xns, false);
  1412.                
  1413.                 if (bSUDSType) {
  1414.                     Util.Log("RealSchemaType.Resolve AddRealSUDSType " + _type);
  1415.                     _xns.AddRealSUDSType(this);
  1416.                    
  1417.                     // Resolve interfaces introduced by this type
  1418.                     if (_iFaces.Length > 0) {
  1419.                         _implIFaces = new string[_iFaces.Length];
  1420.                         for (int i = 0; i < _iFaces.Length; i++) {
  1421.                             string ns;
  1422.                             Assembly assem;
  1423.                             Util.Log("RealSchemaType.Resolve iFace " + _iFaces[i].Name);
  1424.                             bool bInteropType = WsdlGenerator.GetNSAndAssembly(_iFaces[i], out ns, out assem);
  1425.                             XMLNamespace xns = _xns.LookupSchemaNamespace(ns, assem);
  1426.                             Debug.Assert(xns != null, "SchemaType should have been found");
  1427.                             sb.Length = 0;
  1428.                             sb.Append(xns.Prefix);
  1429.                             sb.Append(':');
  1430.                             sb.Append(_iFaces[i].Name);
  1431.                             _implIFaces[i] = sb.ToString();
  1432.                             _xns.DependsOnSUDSNS(xns);
  1433.                         }
  1434.                     }
  1435.                    
  1436.                     // Resolve methods introduced by this type
  1437.                     if (_methods.Length > 0) {
  1438.                         string useNS = null;
  1439.                         if (_xns.IsInteropType)
  1440.                             useNS = _xns.Name;
  1441.                         else {
  1442.                             sb.Length = 0;
  1443.                             WsdlGenerator.QualifyName(sb, _xns.Name, Name);
  1444.                             useNS = sb.ToString();
  1445.                         }
  1446.                         XMLNamespace methodXNS = _xns.LookupSchemaNamespace(useNS, _xns.Assem);
  1447.                         Debug.Assert(methodXNS != null, "Namespace is null");
  1448.                         _xns.DependsOnSUDSNS(methodXNS);
  1449.                         _phony = new PhonySchemaType[_methods.Length];
  1450.                         for (int i = 0; i < _methods.Length; i++) {
  1451.                             // Process the request
  1452.                             MethodInfo method = _methods[i];
  1453.                             string methodRequestName = method.Name;
  1454.                            
  1455.                             ParameterInfo[] parameters = method.GetParameters();
  1456.                             PhonySchemaType methodRequest = new PhonySchemaType(methodRequestName);
  1457.                            
  1458.                             // Wsdl
  1459.                             Util.Log("RealSchemaType.Resolve Wsdl " + methodRequestName);
  1460.                             methodRequest._inParamTypes = new ArrayList(10);
  1461.                             methodRequest._inParamNames = new ArrayList(10);
  1462.                             methodRequest._outParamTypes = new ArrayList(10);
  1463.                             methodRequest._outParamNames = new ArrayList(10);
  1464.                             methodRequest._paramNamesOrder = new ArrayList(10);
  1465.                            
  1466.                             int paramNameCnt = 0;
  1467.                             foreach (ParameterInfo param in parameters) {
  1468.                                 bool bmarshalIn = false;
  1469.                                 bool bmarshalOut = false;
  1470.                                 methodRequest._paramNamesOrder.Add(param.Name);
  1471.                                 ParamInOut(param, out bmarshalIn, out bmarshalOut);
  1472.                                
  1473.                                 Type type = param.ParameterType;
  1474.                                 string paramName = param.Name;
  1475.                                 if (paramName == null || paramName.Length == 0)
  1476.                                     paramName = "param" + paramNameCnt++;
  1477.                                
  1478.                                 // Find the Wsdl type name
  1479.                                
  1480.                                 string stringType = TypeName(type, true, methodXNS);
  1481.                                 // add to the method parameters
  1482.                                 if (bmarshalIn) {
  1483.                                     methodRequest._inParamNames.Add(paramName);
  1484.                                     methodRequest._inParamTypes.Add(stringType);
  1485.                                 }
  1486.                                
  1487.                                 if (bmarshalOut) {
  1488.                                     methodRequest._outParamNames.Add(paramName);
  1489.                                     methodRequest._outParamTypes.Add(stringType);
  1490.                                 }
  1491.                             }
  1492.                            
  1493.                            
  1494.                             methodXNS.AddPhonySchemaType(methodRequest);
  1495.                             _phony[i] = methodRequest;
  1496.                             _methodTypes[2 * i] = methodRequest.ElementName;
  1497.                            
  1498.                             if (!RemotingServices.IsOneWay(method)) {
  1499.                                 // Process response (look at custom attributes to get values
  1500.                                
  1501.                                 string returnName = null;
  1502.                                 SoapMethodAttribute soapAttribute = (SoapMethodAttribute)InternalRemotingServices.GetCachedSoapAttribute(method);
  1503.                                 if (soapAttribute.ReturnXmlElementName != null)
  1504.                                     returnName = soapAttribute.ReturnXmlElementName;
  1505.                                 else
  1506.                                     returnName = "return";
  1507.                                
  1508.                                 string responseName = null;
  1509.                                 if (soapAttribute.ResponseXmlElementName != null)
  1510.                                     responseName = soapAttribute.ResponseXmlElementName;
  1511.                                 else
  1512.                                     responseName = methodRequestName + "Response";
  1513.                                
  1514.                                 PhonySchemaType methodResponse = new PhonySchemaType(responseName);
  1515.                                
  1516.                                 //Wsdl type
  1517.                                 // out paramters alread processed above.
  1518.                                 // return name stored in methodRequest PhonySchemaType
  1519.                                 methodRequest._returnName = returnName;
  1520.                                 Type returnType = method.ReturnType;
  1521.                                
  1522.                                 if (!((returnType == null) || (returnType == typeof(void)))) {
  1523.                                     methodRequest._returnType = TypeName(returnType, true, methodXNS);
  1524.                                 }
  1525.                                 methodXNS.AddPhonySchemaType(methodResponse);
  1526.                                 _methodTypes[2 * i + 1] = methodResponse.ElementName;
  1527.                             }
  1528.                         }
  1529.                     }
  1530.                 }
  1531.                
  1532.                 // Resolve fields
  1533.                 if (_fields != null) {
  1534.                     for (int i = 0; i < _fields.Length; i++) {
  1535.                         FieldInfo field = _fields[i];
  1536.                         Debug.Assert(!field.IsStatic, "Static field");
  1537.                         Type fieldType = field.FieldType;
  1538.                         if (fieldType == null)
  1539.                             fieldType = typeof(object);
  1540.                         Util.Log("RealSchemaType.Resolve fields " + field.Name + " type " + fieldType);
  1541.                         AddParticle(new SchemaElement(field.Name, fieldType, false, _xns));
  1542.                     }
  1543.                 }
  1544.                
  1545.                 // Resolve attribute elements
  1546.                 return;
  1547.             }
  1548.            
  1549.             private void ParamInOut(ParameterInfo param, out bool bMarshalIn, out bool bMarshalOut)
  1550.             {
  1551.                 bool bIsIn = param.IsIn;
  1552.                 // [In]
  1553.                 bool bIsOut = param.IsOut;
  1554.                 // [Out] note: out int a === [Out] ref int b
  1555.                 bool bIsByRef = param.ParameterType.IsByRef;
  1556.                 // (ref or normal)
  1557.                 bMarshalIn = false;
  1558.                 bMarshalOut = false;
  1559.                 if (bIsByRef) {
  1560.                     if (bIsIn == bIsOut) {
  1561.                         // "ref int a" or "[In, Out] ref int a"
  1562.                         bMarshalIn = true;
  1563.                         bMarshalOut = true;
  1564.                     }
  1565.                     else {
  1566.                         // "[In] ref int a" or "out int a"
  1567.                         bMarshalIn = bIsIn;
  1568.                         bMarshalOut = bIsOut;
  1569.                     }
  1570.                 }
  1571.                 else {
  1572.                     // "int a" or "[In, Out] a"
  1573.                     bMarshalIn = true;
  1574.                     bMarshalOut = bIsOut;
  1575.                 }
  1576.                 Util.Log("RealSchemaType.ParamInOut " + param.Name + " ref,in,out " + bIsByRef + "," + bIsIn + "," + bIsOut + " bMarshalIn,bMarshalOut " + bMarshalIn + "," + bMarshalOut);
  1577.             }
  1578.            
  1579.            
  1580.             internal override void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous)
  1581.             {
  1582.                 Util.Log("RealSchemaType.PrintSchemaType");
  1583.                 if (bAnonymous == false) {
  1584.                     sb.Length = 0;
  1585.                     sb.Append(indent);
  1586.                     sb.Append("<element name='");
  1587.                     sb.Append(ElementName);
  1588.                     sb.Append("' type='");
  1589.                     sb.Append(_xns.Prefix);
  1590.                     sb.Append(':');
  1591.                     sb.Append(FullRefName);
  1592.                     sb.Append("'/>");
  1593.                     textWriter.WriteLine(sb);
  1594.                 }
  1595.                
  1596.                 sb.Length = 0;
  1597.                 sb.Append(indent);
  1598.                 if (bAnonymous == false) {
  1599.                     sb.Append("<complexType name='");
  1600.                     sb.Append(FullRefName);
  1601.                     sb.Append('\'');
  1602.                 }
  1603.                 else {
  1604.                     sb.Append("<complexType ");
  1605.                 }
  1606.                 if (BaseName != null) {
  1607.                     sb.Append(" base='");
  1608.                     sb.Append(BaseName);
  1609.                     sb.Append('\'');
  1610.                 }
  1611.                 if ((IsSealed == true) && (bAnonymous == false))
  1612.                     sb.Append(" final='#all'");
  1613.                 bool bEmpty = IsEmpty;
  1614.                 if (bEmpty)
  1615.                     sb.Append("/>");
  1616.                 else
  1617.                     sb.Append('>');
  1618.                 textWriter.WriteLine(sb);
  1619.                 if (bEmpty)
  1620.                     return;
  1621.                
  1622.                 base.PrintBody(textWriter, sb, indent);
  1623.                
  1624.                 textWriter.Write(indent);
  1625.                 textWriter.WriteLine("</complexType>");
  1626.                
  1627.                 return;
  1628.             }
  1629.            
  1630.            
  1631.             internal void PrintMessageWsdl(TextWriter textWriter, StringBuilder sb, string indent, ArrayList refNames)
  1632.             {
  1633.                 Util.Log("RealSchemaType.PrintMessageWsdl " + Name);
  1634.                
  1635.                 string indent1 = IndentP(indent);
  1636.                 string indent2 = IndentP(indent1);
  1637.                 string indent3 = IndentP(indent2);
  1638.                 string ns = null;
  1639.                 string nsPrefix = null;
  1640.                 MethodInfo method = null;
  1641.                 string methodName = null;
  1642.                 string overloadedName = null;
  1643.                 bool bIsOneWay = false;
  1644.                
  1645.                 string useNS = null;
  1646.                 if (_xns.IsInteropType)
  1647.                     useNS = _xns.Name;
  1648.                 else {
  1649.                     sb.Length = 0;
  1650.                    
  1651.                     WsdlGenerator.QualifyName(sb, _xns.Name, Name);
  1652.                     useNS = sb.ToString();
  1653.                 }
  1654.                 XMLNamespace methodXns = _xns.LookupSchemaNamespace(useNS, _xns.Assem);
  1655.                
  1656.                 //Debug.Assert(methodXns != null, "Namespace is null");
  1657.                
  1658.                 int methodsLength = 0;
  1659.                 if (_methods != null)
  1660.                     methodsLength = _methods.Length;
  1661.                
  1662.                 if (methodsLength > 0) {
  1663.                     ns = methodXns.Namespace;
  1664.                     nsPrefix = methodXns.Prefix;
  1665.                 }
  1666.                
  1667.                 refNames.Add(Name);
  1668.                
  1669.                 for (int i = 0; i < methodsLength; i++) {
  1670.                     method = _methods[i];
  1671.                     bIsOneWay = RemotingServices.IsOneWay(method);
  1672.                     methodName = PrintMethodName(method);
  1673.                     sb.Length = 0;
  1674.                     WsdlGenerator.QualifyName(sb, Name, _methodTypes[2 * i]);
  1675.                     overloadedName = sb.ToString();
  1676.                    
  1677.                     // Message element
  1678.                     sb.Length = 0;
  1679.                     sb.Append("\n");
  1680.                     sb.Append(indent);
  1681.                     sb.Append("<message name='");
  1682.                     sb.Append(overloadedName + "Input");
  1683.                     sb.Append("'>");
  1684.                     textWriter.WriteLine(sb);
  1685.                    
  1686.                     PhonySchemaType phony = _phony[i];
  1687.                    
  1688.                    
  1689.                     if (phony._inParamTypes != null) {
  1690.                         for (int iparam = 0; iparam < phony._inParamTypes.Count; iparam++) {
  1691.                             sb.Length = 0;
  1692.                             sb.Append(indent1);
  1693.                             sb.Append("<part name='");
  1694.                             sb.Append(phony._inParamNames[iparam]);
  1695.                             sb.Append("' type='");
  1696.                             sb.Append(phony._inParamTypes[iparam]);
  1697.                             sb.Append("'/>");
  1698.                             textWriter.WriteLine(sb);
  1699.                         }
  1700.                        
  1701.                         sb.Length = 0;
  1702.                         sb.Append(indent);
  1703.                         sb.Append("</message>");
  1704.                         textWriter.WriteLine(sb);
  1705.                        
  1706.                         if (!bIsOneWay) {
  1707.                             sb.Length = 0;
  1708.                             sb.Append(indent);
  1709.                             sb.Append("<message name='");
  1710.                             sb.Append(overloadedName + "Output");
  1711.                             sb.Append("'>");
  1712.                             textWriter.WriteLine(sb);
  1713.                            
  1714.                             if (phony._returnType != null || phony._outParamTypes != null) {
  1715.                                 if (phony._returnType != null) {
  1716.                                     sb.Length = 0;
  1717.                                     sb.Append(indent1);
  1718.                                     sb.Append("<part name='");
  1719.                                     sb.Append(phony._returnName);
  1720.                                     sb.Append("' type='");
  1721.                                     sb.Append(phony._returnType);
  1722.                                     sb.Append("'/>");
  1723.                                     textWriter.WriteLine(sb);
  1724.                                 }
  1725.                                
  1726.                                 if (phony._outParamTypes != null) {
  1727.                                     for (int iparam = 0; iparam < phony._outParamTypes.Count; iparam++) {
  1728.                                         sb.Length = 0;
  1729.                                         sb.Append(indent1);
  1730.                                         sb.Append("<part name='");
  1731.                                         sb.Append(phony._outParamNames[iparam]);
  1732.                                         sb.Append("' type='");
  1733.                                         sb.Append(phony._outParamTypes[iparam]);
  1734.                                         sb.Append("'/>");
  1735.                                         textWriter.WriteLine(sb);
  1736.                                     }
  1737.                                 }
  1738.                             }
  1739.                            
  1740.                             sb.Length = 0;
  1741.                             sb.Append(indent);
  1742.                             sb.Append("</message>");
  1743.                             textWriter.WriteLine(sb);
  1744.                         }
  1745.                     }
  1746.                 }
  1747.                
  1748.                 // PortType Element
  1749.                 sb.Length = 0;
  1750.                 sb.Append("\n");
  1751.                 sb.Append(indent);
  1752.                 sb.Append("<portType name='");
  1753.                 sb.Append(Name);
  1754.                 sb.Append("PortType");
  1755.                 sb.Append("'>");
  1756.                 textWriter.WriteLine(sb);
  1757.                
  1758.                 for (int i = 0; i < methodsLength; i++) {
  1759.                     method = _methods[i];
  1760.                     PhonySchemaType phony = _phony[i];
  1761.                    
  1762.                     bIsOneWay = RemotingServices.IsOneWay(method);
  1763.                     methodName = PrintMethodName(method);
  1764.                     sb.Length = 0;
  1765.                     sb.Append("tns:");
  1766.                     WsdlGenerator.QualifyName(sb, Name, _methodTypes[2 * i]);
  1767.                     overloadedName = sb.ToString();
  1768.                    
  1769.                     sb.Length = 0;
  1770.                     sb.Append(indent1);
  1771.                     sb.Append("<operation name='");
  1772.                     sb.Append(methodName);
  1773.                     sb.Append("'");
  1774.                     if (phony != null && phony._paramNamesOrder.Count > 0) {
  1775.                        
  1776.                         sb.Append(" parameterOrder='");
  1777.                         bool bfirst = true;
  1778.                         foreach (string param in phony._paramNamesOrder) {
  1779.                             if (!bfirst)
  1780.                                 sb.Append(" ");
  1781.                             sb.Append(param);
  1782.                             bfirst = false;
  1783.                         }
  1784.                         sb.Append("'");
  1785.                     }
  1786.                    
  1787.                     sb.Append(">");
  1788.                     textWriter.WriteLine(sb);
  1789.                    
  1790.                     sb.Length = 0;
  1791.                     sb.Append(indent2);
  1792.                     sb.Append("<input name='");
  1793.                     sb.Append(_methodTypes[2 * i]);
  1794.                     sb.Append("Request' ");
  1795.                     sb.Append("message='");
  1796.                     sb.Append(overloadedName);
  1797.                     sb.Append("Input");
  1798.                     sb.Append("'/>");
  1799.                     textWriter.WriteLine(sb);
  1800.                    
  1801.                     if (!bIsOneWay) {
  1802.                         sb.Length = 0;
  1803.                         sb.Append(indent2);
  1804.                         sb.Append("<output name='");
  1805.                         sb.Append(_methodTypes[2 * i]);
  1806.                         sb.Append("Response' ");
  1807.                        
  1808.                         sb.Append("message='");
  1809.                         sb.Append(overloadedName);
  1810.                         sb.Append("Output");
  1811.                         sb.Append("'/>");
  1812.                         textWriter.WriteLine(sb);
  1813.                     }
  1814.                    
  1815.                     sb.Length = 0;
  1816.                     sb.Append(indent1);
  1817.                     sb.Append("</operation>");
  1818.                     textWriter.WriteLine(sb);
  1819.                 }
  1820.                
  1821.                 sb.Length = 0;
  1822.                 sb.Append(indent);
  1823.                 sb.Append("</portType>");
  1824.                 textWriter.WriteLine(sb);
  1825.                
  1826.                
  1827.                 // Binding
  1828.                 sb.Length = 0;
  1829.                 sb.Append("\n");
  1830.                 sb.Append(indent);
  1831.                 sb.Append("<binding name='");
  1832.                 sb.Append(Name);
  1833.                 sb.Append("Binding");
  1834.                 sb.Append("' ");
  1835.                 sb.Append("type='tns:");
  1836.                 sb.Append(Name);
  1837.                 sb.Append("PortType");
  1838.                 sb.Append("'>");
  1839.                 textWriter.WriteLine(sb);
  1840.                
  1841.                 sb.Length = 0;
  1842.                 sb.Append(indent1);
  1843.                 sb.Append("<soap:binding style='rpc' transport='http://schemas.xmlsoap.org/soap/http'/>");
  1844.                 textWriter.WriteLine(sb);
  1845.                
  1846.                 if (_type.IsInterface || IsSUDSType)
  1847.                     PrintSuds(_type, _implIFaces, _nestedTypes, textWriter, sb, indent);
  1848.                 // Some namespaces have no suds types
  1849.                
  1850.                 if (!_xns.IsClassesPrinted) {
  1851.                     for (int i = 0; i < _xns._realSchemaTypes.Count; i++) {
  1852.                         RealSchemaType rsType = (RealSchemaType)_xns._realSchemaTypes[i];
  1853.                         Type type = rsType._type;
  1854.                         Util.Log("RealSchemaType.PrintMessageWsd suds realSchemaType " + type);
  1855.                         if (!rsType.Type.IsInterface && !rsType.IsSUDSType) {
  1856.                             Util.Log("RealSchemaType.PrintMessageWsd suds realSchemaType 2 " + type.BaseType + " " + typeof(MulticastDelegate).IsAssignableFrom(type));
  1857.                             ;
  1858.                            
  1859.                             Type[] iFaces = GetIntroducedInterfaces(rsType._type);
  1860.                             string[] implIFaces = null;
  1861.                             bool bUsedFaces = false;
  1862.                             if (iFaces.Length > 0) {
  1863.                                 implIFaces = new string[iFaces.Length];
  1864.                                 for (int j = 0; i < iFaces.Length; i++) {
  1865.                                     string fns;
  1866.                                     Assembly fassem;
  1867.                                     Util.Log("RealSchemaType.PrintMessageWsdl iFace " + iFaces[j].Name);
  1868.                                     bool bInteropType = WsdlGenerator.GetNSAndAssembly(iFaces[j], out fns, out fassem);
  1869.                                     XMLNamespace xns = _xns.LookupSchemaNamespace(fns, fassem);
  1870.                                     Debug.Assert(xns != null, "SchemaType should have been found");
  1871.                                     sb.Length = 0;
  1872.                                     sb.Append(xns.Prefix);
  1873.                                     sb.Append(':');
  1874.                                     sb.Append(iFaces[j].Name);
  1875.                                     implIFaces[j] = sb.ToString();
  1876.                                     if (implIFaces[j].Length > 0)
  1877.                                         bUsedFaces = true;
  1878.                                 }
  1879.                             }
  1880.                             if (!bUsedFaces)
  1881.                                 implIFaces = null;
  1882.                            
  1883.                             PrintSuds(type, implIFaces, rsType._nestedTypes, textWriter, sb, indent);
  1884.                         }
  1885.                     }
  1886.                     _xns.IsClassesPrinted = true;
  1887.                 }
  1888.                
  1889.                
  1890.                 for (int i = 0; i < methodsLength; i++) {
  1891.                     method = _methods[i];
  1892.                     methodName = PrintMethodName(method);
  1893.                     bIsOneWay = RemotingServices.IsOneWay(method);
  1894.                    
  1895.                     //binding operation
  1896.                     sb.Length = 0;
  1897.                     sb.Append(indent1);
  1898.                     sb.Append("<operation name='");
  1899.                     sb.Append(methodName);
  1900.                     sb.Append("'>");
  1901.                     textWriter.WriteLine(sb);
  1902.                    
  1903.                     sb.Length = 0;
  1904.                     sb.Append(indent2);
  1905.                     sb.Append("<soap:operation soapAction='");
  1906.                     string soapAction = SoapServices.GetSoapActionFromMethodBase(method);
  1907.                     if ((soapAction != null) || (soapAction.Length > 0)) {
  1908.                         sb.Append(soapAction);
  1909.                     }
  1910.                     else {
  1911.                         sb.Append(ns);
  1912.                         sb.Append('#');
  1913.                         sb.Append(methodName);
  1914.                     }
  1915.                     sb.Append("'/>");
  1916.                     textWriter.WriteLine(sb);
  1917.                    
  1918.                     if (_methodAttributes != null && (i < _methodAttributes.Length) && _methodAttributes[i] != null) {
  1919.                         // Suds for method attributes
  1920.                         // Attributes are only for public methods,
  1921.                         // _method contains public and additional qualified interface methods
  1922.                         // The public methods are at the beginning of _methods
  1923.                         sb.Length = 0;
  1924.                         sb.Append(indent2);
  1925.                         sb.Append("<suds:method attributes='");
  1926.                         sb.Append(_methodAttributes[i]);
  1927.                         sb.Append("'/>");
  1928.                         textWriter.WriteLine(sb);
  1929.                     }
  1930.                    
  1931.                     sb.Length = 0;
  1932.                     sb.Append(indent2);
  1933.                     sb.Append("<input name='");
  1934.                     sb.Append(_methodTypes[2 * i]);
  1935.                     sb.Append("Request'>");
  1936.                     textWriter.WriteLine(sb);
  1937.                    
  1938.                     sb.Length = 0;
  1939.                     sb.Append(indent3);
  1940.                     sb.Append("<soap:body use='encoded' encodingStyle='http://schemas.xmlsoap.org/soap/encoding/' namespace='");
  1941.                     string interopNamespace = SoapServices.GetXmlNamespaceForMethodCall(method);
  1942.                     if (interopNamespace == null)
  1943.                         sb.Append(ns);
  1944.                     else
  1945.                         sb.Append(interopNamespace);
  1946.                     sb.Append("'/>");
  1947.                     textWriter.WriteLine(sb);
  1948.                    
  1949.                     sb.Length = 0;
  1950.                     sb.Append(indent2);
  1951.                     sb.Append("</input>");
  1952.                     textWriter.WriteLine(sb);
  1953.                    
  1954.                     if (!bIsOneWay) {
  1955.                         sb.Length = 0;
  1956.                         sb.Append(indent2);
  1957.                         sb.Append("<output name='");
  1958.                         sb.Append(_methodTypes[2 * i]);
  1959.                         sb.Append("Response'>");
  1960.                         textWriter.WriteLine(sb);
  1961.                        
  1962.                         sb.Length = 0;
  1963.                         sb.Append(indent3);
  1964.                         sb.Append("<soap:body use='encoded' encodingStyle='http://schemas.xmlsoap.org/soap/encoding/' namespace='");
  1965.                         interopNamespace = SoapServices.GetXmlNamespaceForMethodResponse(method);
  1966.                         if (interopNamespace == null)
  1967.                             sb.Append(ns);
  1968.                         else
  1969.                             sb.Append(interopNamespace);
  1970.                         sb.Append("'/>");
  1971.                         textWriter.WriteLine(sb);
  1972.                        
  1973.                         sb.Length = 0;
  1974.                         sb.Append(indent2);
  1975.                         sb.Append("</output>");
  1976.                         textWriter.WriteLine(sb);
  1977.                     }
  1978.                    
  1979.                     sb.Length = 0;
  1980.                     sb.Append(indent1);
  1981.                     sb.Append("</operation>");
  1982.                     textWriter.WriteLine(sb);
  1983.                 }
  1984.                
  1985.                 sb.Length = 0;
  1986.                 sb.Append(indent);
  1987.                 sb.Append("</binding>");
  1988.                 textWriter.WriteLine(sb);
  1989.             }
  1990.            
  1991.             private void PrintSuds(Type type, string[] implIFaces, Type[] nestedTypes, TextWriter textWriter, StringBuilder sb, string indent)
  1992.             {
  1993.                 Util.Log("RealSchemaType.PrintSuds " + type + " implIFaces " + implIFaces + " nestedTypes " + nestedTypes);
  1994.                 string indent1 = IndentP(indent);
  1995.                 string indent2 = IndentP(indent1);
  1996.                 string indent3 = IndentP(indent2);
  1997.                
  1998.                 string sudsEnd = null;
  1999.                 // Type, interface, extends information
  2000.                 sb.Length = 0;
  2001.                 sb.Append(indent1);
  2002.                 if (type.IsInterface) {
  2003.                     sb.Append("<suds:interface type='");
  2004.                     sudsEnd = "</suds:interface>";
  2005.                    
  2006.                    
  2007.                 }
  2008.                 else if (type.IsValueType) {
  2009.                     sb.Append("<suds:struct type='");
  2010.                     sudsEnd = "</suds:struct>";
  2011.                 }
  2012.                 else {
  2013.                     sb.Append("<suds:class type='");
  2014.                     sudsEnd = "</suds:class>";
  2015.                 }
  2016.                 sb.Append(_xns.Prefix);
  2017.                 sb.Append(':');
  2018.                 sb.Append(WsdlGenerator.RefName(type));
  2019.                 sb.Append("'");
  2020.                
  2021.                 Type baseType = type.BaseType;
  2022.                 if (IsNotSystemDefinedRoot(type, baseType)) {
  2023.                     XMLNamespace xns = _WsdlGenerator.GetNamespace(baseType);
  2024.                     sb.Append(" extends='");
  2025.                     sb.Append(xns.Prefix);
  2026.                     sb.Append(':');
  2027.                     sb.Append(baseType.Name);
  2028.                     sb.Append("'");
  2029.                    
  2030.                 }
  2031.                
  2032.                 if (baseType != null && baseType.FullName == "System.EnterpriseServices.ServicedComponent")
  2033.                     sb.Append(" rootType='ServicedComponent'");
  2034.                 else if (typeof(Delegate).IsAssignableFrom(type) || typeof(MulticastDelegate).IsAssignableFrom(type))
  2035.                     sb.Append(" rootType='Delegate'");
  2036.                 else if (typeof(MarshalByRefObject).IsAssignableFrom(type))
  2037.                     sb.Append(" rootType='MarshalByRefObject'");
  2038.                 else if (typeof(ISerializable).IsAssignableFrom(type))
  2039.                     sb.Append(" rootType='ISerializable'");
  2040.                
  2041.                 if (implIFaces == null && nestedTypes == null)
  2042.                     sb.Append("/>");
  2043.                 else
  2044.                     sb.Append(">");
  2045.                
  2046.                 textWriter.WriteLine(sb);
  2047.                
  2048.                 string extendAttribute = null;
  2049.                 if (type.IsInterface)
  2050.                     extendAttribute = "<suds:extends type='";
  2051.                 else
  2052.                     extendAttribute = "<suds:implements type='";
  2053.                
  2054.                
  2055.                 if (implIFaces != null) {
  2056.                     for (int j = 0; j < implIFaces.Length; j++) {
  2057.                         if (!(implIFaces[j] == null || implIFaces[j] == String.Empty)) {
  2058.                             sb.Length = 0;
  2059.                             sb.Append(indent2);
  2060.                             sb.Append(extendAttribute);
  2061.                             sb.Append(implIFaces[j]);
  2062.                             sb.Append("'/>");
  2063.                             textWriter.WriteLine(sb);
  2064.                         }
  2065.                     }
  2066.                 }
  2067.                
  2068.                 if (nestedTypes != null) {
  2069.                     for (int j = 0; j < nestedTypes.Length; j++) {
  2070.                         sb.Length = 0;
  2071.                         sb.Append(indent2);
  2072.                         sb.Append("<suds:nestedType name='");
  2073.                         sb.Append(nestedTypes[j].Name);
  2074.                         sb.Append("' type='");
  2075.                         sb.Append(_xns.Prefix);
  2076.                         sb.Append(':');
  2077.                         sb.Append(WsdlGenerator.RefName(nestedTypes[j]));
  2078.                         sb.Append("'/>");
  2079.                         textWriter.WriteLine(sb);
  2080.                     }
  2081.                 }
  2082.                
  2083.                 if (implIFaces != null || nestedTypes != null) {
  2084.                     sb.Length = 0;
  2085.                     sb.Append(indent1);
  2086.                     sb.Append(sudsEnd);
  2087.                     textWriter.WriteLine(sb);
  2088.                 }
  2089.             }
  2090.            
  2091.            
  2092.             private static string ProcessArray(Type type, XMLNamespace xns)
  2093.             {
  2094.                 Util.Log("RealSchemaType.ProcessArray Enter " + type);
  2095.                 string qname = null;
  2096.                 bool bbinary = false;
  2097.                 Type elementType = type.GetElementType();
  2098.                 string elementTypeName = "ArrayOf";
  2099.                 while (elementType.IsArray) {
  2100.                     elementTypeName = elementTypeName + "ArrayOf";
  2101.                     elementType = elementType.GetElementType();
  2102.                 }
  2103.                
  2104.                 qname = RealSchemaType.TypeName(elementType, true, xns);
  2105.                 int index = qname.IndexOf(":");
  2106.                 string prefix = qname.Substring(0, index);
  2107.                 string wireName = qname.Substring(index + 1);
  2108.                 Util.Log("RealSchemaType.ProcessArray qname " + qname + " wirename " + wireName);
  2109.                 int rank = type.GetArrayRank();
  2110.                 string rankStr = "";
  2111.                 if (rank > 1)
  2112.                     rankStr = rank.ToString(CultureInfo.InvariantCulture);
  2113.                 string csname = elementTypeName + wireName.Substring(0, 1).ToUpper(CultureInfo.InvariantCulture) + wireName.Substring(1) + rankStr;
  2114.                 csname = csname.Replace('+', 'N');
  2115.                 // need to get rid of + in nested classes
  2116.                 ArraySchemaType ast = xns.LookupArraySchemaType(csname);
  2117.                 if (ast == null) {
  2118.                     ArraySchemaType cstype = new ArraySchemaType(type, csname, SchemaBlockType.ComplexContent, false);
  2119.                     Restriction restriction = new Restriction();
  2120.                     SchemaAttribute attribute = new SchemaAttribute();
  2121.                     if (bbinary)
  2122.                         attribute.AddArray(qname);
  2123.                     else {
  2124.                         string arrayTypeName = type.Name;
  2125.                         index = arrayTypeName.IndexOf("[");
  2126.                         attribute.AddArray(qname + arrayTypeName.Substring(index));
  2127.                     }
  2128.                    
  2129.                     restriction.AddArray(attribute);
  2130.                     cstype.AddParticle(restriction);
  2131.                     xns.AddArraySchemaType(cstype);
  2132.                 }
  2133.                
  2134.                 string returnStr = xns.Prefix + ":" + csname;
  2135.                 Util.Log("RealSchemaType.ProcessArray Exit " + returnStr);
  2136.                 return returnStr;
  2137.             }
  2138.            
  2139.            
  2140.            
  2141.             static internal string TypeName(Type type, bool bEmbedded, XMLNamespace thisxns)
  2142.             {
  2143.                 Util.Log("RealSchemaType.TypeName entry " + type + " bEmbedded " + bEmbedded + " xns " + thisxns.Name);
  2144.                 string typeName = null;
  2145.                 if (type.IsArray)
  2146.                     return ProcessArray(type, thisxns);
  2147.                
  2148.                 string clrTypeName = WsdlGenerator.RefName(type);
  2149.                 Type clrType = type;
  2150.                
  2151.                 // If ref type the name ends in &
  2152.                 if (type.IsByRef) {
  2153.                     clrType = type.GetElementType();
  2154.                     clrTypeName = WsdlGenerator.RefName(clrType);
  2155.                     if (clrType.IsArray)
  2156.                         return ProcessArray(clrType, thisxns);
  2157.                 }
  2158.                
  2159.                 typeName = SudsConverter.MapClrTypeToXsdType(clrType);
  2160.                
  2161.                 if (typeName == null) {
  2162.                     string ns = type.Namespace;
  2163.                     Assembly assem = type.Module.Assembly;
  2164.                     XMLNamespace xns = null;
  2165.                     Util.Log("RealSchemaType.TypeName realNS " + ns);
  2166.                     xns = (XMLNamespace)thisxns.Generator._typeToInteropNS[type];
  2167.                    
  2168.                     if (xns == null) {
  2169.                         xns = thisxns.LookupSchemaNamespace(ns, assem);
  2170.                         if (xns == null) {
  2171.                             xns = thisxns.Generator.LookupNamespace(ns, assem);
  2172.                             if (xns == null) {
  2173.                                 xns = thisxns.Generator.AddNamespace(ns, assem);
  2174.                             }
  2175.                             thisxns.DependsOnSchemaNS(xns, false);
  2176.                         }
  2177.                         Util.Log("RealSchemaType.TypeName depended NS with assem equals " + xns.Name);
  2178.                     }
  2179.                     StringBuilder sb = new StringBuilder(256);
  2180.                    
  2181.                     sb.Append(xns.Prefix);
  2182.                     sb.Append(':');
  2183.                     sb.Append(clrTypeName);
  2184.                     typeName = sb.ToString();
  2185.                 }
  2186.                
  2187.                 Util.Log("RealSchemaType.TypeName exit " + typeName);
  2188.                 return typeName;
  2189.             }
  2190.            
  2191.            
  2192.             private static Type[] GetIntroducedInterfaces(Type type)
  2193.             {
  2194.                 ArrayList ifaceA = new ArrayList();
  2195.                 Type[] typeA = type.GetInterfaces();
  2196.                 // remove system interfaces.
  2197.                 foreach (Type itype in typeA) {
  2198.                     if (!itype.FullName.StartsWith("System.")) {
  2199.                         ifaceA.Add(itype);
  2200.                         Util.Log("RealSchemaType.GetIntroducedInterfaces " + type + " Interfaces " + itype);
  2201.                     }
  2202.                 }
  2203.                
  2204.                 Util.Log("RealSchemaType.GetIntroducedInterfaces " + type + " typeInterface? " + type.IsInterface + " number of interfaces " + typeA.Length);
  2205.                
  2206.                 Type[] ifaceTypes = new Type[ifaceA.Count];
  2207.                 for (int i = 0; i < ifaceA.Count; i++)
  2208.                     ifaceTypes[i] = (Type)ifaceA[i];
  2209.                 return ifaceTypes;
  2210.             }
  2211.            
  2212.             private static void FindMethodAttributes(Type type, MethodInfo[] infos, ref string[] methodAttributes, BindingFlags bFlags)
  2213.             {
  2214.                 Util.Log("RealSchemaType.FindMethodAttributes Enter " + type);
  2215.                 Type baseType = type;
  2216.                 ArrayList inherit = new ArrayList();
  2217.                 while (true) {
  2218.                     baseType = baseType.BaseType;
  2219.                    
  2220.                     Util.Log("RealSchemaType.FindMethodAttributes baseType " + baseType);
  2221.                     if (baseType != null && !baseType.FullName.StartsWith("System."))
  2222.                         inherit.Add(baseType);
  2223.                     else
  2224.                         break;
  2225.                 }
  2226.                
  2227.                 StringBuilder sb = new StringBuilder();
  2228.                 for (int i = 0; i < infos.Length; i++) {
  2229.                     MethodBase info = (MethodBase)infos[i];
  2230.                     sb.Length = 0;
  2231.                     MethodAttributes ma = info.Attributes;
  2232.                     bool bVirtual = info.IsVirtual;
  2233.                     bool bNewSlot = ((ma & MethodAttributes.NewSlot) == MethodAttributes.NewSlot);
  2234.                     Util.Log("RealSchemaType.FindMethodAttributes " + info.Name + " bVirtual " + bVirtual + " bNewSlot " + bNewSlot + " hidebysig " + info.IsHideBySig);
  2235.                     if (info.IsPublic)
  2236.                         sb.Append("public");
  2237.                     else if (info.IsFamily)
  2238.                         sb.Append("protected");
  2239.                     else if (info.IsAssembly)
  2240.                         sb.Append("internal");
  2241.                    
  2242.                     // See if method hides inherited methods
  2243.                     bool bHides = false;
  2244.                     for (int j = 0; j < inherit.Count; j++) {
  2245.                         baseType = (Type)inherit[j];
  2246.                         ParameterInfo[] paramInfos = info.GetParameters();
  2247.                         Type[] types = new Type[paramInfos.Length];
  2248.                         for (int itype = 0; itype < types.Length; itype++) {
  2249.                             types[itype] = paramInfos[itype].ParameterType;
  2250.                         }
  2251.                         MethodInfo baseInfo = baseType.GetMethod(info.Name, types);
  2252.                         if (baseInfo != null) {
  2253.                             // Hides
  2254.                             if (sb.Length > 0)
  2255.                                 sb.Append(" ");
  2256.                             if (bNewSlot || baseInfo.IsFinal)
  2257.                                 sb.Append("new");
  2258.                             else if (baseInfo.IsVirtual && bVirtual)
  2259.                                 sb.Append("override");
  2260.                             else
  2261.                                 sb.Append("new");
  2262.                             bHides = true;
  2263.                             break;
  2264.                         }
  2265.                     }
  2266.                     if (!bHides && bVirtual) {
  2267.                         if (sb.Length > 0)
  2268.                             sb.Append(" ");
  2269.                         sb.Append("virtual");
  2270.                     }
  2271.                    
  2272.                     if (sb.Length > 0) {
  2273.                         methodAttributes[i] = sb.ToString();
  2274.                         Util.Log("RealSchemaType.FindMethodAttributes Exit " + info.Name + " " + methodAttributes[i]);
  2275.                     }
  2276.                 }
  2277.             }
  2278.            
  2279.             private static MethodInfo[] GetIntroducedMethods(Type type, ref string[] methodAttributes)
  2280.             {
  2281.                 Util.Log("RealSchemaType.GetIntroducedMethods " + type);
  2282.                
  2283.                
  2284.                 // Methods in the class are either the class public methods or interface qualified methods
  2285.                
  2286.                 BindingFlags bFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public;
  2287.                 MethodInfo[] methodInfos = type.GetMethods(bFlags);
  2288.                 //public methods (including unqualified interface methods)
  2289.                 if (type.IsInterface)
  2290.                     return methodInfos;
  2291.                
  2292.                 // Find method attributes for public methods
  2293.                 methodAttributes = new string[methodInfos.Length];
  2294.                 FindMethodAttributes(type, methodInfos, ref methodAttributes, bFlags);
  2295.                
  2296.                 // Get any class methods which are interface qualifed methods.
  2297.                 // interface qualified methods are not public in the metadata.
  2298.                 ArrayList additionalInfos = new ArrayList();
  2299.                 Type[] itypeA = type.GetInterfaces();
  2300.                 foreach (Type itype in itypeA) {
  2301.                     InterfaceMapping im = type.GetInterfaceMap(itype);
  2302.                     foreach (MethodInfo mi in im.TargetMethods) {
  2303.                         if (!mi.IsPublic && type.GetMethod(mi.Name, bFlags | BindingFlags.NonPublic) != null) {
  2304.                             additionalInfos.Add(mi);
  2305.                         }
  2306.                     }
  2307.                 }
  2308.                
  2309.                 // Combine all the methodinfos into one structure
  2310.                 MethodInfo[] finalMethodInfos = null;
  2311.                 if (additionalInfos.Count > 0) {
  2312.                     finalMethodInfos = new MethodInfo[methodInfos.Length + additionalInfos.Count];
  2313.                     for (int i = 0; i < methodInfos.Length; i++)
  2314.                         finalMethodInfos[i] = methodInfos[i];
  2315.                     for (int i = 0; i < additionalInfos.Count; i++)
  2316.                         finalMethodInfos[methodInfos.Length + i] = (MethodInfo)additionalInfos[i];
  2317.                 }
  2318.                 else
  2319.                     finalMethodInfos = methodInfos;
  2320.                
  2321.                 return finalMethodInfos;
  2322.             }
  2323.            
  2324.             static internal string PrintMethodName(MethodInfo methodInfo)
  2325.             {
  2326.                 string methodName = methodInfo.Name;
  2327.                 int lastDot = 0;
  2328.                 int prevDot = 0;
  2329.                
  2330.                 for (int i = 0; i < methodName.Length; i++) {
  2331.                     if (methodName[i] == '.') {
  2332.                         prevDot = lastDot;
  2333.                         lastDot = i;
  2334.                     }
  2335.                 }
  2336.                
  2337.                 string iname = methodName;
  2338.                
  2339.                 if (prevDot > 0)
  2340.                     iname = methodName.Substring(prevDot + 1);
  2341.                
  2342.                 return iname;
  2343.             }
  2344.            
  2345.             private static FieldInfo[] GetInstanceFields(Type type)
  2346.             {
  2347.                 Util.Log("RealSchemaType.GetIntroducedFields " + type);
  2348.                
  2349.                 BindingFlags bFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public;
  2350.                
  2351.                 if (!s_marshalByRefType.IsAssignableFrom(type))
  2352.                     bFlags |= BindingFlags.NonPublic;
  2353.                
  2354.                 FieldInfo[] fields = type.GetFields(bFlags);
  2355.                 Util.Log("RealSchemaType.GetIntroducedFields length " + fields.Length);
  2356.                 int actualLength = fields.Length;
  2357.                 if (actualLength == 0)
  2358.                     return (emptyFieldSet);
  2359.                
  2360.                 for (int i = 0; i < fields.Length; i++) {
  2361.                     Util.Log("RealSchemaType.GetInstanceFields field " + fields[i].Name + " " + fields[i].FieldType + " type " + type);
  2362.                     if (fields[i].IsStatic) {
  2363.                         Debug.Assert(false, "Static Field");
  2364.                         Util.Log("RealSchemaType.GetInstanceFields field static " + fields[i].FieldType);
  2365.                         --actualLength;
  2366.                         fields[i] = fields[actualLength];
  2367.                         fields[actualLength] = null;
  2368.                     }
  2369.                 }
  2370.                
  2371.                 if (actualLength < fields.Length) {
  2372.                     FieldInfo[] ifields = new FieldInfo[actualLength];
  2373.                     Array.Copy(fields, ifields, actualLength);
  2374.                     Util.Log("RealSchemaType.GetInstanceFields adjust length " + actualLength);
  2375.                     return (ifields);
  2376.                 }
  2377.                
  2378.                 return (fields);
  2379.             }
  2380.            
  2381.             // Instance fields
  2382.             private WsdlGenerator _WsdlGenerator;
  2383.             private Type _type;
  2384.             private string _serviceEndpoint;
  2385.             private Hashtable _typeToServiceEndpoint;
  2386.             private bool _bUnique;
  2387.             private XMLNamespace _xns;
  2388.             private bool _bStruct;
  2389.             private string[] _implIFaces;
  2390.            
  2391.             private Type[] _iFaces;
  2392.             private MethodInfo[] _methods;
  2393.             private string[] _methodAttributes;
  2394.             private string[] _methodTypes;
  2395.             private FieldInfo[] _fields;
  2396.             private PhonySchemaType[] _phony;
  2397.             internal Type[] _nestedTypes;
  2398.            
  2399.             // Static fields
  2400.             private static Type[] emptyTypeSet = new Type[0];
  2401.             private static MethodInfo[] emptyMethodSet = new MethodInfo[0];
  2402.             private static FieldInfo[] emptyFieldSet = new FieldInfo[0];
  2403.         }
  2404.        
  2405.         private class XMLNamespace
  2406.         {
  2407.             internal XMLNamespace(string name, Assembly assem, string serviceEndpoint, Hashtable typeToServiceEndpoint, string prefix, bool bInteropType, WsdlGenerator generator)
  2408.             {
  2409.                 Util.Log("XMLNamespace.XMLNamespace Enter " + name + " serviceEndpoint " + serviceEndpoint + " prefix " + prefix + " bInteropType " + bInteropType);
  2410.                 _name = name;
  2411.                 _assem = assem;
  2412.                 _bUnique = false;
  2413.                 _bInteropType = bInteropType;
  2414.                 _generator = generator;
  2415.                 StringBuilder sb = new StringBuilder(256);
  2416.                 Assembly systemAssembly = typeof(string).Module.Assembly;
  2417.                
  2418.                 // Remove leading . for an empty namespace
  2419.                
  2420.                 if (!_bInteropType) {
  2421.                     if (assem == systemAssembly) {
  2422.                         sb.Append(SoapServices.CodeXmlNamespaceForClrTypeNamespace(name, null));
  2423.                     }
  2424.                     else if (assem != null) {
  2425.                         sb.Append(SoapServices.CodeXmlNamespaceForClrTypeNamespace(name, assem.FullName));
  2426.                     }
  2427.                 }
  2428.                 else {
  2429.                     sb.Append(name);
  2430.                 }
  2431.                 _namespace = sb.ToString();
  2432.                 _prefix = prefix;
  2433.                 _dependsOnSchemaNS = new ArrayList();
  2434.                 _realSUDSTypes = new ArrayList();
  2435.                 _dependsOnSUDSNS = new ArrayList();
  2436.                 _realSchemaTypes = new ArrayList();
  2437.                 _phonySchemaTypes = new ArrayList();
  2438.                 _simpleSchemaTypes = new ArrayList();
  2439.                 _arraySchemaTypes = new ArrayList();
  2440.                 _xnsImports = new ArrayList();
  2441.                 _serviceEndpoint = serviceEndpoint;
  2442.                 _typeToServiceEndpoint = typeToServiceEndpoint;
  2443.                 Util.Log("XMLNamespace.XMLNamespace exit " + _namespace);
  2444.             }
  2445.            
  2446.             internal string Name {
  2447.                 get { return (_name); }
  2448.             }
  2449.             internal Assembly Assem {
  2450.                 get { return (_assem); }
  2451.             }
  2452.             internal string Prefix {
  2453.                 get { return (_prefix); }
  2454.             }
  2455.             internal string Namespace {
  2456.                 get { return (_namespace); }
  2457.             }
  2458.            
  2459.             internal bool IsInteropType {
  2460.                 get { return (_bInteropType); }
  2461.             }
  2462.            
  2463.             internal WsdlGenerator Generator {
  2464.                 get { return (_generator); }
  2465.             }
  2466.            
  2467.             internal bool IsClassesPrinted {
  2468.                 get { return _bClassesPrinted; }
  2469.                 set { _bClassesPrinted = value; }
  2470.             }
  2471.            
  2472.            
  2473.             //internal XMLNamespace(String name, Assembly assem, String serviceEndpoint, Hashtable typeToServiceEndpoint, String prefix, bool bInteropType, WsdlGenerator generator ){
  2474.            
  2475. /*
  2476.             internal SchemaType LookupSchemaType(Type type)
  2477.             {
  2478.                 return (SchemaType)_typeToSchemaType[type];
  2479.             }
  2480.             internal Type LookupType(SchemaType stype)
  2481.             {
  2482.                 return (Type)_schemaTypeToType[stype];
  2483.             }
  2484.             */           
  2485.            
  2486.             internal Type LookupSchemaType(string name)
  2487.             {
  2488.                 Type returnType = null;
  2489.                 RealSchemaType rsType = LookupRealSchemaType(name);
  2490.                 if (rsType != null)
  2491.                     returnType = rsType.Type;
  2492.                
  2493.                 SimpleSchemaType ssType = LookupSimpleSchemaType(name);
  2494.                 if (ssType != null)
  2495.                     returnType = ssType.Type;
  2496.                
  2497.                 ArraySchemaType asType = LookupArraySchemaType(name);
  2498.                 if (asType != null)
  2499.                     returnType = asType.Type;
  2500.                
  2501.                 Util.Log("XMLNamespace.LookupSchemaType " + name + " return " + returnType);
  2502.                 return (returnType);
  2503.             }
  2504.            
  2505.             internal SimpleSchemaType LookupSimpleSchemaType(string name)
  2506.             {
  2507.                 Util.Log("XMLNamespace.LookupSimpleSchemaType " + name);
  2508.                 for (int i = 0; i < _simpleSchemaTypes.Count; i++) {
  2509.                     SimpleSchemaType ssType = (SimpleSchemaType)_simpleSchemaTypes[i];
  2510.                     if (ssType.FullRefName == name)
  2511.                         return (ssType);
  2512.                 }
  2513.                
  2514.                 return (null);
  2515.             }
  2516.            
  2517.             internal bool CheckForSchemaContent()
  2518.             {
  2519.                 if (_arraySchemaTypes.Count > 0 || _simpleSchemaTypes.Count > 0)
  2520.                     return true;
  2521.                
  2522.                 if (_realSchemaTypes.Count == 0)
  2523.                     return false;
  2524.                
  2525.                 bool bRealSchema = false;
  2526.                 for (int i = 0; i < _realSchemaTypes.Count; i++) {
  2527.                     RealSchemaType rsType = (RealSchemaType)_realSchemaTypes[i];
  2528.                     if (!rsType.Type.IsInterface && !rsType.IsSUDSType) {
  2529.                         bRealSchema = true;
  2530.                         break;
  2531.                     }
  2532.                 }
  2533.                
  2534.                 if (bRealSchema)
  2535.                     return true;
  2536.                 else
  2537.                     return false;
  2538.             }
  2539.            
  2540.             internal RealSchemaType LookupRealSchemaType(string name)
  2541.             {
  2542.                 Util.Log("XMLNamespace.LookupRealSchemaType " + name);
  2543.                 Debug.Assert(_phonySchemaTypes.Count == 0, "PhonyTypes present");
  2544.                 for (int i = 0; i < _realSchemaTypes.Count; i++) {
  2545.                     RealSchemaType rsType = (RealSchemaType)_realSchemaTypes[i];
  2546.                     if (rsType.FullRefName == name)
  2547.                         return (rsType);
  2548.                 }
  2549.                
  2550.                 return (null);
  2551.             }
  2552.            
  2553.             internal ArraySchemaType LookupArraySchemaType(string name)
  2554.             {
  2555.                 Util.Log("XMLNamespace.LookupArraySchemaType " + name);
  2556.                 //Debug.Assert(_phonySchemaTypes.Count == 0, "PhonyTypes present");
  2557.                 for (int i = 0; i < _arraySchemaTypes.Count; i++) {
  2558.                     ArraySchemaType asType = (ArraySchemaType)_arraySchemaTypes[i];
  2559.                     if (asType.Name == name)
  2560.                         return (asType);
  2561.                 }
  2562.                
  2563.                 return (null);
  2564.             }
  2565.            
  2566.             internal void AddRealSUDSType(RealSchemaType rsType)
  2567.             {
  2568.                 Util.Log("XMLNamespace.AddRealSUDSType " + rsType.Type);
  2569.                 _realSUDSTypes.Add(rsType);
  2570.                 //_typeToSchemaType[rsType.Type] = rsType;
  2571.                 //_schemaTypeToType[rsType] = rsType.Type;
  2572.                 return;
  2573.             }
  2574.            
  2575.             internal void AddRealSchemaType(RealSchemaType rsType)
  2576.             {
  2577.                 Util.Log("XMLNamespace.AddRealSchemaType " + rsType.Type);
  2578.                 Debug.Assert(LookupRealSchemaType(rsType.Name) == null, "Duplicate Type found");
  2579.                 _realSchemaTypes.Add(rsType);
  2580.                 if (rsType.IsUnique)
  2581.                     _bUnique = true;
  2582.                 //_typeToSchemaType[rsType.Type] = rsType;
  2583.                 //_schemaTypeToType[rsType] = rsType.Type;
  2584.                 return;
  2585.             }
  2586.            
  2587.             internal void AddArraySchemaType(ArraySchemaType asType)
  2588.             {
  2589.                 Debug.Assert(LookupArraySchemaType(asType.Name) == null, "Duplicate Type found");
  2590.                 _arraySchemaTypes.Add(asType);
  2591.                 //_typeToSchemaType[asType.Type] = asType;
  2592.                 //_schemaTypeToType[asType] = asType.Type;
  2593.                 return;
  2594.             }
  2595.            
  2596.             internal void AddSimpleSchemaType(SimpleSchemaType ssType)
  2597.             {
  2598.                 Util.Log("XMLNamespace.AddSimpleSchemaType " + ssType.Type);
  2599.                 Debug.Assert(LookupSimpleSchemaType(ssType.Type.Name) == null, "Duplicate Type found");
  2600.                 _simpleSchemaTypes.Add(ssType);
  2601.                 //_typeToSchemaType[ssType.Type] = ssType;
  2602.                 //_schemaTypeToType[ssType] = ssType.Type;
  2603.                 return;
  2604.             }
  2605.            
  2606.             internal PhonySchemaType LookupPhonySchemaType(string name)
  2607.             {
  2608.                 Util.Log("XMLNamespace.LookupPhonySchemaType " + name);
  2609.                 for (int i = 0; i < _phonySchemaTypes.Count; i++) {
  2610.                     PhonySchemaType type = (PhonySchemaType)_phonySchemaTypes[i];
  2611.                     if (type.Name == name)
  2612.                         return (type);
  2613.                 }
  2614.                
  2615.                 return (null);
  2616.             }
  2617.            
  2618.             internal void AddPhonySchemaType(PhonySchemaType phType)
  2619.             {
  2620.                 Util.Log("XMLNamespace.AddPhonySchemaType " + phType.Name);
  2621.                 PhonySchemaType overloadedType = LookupPhonySchemaType(phType.Name);
  2622.                 if (overloadedType != null)
  2623.                     phType.ElementName = phType.Name + overloadedType.OverloadedType();
  2624.                 _phonySchemaTypes.Add(phType);
  2625.                
  2626.                 return;
  2627.             }
  2628.            
  2629.             internal XMLNamespace LookupSchemaNamespace(string ns, Assembly assem)
  2630.             {
  2631.                 Util.Log("XMLNamespace.LookupSchemaNamespace " + ns);
  2632.                 for (int i = 0; i < _dependsOnSchemaNS.Count; i++) {
  2633.                     XMLNamespace xns = (XMLNamespace)_dependsOnSchemaNS[i];
  2634.                     if ((xns.Name == ns) && (xns.Assem == assem))
  2635.                         return (xns);
  2636.                 }
  2637.                
  2638.                 return (null);
  2639.             }
  2640.            
  2641.             internal void DependsOnSchemaNS(XMLNamespace xns, bool bImport)
  2642.             {
  2643.                 Util.Log("XMLNamespace.DependsOnSchemaNS " + Namespace + " depends on " + xns.Namespace + " bImport " + bImport);
  2644.                 if (LookupSchemaNamespace(xns.Name, xns.Assem) != null)
  2645.                     return;
  2646.                
  2647.                 _dependsOnSchemaNS.Add(xns);
  2648.                 if (bImport && Namespace != xns.Namespace)
  2649.                     _xnsImports.Add(xns);
  2650.                 return;
  2651.             }
  2652.            
  2653.             private XMLNamespace LookupSUDSNamespace(string ns, Assembly assem)
  2654.             {
  2655.                 Util.Log("XMLNamespace.LookupSUDSNamespace " + ns);
  2656.                 for (int i = 0; i < _dependsOnSUDSNS.Count; i++) {
  2657.                     XMLNamespace xns = (XMLNamespace)_dependsOnSUDSNS[i];
  2658.                     if ((xns.Name == ns) && (xns.Assem == assem))
  2659.                         return (xns);
  2660.                 }
  2661.                
  2662.                 return (null);
  2663.             }
  2664.            
  2665.             internal void DependsOnSUDSNS(XMLNamespace xns)
  2666.             {
  2667.                 Util.Log("XMLNamespace.DependsOnSUDSNS " + xns.Name + " " + xns.Assem);
  2668.                 if (LookupSUDSNamespace(xns.Name, xns.Assem) != null)
  2669.                     return;
  2670.                
  2671.                 _dependsOnSUDSNS.Add(xns);
  2672.                 return;
  2673.             }
  2674.            
  2675.             internal void Resolve()
  2676.             {
  2677.                 Util.Log("XMLNamespace.Resolve");
  2678.                 StringBuilder sb = new StringBuilder(256);
  2679.                 for (int i = 0; i < _realSchemaTypes.Count; i++)
  2680.                     ((RealSchemaType)_realSchemaTypes[i]).Resolve(sb);
  2681.                
  2682.                 return;
  2683.             }
  2684.            
  2685.             internal void PrintDependsOnWsdl(TextWriter textWriter, StringBuilder sb, string indent, Hashtable usedNames)
  2686.             {
  2687.                 Util.Log("XMLNamespace.PrintDependsOn " + _name + " targetNameSpace " + Namespace);
  2688.                 if (_dependsOnSchemaNS.Count > 0) {
  2689.                     for (int i = 0; i < _dependsOnSchemaNS.Count; i++) {
  2690.                         XMLNamespace xns = (XMLNamespace)_dependsOnSchemaNS[i];
  2691.                         if (!usedNames.ContainsKey(xns.Prefix)) {
  2692.                             usedNames[xns.Prefix] = null;
  2693.                             sb.Length = 0;
  2694.                             sb.Append(indent);
  2695.                             sb.Append("xmlns:");
  2696.                             sb.Append(xns.Prefix);
  2697.                             sb.Append("='");
  2698.                             sb.Append(xns.Namespace);
  2699.                             sb.Append("'");
  2700.                             textWriter.WriteLine(sb);
  2701.                         }
  2702.                     }
  2703.                 }
  2704.             }
  2705.            
  2706.             internal void PrintSchemaWsdl(TextWriter textWriter, StringBuilder sb, string indent)
  2707.             {
  2708.                 Util.Log("XMLNamespace.PrintSchemaWsdl " + Namespace + " _realSchemaTypes.Count " + _realSchemaTypes.Count);
  2709.                 // Print schema types
  2710.                
  2711.                 bool bReal = false;
  2712.                
  2713.                 /*
  2714.                 for(int i=0;i<_realSchemaTypes.Count;i++)
  2715.                 {
  2716.                     RealSchemaType rsType = (RealSchemaType) _realSchemaTypes[i];
  2717.                     if(!rsType.Type.IsInterface && !rsType.IsSUDSType)
  2718.                         bReal = true;
  2719.                 }
  2720.                 */               
  2721.                
  2722. if ((_simpleSchemaTypes.Count > 0) || (_realSchemaTypes.Count > 0) || (_arraySchemaTypes.Count > 0)) {
  2723.                     bReal = true;
  2724.                 }
  2725.                
  2726.                 // Print schema types
  2727.                 if (bReal) {
  2728.                     // schema begin
  2729.                     string indent1 = IndentP(indent);
  2730.                     string indent2 = IndentP(indent1);
  2731.                     string indent3 = IndentP(indent2);
  2732.                     string indent4 = IndentP(indent3);
  2733.                     sb.Length = 0;
  2734.                     sb.Append(indent);
  2735.                     sb.Append("<schema ");
  2736.                     sb.Append("targetNamespace='");
  2737.                     sb.Append(Namespace);
  2738.                     sb.Append("'");
  2739.                     textWriter.WriteLine(sb);
  2740.                    
  2741.                     sb.Length = 0;
  2742.                     sb.Append(indent2);
  2743.                     sb.Append("xmlns='");
  2744.                     sb.Append(SudsConverter.GetXsdVersion(_generator._xsdVersion));
  2745.                     sb.Append("'");
  2746.                     textWriter.WriteLine(sb);
  2747.                    
  2748.                     sb.Length = 0;
  2749.                     sb.Append(indent2);
  2750.                     sb.Append("elementFormDefault='unqualified' attributeFormDefault='unqualified'>");
  2751.                     textWriter.WriteLine(sb);
  2752.                    
  2753.                     // Write import statements
  2754.                     foreach (XMLNamespace xns in _xnsImports) {
  2755.                         sb.Length = 0;
  2756.                         sb.Append(indent1);
  2757.                         sb.Append("<import namespace='");
  2758.                         sb.Append(xns.Namespace);
  2759.                         sb.Append("'/>");
  2760.                         textWriter.WriteLine(sb);
  2761.                     }
  2762.                    
  2763.                    
  2764.                     for (int i = 0; i < _simpleSchemaTypes.Count; i++) {
  2765.                         SimpleSchemaType ssType = (SimpleSchemaType)_simpleSchemaTypes[i];
  2766.                         ssType.PrintSchemaType(textWriter, sb, indent1, false);
  2767.                     }
  2768.                    
  2769.                     for (int i = 0; i < _realSchemaTypes.Count; i++) {
  2770.                         RealSchemaType rsType = (RealSchemaType)_realSchemaTypes[i];
  2771.                         if (!rsType.Type.IsInterface && !rsType.IsSUDSType)
  2772.                             rsType.PrintSchemaType(textWriter, sb, indent1, false);
  2773.                     }
  2774.                    
  2775.                     for (int i = 0; i < _arraySchemaTypes.Count; i++) {
  2776.                         ArraySchemaType asType = (ArraySchemaType)_arraySchemaTypes[i];
  2777.                         asType.PrintSchemaType(textWriter, sb, indent1, false);
  2778.                     }
  2779.                    
  2780.                    
  2781.                     /*
  2782.                     for(int i=0;i<_phonySchemaTypes.Count;i++)
  2783.                     {
  2784.                         PhonySchemaType psType = (PhonySchemaType) _phonySchemaTypes[i];
  2785.                         psType.PrintSchemaType(textWriter, sb, indent1, true);
  2786.                     }
  2787.                     */                   
  2788.                    
  2789. sb.Length = 0;
  2790.                     sb.Append(indent);
  2791.                     sb.Append("</schema>");
  2792.                     textWriter.WriteLine(sb);
  2793.                    
  2794.                    
  2795.                 }
  2796.             }
  2797.            
  2798.             internal void PrintMessageWsdl(TextWriter textWriter, StringBuilder sb, string indent, ArrayList refNames)
  2799.             {
  2800.                 Util.Log("XmlNamespace.PrintMessageWsdl");
  2801.                 for (int i = 0; i < _realSUDSTypes.Count; i++)
  2802.                     ((RealSchemaType)_realSUDSTypes[i]).PrintMessageWsdl(textWriter, sb, indent, refNames);
  2803.                
  2804.                 if (_realSUDSTypes.Count == 0 && _realSchemaTypes.Count > 0) {
  2805.                     // If no suds type, we still generate a binding section to print the Suds Extendsions
  2806.                     // We only need to do this once, because all the realschema types will be placed into
  2807.                     // one binding
  2808.                     ((RealSchemaType)_realSchemaTypes[0]).PrintMessageWsdl(textWriter, sb, indent, new ArrayList());
  2809.                 }
  2810.             }
  2811.            
  2812.             // Fields
  2813.             private string _name;
  2814.             private Assembly _assem;
  2815.             private string _namespace;
  2816.             private string _prefix;
  2817.             internal bool _bUnique;
  2818.             private ArrayList _dependsOnSUDSNS;
  2819.             private ArrayList _realSUDSTypes;
  2820.             private ArrayList _dependsOnSchemaNS;
  2821.             internal ArrayList _realSchemaTypes;
  2822.             private ArrayList _phonySchemaTypes;
  2823.             private ArrayList _simpleSchemaTypes;
  2824.             private ArrayList _arraySchemaTypes;
  2825.             private bool _bInteropType;
  2826.             private string _serviceEndpoint;
  2827.             private Hashtable _typeToServiceEndpoint;
  2828.             private WsdlGenerator _generator;
  2829.             private ArrayList _xnsImports;
  2830.             private bool _bClassesPrinted = false;
  2831.             //private Hashtable _typeToSchemaType = new Hashtable();
  2832.             //private Hashtable _schemaTypeToType = new Hashtable();
  2833.            
  2834.            
  2835.         }
  2836.        
  2837.         static internal string IndentP(string indentStr)
  2838.         {
  2839.             return indentStr + " ";
  2840.         }
  2841.        
  2842.     }
  2843. }

Developer Fusion