WsdlWriter.cs

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("&");
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("&", "&");
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.             }
804.             internal void Add(Restriction restriction)
805.             {
806.                 _restriction = restriction;
807.             }
809.             public void Print(TextWriter textWriter, StringBuilder sb, String indent)
810.             {
811.                 Util.Log("EnumElement.Print");
812.                 sb.Length = 0;
813.                 sb.Append(indent);
814.                 sb.Append("<enumeration value='");
815.                 sb.Append(_value);
816.                 sb.Append("'/>");
817.                 textWriter.WriteLine(sb);
818.                 return;
819.             }
821.             Restriction _restriction;
822.         }
823.         */        
824.         
825.         
826.         private class Restriction : Particle
827.         {
828.             internal enum RestrictionType
829.             {
830.                 None = 0,
831.                 Array = 1,
832.                 Enum = 2
833.             }
834.             
835.             internal Restriction()
836.             {
837.                 Util.Log("Restriction.Restriction ");
838.             }
839.             
840.             internal Restriction(string baseName, XMLNamespace baseNS)
841.             {
842.                 Util.Log("Restriction.Restriction " + baseName + " " + baseNS.Namespace);
843.                 _baseName = baseName;
844.                 _baseNS = baseNS;
845.             }
846.             
847.             internal void AddArray(SchemaAttribute attribute)
848.             {
849.                 Util.Log("Restriction.AddArray ");
850.                 _rtype = RestrictionType.Array;
851.                 _attribute = attribute;
852.             }
853.             
854.             public override string Name()
855.             {
856.                 return _baseName;
857.             }
858.             
859.             public override void Print(TextWriter textWriter, StringBuilder sb, string indent)
860.             {
861.                 Util.Log("Restriction.Print " + _baseName);
862.                 string indent1 = IndentP(indent);
863.                 sb.Length = 0;
864.                 sb.Append(indent);
865.                 if (_rtype == RestrictionType.Array)
866.                     sb.Append("<restriction base='soapenc:Array'>");
867.                 else if (_rtype == RestrictionType.Enum) {
868.                     sb.Append("<restriction base='xsd:string'>");
869.                 }
870.                 else {
871.                     sb.Append("<restriction base='");
872.                     sb.Append(_baseNS.Prefix);
873.                     sb.Append(':');
874.                     sb.Append(_baseName);
875.                     sb.Append("'>");
876.                 }
877.                 textWriter.WriteLine(sb);
878.                 foreach (IAbstractElement elem in _abstractElms)
879.                     elem.Print(textWriter, sb, IndentP(indent1));
880.                 
881.                 if (_attribute != null)
882.                     _attribute.Print(textWriter, sb, IndentP(indent1));
883.                 sb.Length = 0;
884.                 sb.Append(indent);
885.                 sb.Append("</restriction>");
886.                 textWriter.WriteLine(sb);
887.             }
888.             
889.             string _baseName;
890.             XMLNamespace _baseNS;
891.             internal RestrictionType _rtype;
892.             SchemaAttribute _attribute;
893.             internal ArrayList _abstractElms = new ArrayList();
894.         }
895.         
896.         private class SchemaAttribute : IAbstractElement
897.         {
898.             internal SchemaAttribute()
899.             {
900.                 Util.Log("SchemaAttribute ");
901.             }
902.             
903.             internal void AddArray(string wireQname)
904.             {
905.                 Util.Log("SchemaAttribute wireQname " + wireQname);
906.                 _wireQname = wireQname;
907.             }
908.             
909.             public void Print(TextWriter textWriter, StringBuilder sb, string indent)
910.             {
911.                 sb.Length = 0;
912.                 sb.Append(indent);
913.                 sb.Append("<attribute ref='soapenc:arrayType'");
914.                 sb.Append(" wsdl:arrayType ='");
915.                 sb.Append(_wireQname);
916.                 sb.Append("'/>");
917.                 textWriter.WriteLine(sb);
918.                 return;
919.             }
920.             
921.             // Fields
922.             private string _wireQname;
923.             
924.         }
925.         
926.         private abstract class Particle : IAbstractElement
927.         {
928.             protected Particle()
929.             {
930.             }
931.             public abstract string Name();
932.             public abstract void Print(TextWriter textWriter, StringBuilder sb, string indent);
933.         }
934.         
935.         private class SchemaElement : Particle
936.         {
937.             internal SchemaElement(string name, Type type, bool bEmbedded, XMLNamespace xns) : base()
938.             {
939.                 Util.Log("SchemaElement.SchemaElement Particle " + name + " type " + type + " bEmbedded " + bEmbedded);
940.                 _name = name;
941.                 _typeString = null;
942.                 _schemaType = SimpleSchemaType.GetSimpleSchemaType(type, xns, true);
943.                 _typeString = RealSchemaType.TypeName(type, bEmbedded, xns);
944.             }
945.             
946.             public override string Name()
947.             {
948.                 return _name;
949.             }
950.             
951.             public override void Print(TextWriter textWriter, StringBuilder sb, string indent)
952.             {
953.                 Util.Log("SchemaElement.Print " + _name + " _schemaType " + _schemaType + " _typeString " + _typeString);
954.                 string indent1 = IndentP(indent);
955.                 sb.Length = 0;
956.                 sb.Append(indent);
957.                 sb.Append("<element name='");
958.                 sb.Append(_name);
959.                 if (_schemaType != null && !(_schemaType is SimpleSchemaType && ((SimpleSchemaType)_schemaType).Type.IsEnum)) {
960.                     sb.Append("'>");
961.                     textWriter.WriteLine(sb);
962.                     _schemaType.PrintSchemaType(textWriter, sb, IndentP(indent1), true);
963.                     
964.                     sb.Length = 0;
965.                     sb.Append(indent);
966.                     sb.Append("</element>");
967.                 }
968.                 else {
969.                     if (_typeString != null) {
970.                         sb.Append("' type='");
971.                         sb.Append(_typeString);
972.                         sb.Append('/'');
973.                     }
974.                     sb.Append("/>");
975.                 }
976.                 textWriter.WriteLine(sb);
977.                 
978.                 return;
979.             }
980.             
981.             // Fields
982.             private string _name;
983.             private string _typeString;
984.             private SchemaType _schemaType;
985.         }
986.         
987.         private abstract class SchemaType
988.         {
989.             internal abstract void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous);
990.         }
991.         
992.         private class SimpleSchemaType : SchemaType
993.         {
994.             private SimpleSchemaType(Type type, XMLNamespace xns)
995.             {
996.                 Util.Log("SimpleSchemaType.SimpleSchemaType " + type + " xns " + ((xns != null) ? xns.Name : "Null"));
997.                 _type = type;
998.                 _xns = xns;
999.                 _abstractElms = new ArrayList();
1000.                 
1001.                 _fullRefName = WsdlGenerator.RefName(type);
1002.             }
1003.             
1004.             internal Type Type {
1005.                 get { return (_type); }
1006.             }
1007.             
1008.             internal string FullRefName {
1009.                 get { return _fullRefName; }
1010.             }
1011.             
1012.             internal string BaseName {
1013.                 get { return (_baseName); }
1014.             }
1015.             
1016.             internal override void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous)
1017.             {
1018.                 Util.Log("SimpleSchemaType.PrintSchemaType _type.Name " + _type.Name);
1019.                 sb.Length = 0;
1020.                 sb.Append(indent);
1021.                 if (bAnonymous == false) {
1022.                     sb.Append("<simpleType name='");
1023.                     sb.Append(FullRefName);
1024.                     sb.Append("'");
1025.                     if (BaseName != null) {
1026.                         sb.Append(" base='");
1027.                         sb.Append(BaseName);
1028.                         sb.Append("'");
1029.                     }
1030.                     
1031.                     if (_restriction._rtype == Restriction.RestrictionType.Enum) {
1032.                         sb.Append(" suds:enumType='");
1033.                         sb.Append(_restriction.Name());
1034.                         sb.Append("'");
1035.                     }
1036.                 }
1037.                 else {
1038.                     if (BaseName != null) {
1039.                         sb.Append("<simpleType base='");
1040.                         sb.Append(BaseName);
1041.                         sb.Append("'");
1042.                     }
1043.                     else
1044.                         sb.Append("<simpleType");
1045.                 }
1046.                 
1047.                 bool bEmpty = (_abstractElms.Count == 0 && _restriction == null);
1048.                 if (bEmpty)
1049.                     sb.Append("/>");
1050.                 else
1051.                     sb.Append(">");
1052.                 textWriter.WriteLine(sb);
1053.                 if (bEmpty)
1054.                     return;
1055.                 
1056.                 if (_abstractElms.Count > 0) {
1057.                     for (int i = 0; i < _abstractElms.Count; i++)
1058.                         ((IAbstractElement)_abstractElms[i]).Print(textWriter, sb, IndentP(indent));
1059.                 }
1060.                 
1061.                 if (_restriction != null)
1062.                     _restriction.Print(textWriter, sb, IndentP(indent));
1063.                 
1064.                 textWriter.Write(indent);
1065.                 textWriter.WriteLine("</simpleType>");
1066.                 
1067.                 return;
1068.             }
1069.             
1070.             
1071.             static internal SimpleSchemaType GetSimpleSchemaType(Type type, XMLNamespace xns, bool fInline)
1072.             {
1073.                 Util.Log("SimpleSchemaType.GetSimpleSchemaType " + type + " xns " + xns.Name);
1074.                 
1075.                 SimpleSchemaType ssType = null;
1076.                 if (type.IsEnum) {
1077.                     ssType = new SimpleSchemaType(type, xns);
1078.                     string baseName = RealSchemaType.TypeName(Enum.GetUnderlyingType(type), true, xns);
1079.                     ssType._restriction = new Restriction(baseName, xns);
1080.                     string[] values = Enum.GetNames(type);
1081.                     for (int i = 0; i < values.Length; i++)
1082.                         ssType._restriction._abstractElms.Add(new EnumElement(values[i]));
1083.                     ssType._restriction._rtype = Restriction.RestrictionType.Enum;
1084.                 }
1085.                 else {
1086.                 }
1087.                 return (ssType);
1088.             }
1089.             
1090.             
1091.             private Type _type;
1092.             internal string _baseName = null;
1093.             //get rid of warning, not used for now
1094.             private XMLNamespace _xns;
1095.             internal Restriction _restriction;
1096.             private string _fullRefName;
1097.             private ArrayList _abstractElms = new ArrayList();
1098.         }
1099.         
1100.         
1101.         private abstract class ComplexSchemaType : SchemaType
1102.         {
1103.             internal ComplexSchemaType(string name, bool bSealed)
1104.             {
1105.                 _name = name;
1106.                 _fullRefName = _name;
1107.                 _blockType = SchemaBlockType.ALL;
1108.                 _baseName = null;
1109.                 _elementName = name;
1110.                 _bSealed = bSealed;
1111.                 _particles = new ArrayList();
1112.                 _abstractElms = new ArrayList();
1113.             }
1114.             
1115.             internal ComplexSchemaType(string name, SchemaBlockType blockType, bool bSealed)
1116.             {
1117.                 _name = name;
1118.                 _fullRefName = _name;
1119.                 _blockType = blockType;
1120.                 _baseName = null;
1121.                 _elementName = name;
1122.                 _bSealed = bSealed;
1123.                 _particles = new ArrayList();
1124.                 _abstractElms = new ArrayList();
1125.             }
1126.             
1127.             internal ComplexSchemaType(Type type)
1128.             {
1129.                 Util.Log("ComplexSchemaType.ComplexSchemaType " + type);
1130.                 _blockType = SchemaBlockType.ALL;
1131.                 _type = type;
1132.                 Init();
1133.             }
1134.             
1135.             private void Init()
1136.             {
1137.                 _name = _type.Name;
1138.                 _bSealed = _type.IsSealed;
1139.                 _baseName = null;
1140.                 _elementName = _name;
1141.                 _particles = new ArrayList();
1142.                 _abstractElms = new ArrayList();
1143.                 _fullRefName = WsdlGenerator.RefName(_type);
1144.             }
1145.             
1146.             internal string Name {
1147.                 get { return (_name); }
1148.             }
1149.             
1150.             internal string FullRefName {
1151.                 get { return (_fullRefName); }
1152.             }
1153.             
1154.             protected string BaseName {
1155.                 get { return (_baseName); }
1156.                 set { _baseName = value; }
1157.             }
1158.             
1159.             internal string ElementName {
1160.                 get { return (_elementName); }
1161.                 set { _elementName = value; }
1162.             }
1163.             
1164.             
1165.             protected bool IsSealed {
1166.                 get { return (_bSealed); }
1167.             }
1168.             
1169.             protected bool IsEmpty {
1170.                 get { return ((_abstractElms.Count == 0) && (_particles.Count == 0)); }
1171.             }
1172.             
1173.             internal void AddParticle(Particle particle)
1174.             {
1175.                 Util.Log("ComplexSchemaType.AddParticle " + particle.Name());
1176.                 _particles.Add(particle);
1177.             }
1178.             
1179.             protected void PrintBody(TextWriter textWriter, StringBuilder sb, string indent)
1180.             {
1181.                 Util.Log("ComplexSchemaType.PrintBody " + _name);
1182.                 int particleCount = _particles.Count;
1183.                 string indent1 = IndentP(indent);
1184.                 string indent2 = IndentP(indent1);
1185.                 if (particleCount > 0) {
1186.                         /*(particleCount > 1) && */                    bool bPrintBlockElms = (WsdlGenerator.blockDefault != _blockType);
1187.                     if (bPrintBlockElms) {
1188.                         sb.Length = 0;
1189.                         sb.Append(indent1);
1190.                         sb.Append(schemaBlockBegin[(int)_blockType]);
1191.                         textWriter.WriteLine(sb);
1192.                     }
1193.                     
1194.                     for (int i = 0; i < particleCount; i++)
1195.                         ((Particle)_particles[i]).Print(textWriter, sb, IndentP(indent2));
1196.                     
1197.                     if (bPrintBlockElms) {
1198.                         sb.Length = 0;
1199.                         sb.Append(indent1);
1200.                         sb.Append(schemaBlockEnd[(int)_blockType]);
1201.                         textWriter.WriteLine(sb);
1202.                     }
1203.                 }
1204.                 
1205.                 int abstractElmCount = _abstractElms.Count;
1206.                 for (int i = 0; i < abstractElmCount; i++)
1207.                     ((IAbstractElement)_abstractElms[i]).Print(textWriter, sb, IndentP(indent));
1208.                 
1209.                 return;
1210.             }
1211.             
1212.             private string _name;
1213.             private Type _type;
1214.             private string _fullRefName;
1215.             private string _baseName;
1216.             private string _elementName;
1217.             private bool _bSealed;
1218.             private SchemaBlockType _blockType;
1219.             private ArrayList _particles;
1220.             private ArrayList _abstractElms;
1221.             
1222.             private static string[] schemaBlockBegin = {"<all>", "<sequence>", "<choice>", "<complexContent>"};
1223.             private static string[] schemaBlockEnd = {"</all>", "</sequence>", "</choice>", "</complexContent>"};
1224.         }
1225.         
1226.         private class PhonySchemaType : ComplexSchemaType
1227.         {
1228.             internal PhonySchemaType(string name) : base(name, true)
1229.             {
1230.                 Util.Log("PhonySchemaType.PhonySchemaType " + name);
1231.                 _numOverloadedTypes = 0;
1232.             }
1233.             
1234.             internal int OverloadedType()
1235.             {
1236.                 Util.Log("PhonySchemaType.OverLoadedTypeType");
1237.                 return (++_numOverloadedTypes);
1238.             }
1239.             
1240.             internal override void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous)
1241.             {
1242.                 Util.Log("PhonySchemaType.PrintSchemaType");
1243.                 Debug.Assert(bAnonymous == true, "PhonySchemaType should always be printed as anonymous types");
1244.                 
1245.                 // Wsdl Phony is not printed, instead the message section contains the parameters.
1246.                 return;
1247.             }
1248.             private int _numOverloadedTypes;
1249.             internal ArrayList _inParamTypes;
1250.             internal ArrayList _inParamNames;
1251.             internal ArrayList _outParamTypes;
1252.             internal ArrayList _outParamNames;
1253.             internal ArrayList _paramNamesOrder;
1254.             internal string _returnType;
1255.             internal string _returnName;
1256.         }
1257.         
1258.         private class ArraySchemaType : ComplexSchemaType
1259.         {
1260.             internal ArraySchemaType(Type type, string name, SchemaBlockType blockType, bool bSealed) : base(name, blockType, bSealed)
1261.             {
1262.                 Util.Log("ArraySchemaType.ArrayComplexSchemaType");
1263.                 _type = type;
1264.             }
1265.             
1266.             internal Type Type {
1267.                 get { return _type; }
1268.             }
1269.             
1270.             
1271.             internal override void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous)
1272.             {
1273.                 Util.Log("ArrayType.PrintSchemaType");
1274.                 string indent1 = IndentP(indent);
1275.                 sb.Length = 0;
1276.                 sb.Append(indent);
1277.                 sb.Append("<complexType name='");
1278.                 sb.Append(FullRefName);
1279.                 sb.Append("'>");
1280.                 textWriter.WriteLine(sb);
1281.                 PrintBody(textWriter, sb, indent1);
1282.                 sb.Length = 0;
1283.                 sb.Append(indent);
1284.                 sb.Append("</complexType>");
1285.                 textWriter.WriteLine(sb);
1286.                 
1287.                 return;
1288.             }
1289.             
1290.             private Type _type;
1291.         }
1292.         
1293.         private class RealSchemaType : ComplexSchemaType
1294.         {
1295.             internal RealSchemaType(Type type, XMLNamespace xns, string serviceEndpoint, Hashtable typeToServiceEndpoint, bool bUnique, WsdlGenerator WsdlGenerator) : base(type)
1296.             {
1297.                 Util.Log("RealSchemaType.RealSchemaType " + type + " xns " + xns.Name + " serviceEndpoint " + serviceEndpoint + " bUnique " + bUnique);
1298.                 _type = type;
1299.                 _serviceEndpoint = serviceEndpoint;
1300.                 _typeToServiceEndpoint = typeToServiceEndpoint;
1301.                 _bUnique = bUnique;
1302.                 _WsdlGenerator = WsdlGenerator;
1303.                 _bStruct = type.IsValueType;
1304.                 _xns = xns;
1305.                 _implIFaces = null;
1306.                 _iFaces = null;
1307.                 _methods = null;
1308.                 _fields = null;
1309.                 _methodTypes = null;
1310.                 
1311.                 _nestedTypes = type.GetNestedTypes();
1312.                 if (_nestedTypes != null) {
1313.                     foreach (Type ntype in _nestedTypes) {
1314.                         Util.Log("RealSchemaType.RealSchemaType nested classes" + ntype);
1315.                         _WsdlGenerator.AddType(ntype, xns);
1316.                     }
1317.                 }
1318.             }
1319.             
1320.             internal Type Type {
1321.                 get { return (_type); }
1322.             }
1323.             
1324.             internal XMLNamespace XNS {
1325.                 get { return (_xns); }
1326.             }
1327.             
1328.             internal bool IsUnique {
1329.                 get { return (_bUnique); }
1330.             }
1331.             
1332.             internal bool IsSUDSType {
1333. /*
1334.                 get{ return((_fields == null) &
1335.                             ((_iFaces.Length > 0) || (_methods.Length > 0) ||
1336.                             (_type.IsInterface) || (s_delegateType.IsAssignableFrom(_type))));}
1337.                             */                
1338.                 get { return ((_iFaces != null && _iFaces.Length > 0) || (_methods != null && _methods.Length > 0) || (_type != null && _type.IsInterface) || (s_delegateType != null && s_delegateType.IsAssignableFrom(_type))); }
1339.             }
1340.             
1341.             internal Type[] GetIntroducedInterfaces()
1342.             {
1343.                 Util.Log("RealSchemaType.GetIntroducedInterfaces");
1344.                 Debug.Assert(_iFaces == null, "variable set");
1345.                 _iFaces = GetIntroducedInterfaces(_type);
1346.                 return (_iFaces);
1347.             }
1348.             
1349.             internal MethodInfo[] GetIntroducedMethods()
1350.             {
1351.                 Util.Log("RealSchemaType.GetIntroducedMethods");
1352.                 Debug.Assert(_methods == null, "variable set");
1353.                 _methods = GetIntroducedMethods(_type, ref _methodAttributes);
1354.                 _methodTypes = new string[2 * _methods.Length];
1355.                 return (_methods);
1356.             }
1357.             
1358.             internal FieldInfo[] GetInstanceFields()
1359.             {
1360.                 Util.Log("RealSchemaType.GetInstanceFields");
1361.                 Debug.Assert(_fields == null, "variable set");
1362.                 //Debug.Assert(!WsdlGenerator.s_marshalByRefType.IsAssignableFrom(_type), "Invalid Type");
1363.                 _fields = GetInstanceFields(_type);
1364.                 return (_fields);
1365.             }
1366.             
1367.             private bool IsNotSystemDefinedRoot(Type type, Type baseType)
1368.             {
1369.                 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")
1370.                     return true;
1371.                 else
1372.                     return false;
1373.             }
1374.             
1375.             internal void Resolve(StringBuilder sb)
1376.             {
1377.                 Util.Log("RealSchemaType.Resolve " + _type);
1378.                 sb.Length = 0;
1379.                 
1380.                 // Check if this is a suds type
1381.                 bool bSUDSType = IsSUDSType;
1382.                 
1383.                 
1384.                 // Resolve base type eliminating system defined roots of the class heirarchy
1385.                 
1386.                 Type baseType = _type.BaseType;
1387.                 if (IsNotSystemDefinedRoot(_type, baseType)) {
1388.                     Util.Log("RealSchemaType.Resolve Not System Defined root " + baseType);
1389.                     XMLNamespace xns = _WsdlGenerator.GetNamespace(baseType);
1390.                     Debug.Assert(xns != null, "Namespace should have been found");
1391.                     sb.Append(xns.Prefix);
1392.                     sb.Append(':');
1393.                     sb.Append(baseType.Name);
1394.                     BaseName = sb.ToString();
1395.                     if (bSUDSType)
1396.                         _xns.DependsOnSUDSNS(xns);
1397.                     Type ltype = _type;
1398.                     Type lbaseType = ltype.BaseType;
1399.                     while (lbaseType != null && IsNotSystemDefinedRoot(ltype, lbaseType)) {
1400.                         if (_typeToServiceEndpoint != null && !_typeToServiceEndpoint.ContainsKey(lbaseType.Name) && _typeToServiceEndpoint.ContainsKey(ltype.Name)) {
1401.                             // type contains endpoints, but baseType doesn't, so assign the type's endpoints to the baseType.
1402.                             // This is needed when a child has endpoints but the parent doesn't. A cast to the parent won't 
1403.                             // find the object's endpoint
1404.                             _typeToServiceEndpoint[lbaseType.Name] = _typeToServiceEndpoint[ltype.Name];
1405.                         }
1406.                         ltype = lbaseType;
1407.                         lbaseType = ltype.BaseType;
1408.                     }
1409.                     
1410.                     Util.Log("RealSchemaType.Resolve Not System Defined root BaseName " + BaseName);
1411.                 }
1412.                 
1413.                 // The element definition of this type depends on itself
1414.                 _xns.DependsOnSchemaNS(_xns, false);
1415.                 
1416.                 if (bSUDSType) {
1417.                     Util.Log("RealSchemaType.Resolve AddRealSUDSType " + _type);
1418.                     _xns.AddRealSUDSType(this);
1419.                     
1420.                     // Resolve interfaces introduced by this type
1421.                     if (_iFaces.Length > 0) {
1422.                         _implIFaces = new string[_iFaces.Length];
1423.                         for (int i = 0; i < _iFaces.Length; i++) {
1424.                             string ns;
1425.                             Assembly assem;
1426.                             Util.Log("RealSchemaType.Resolve iFace " + _iFaces[i].Name);
1427.                             bool bInteropType = WsdlGenerator.GetNSAndAssembly(_iFaces[i], out ns, out assem);
1428.                             XMLNamespace xns = _xns.LookupSchemaNamespace(ns, assem);
1429.                             Debug.Assert(xns != null, "SchemaType should have been found");
1430.                             sb.Length = 0;
1431.                             sb.Append(xns.Prefix);
1432.                             sb.Append(':');
1433.                             sb.Append(_iFaces[i].Name);
1434.                             _implIFaces[i] = sb.ToString();
1435.                             _xns.DependsOnSUDSNS(xns);
1436.                         }
1437.                     }
1438.                     
1439.                     // Resolve methods introduced by this type
1440.                     if (_methods.Length > 0) {
1441.                         string useNS = null;
1442.                         if (_xns.IsInteropType)
1443.                             useNS = _xns.Name;
1444.                         else {
1445.                             sb.Length = 0;
1446.                             WsdlGenerator.QualifyName(sb, _xns.Name, Name);
1447.                             useNS = sb.ToString();
1448.                         }
1449.                         XMLNamespace methodXNS = _xns.LookupSchemaNamespace(useNS, _xns.Assem);
1450.                         Debug.Assert(methodXNS != null, "Namespace is null");
1451.                         _xns.DependsOnSUDSNS(methodXNS);
1452.                         _phony = new PhonySchemaType[_methods.Length];
1453.                         for (int i = 0; i < _methods.Length; i++) {
1454.                             // Process the request
1455.                             MethodInfo method = _methods[i];
1456.                             string methodRequestName = method.Name;
1457.                             
1458.                             ParameterInfo[] parameters = method.GetParameters();
1459.                             PhonySchemaType methodRequest = new PhonySchemaType(methodRequestName);
1460.                             
1461.                             // Wsdl 
1462.                             Util.Log("RealSchemaType.Resolve Wsdl " + methodRequestName);
1463.                             methodRequest._inParamTypes = new ArrayList(10);
1464.                             methodRequest._inParamNames = new ArrayList(10);
1465.                             methodRequest._outParamTypes = new ArrayList(10);
1466.                             methodRequest._outParamNames = new ArrayList(10);
1467.                             methodRequest._paramNamesOrder = new ArrayList(10);
1468.                             
1469.                             int paramNameCnt = 0;
1470.                             foreach (ParameterInfo param in parameters) {
1471.                                 bool bmarshalIn = false;
1472.                                 bool bmarshalOut = false;
1473.                                 methodRequest._paramNamesOrder.Add(param.Name);
1474.                                 ParamInOut(param, out bmarshalIn, out bmarshalOut);
1475.                                 
1476.                                 Type type = param.ParameterType;
1477.                                 string paramName = param.Name;
1478.                                 if (paramName == null || paramName.Length == 0)
1479.                                     paramName = "param" + paramNameCnt++;
1480.                                 
1481.                                 // Find the Wsdl type name
1482.                                 
1483.                                 string stringType = TypeName(type, true, methodXNS);
1484.                                 // add to the method parameters
1485.                                 if (bmarshalIn) {
1486.                                     methodRequest._inParamNames.Add(paramName);
1487.                                     methodRequest._inParamTypes.Add(stringType);
1488.                                 }
1489.                                 
1490.                                 if (bmarshalOut) {
1491.                                     methodRequest._outParamNames.Add(paramName);
1492.                                     methodRequest._outParamTypes.Add(stringType);
1493.                                 }
1494.                             }
1495.                             
1496.                             
1497.                             methodXNS.AddPhonySchemaType(methodRequest);
1498.                             _phony[i] = methodRequest;
1499.                             _methodTypes[2 * i] = methodRequest.ElementName;
1500.                             
1501.                             if (!RemotingServices.IsOneWay(method)) {
1502.                                 // Process response (look at custom attributes to get values
1503.                                 
1504.                                 string returnName = null;
1505.                                 SoapMethodAttribute soapAttribute = (SoapMethodAttribute)InternalRemotingServices.GetCachedSoapAttribute(method);
1506.                                 if (soapAttribute.ReturnXmlElementName != null)
1507.                                     returnName = soapAttribute.ReturnXmlElementName;
1508.                                 else
1509.                                     returnName = "return";
1510.                                 
1511.                                 string responseName = null;
1512.                                 if (soapAttribute.ResponseXmlElementName != null)
1513.                                     responseName = soapAttribute.ResponseXmlElementName;
1514.                                 else
1515.                                     responseName = methodRequestName + "Response";
1516.                                 
1517.                                 PhonySchemaType methodResponse = new PhonySchemaType(responseName);
1518.                                 
1519.                                 //Wsdl type
1520.                                 // out paramters alread processed above.
1521.                                 // return name stored in methodRequest PhonySchemaType
1522.                                 methodRequest._returnName = returnName;
1523.                                 Type returnType = method.ReturnType;
1524.                                 
1525.                                 if (!((returnType == null) || (returnType == typeof(void)))) {
1526.                                     methodRequest._returnType = TypeName(returnType, true, methodXNS);
1527.                                 }
1528.                                 methodXNS.AddPhonySchemaType(methodResponse);
1529.                                 _methodTypes[2 * i + 1] = methodResponse.ElementName;
1530.                             }
1531.                         }
1532.                     }
1533.                 }
1534.                 
1535.                 // Resolve fields
1536.                 if (_fields != null) {
1537.                     for (int i = 0; i < _fields.Length; i++) {
1538.                         FieldInfo field = _fields[i];
1539.                         Debug.Assert(!field.IsStatic, "Static field");
1540.                         Type fieldType = field.FieldType;
1541.                         if (fieldType == null)
1542.                             fieldType = typeof(object);
1543.                         Util.Log("RealSchemaType.Resolve fields " + field.Name + " type " + fieldType);
1544.                         AddParticle(new SchemaElement(field.Name, fieldType, false, _xns));
1545.                     }
1546.                 }
1547.                 
1548.                 // Resolve attribute elements 
1549.                 return;
1550.             }
1551.             
1552.             private void ParamInOut(ParameterInfo param, out bool bMarshalIn, out bool bMarshalOut)
1553.             {
1554.                 bool bIsIn = param.IsIn;
1555.                 // [In]
1556.                 bool bIsOut = param.IsOut;
1557.                 // [Out] note: out int a === [Out] ref int b
1558.                 bool bIsByRef = param.ParameterType.IsByRef;
1559.                 // (ref or normal) 
1560.                 bMarshalIn = false;
1561.                 bMarshalOut = false;
1562.                 if (bIsByRef) {
1563.                     if (bIsIn == bIsOut) {
1564.                         // "ref int a" or "[In, Out] ref int a"
1565.                         bMarshalIn = true;
1566.                         bMarshalOut = true;
1567.                     }
1568.                     else {
1569.                         // "[In] ref int a" or "out int a"
1570.                         bMarshalIn = bIsIn;
1571.                         bMarshalOut = bIsOut;
1572.                     }
1573.                 }
1574.                 else {
1575.                     // "int a" or "[In, Out] a"
1576.                     bMarshalIn = true;
1577.                     bMarshalOut = bIsOut;
1578.                 }
1579.                 Util.Log("RealSchemaType.ParamInOut " + param.Name + " ref,in,out " + bIsByRef + "," + bIsIn + "," + bIsOut + " bMarshalIn,bMarshalOut " + bMarshalIn + "," + bMarshalOut);
1580.             }
1581.             
1582.             
1583.             internal override void PrintSchemaType(TextWriter textWriter, StringBuilder sb, string indent, bool bAnonymous)
1584.             {
1585.                 Util.Log("RealSchemaType.PrintSchemaType");
1586.                 if (bAnonymous == false) {
1587.                     sb.Length = 0;
1588.                     sb.Append(indent);
1589.                     sb.Append("<element name='");
1590.                     sb.Append(ElementName);
1591.                     sb.Append("' type='");
1592.                     sb.Append(_xns.Prefix);
1593.                     sb.Append(':');
1594.                     sb.Append(FullRefName);
1595.                     sb.Append("'/>");
1596.                     textWriter.WriteLine(sb);
1597.                 }
1598.                 
1599.                 sb.Length = 0;
1600.                 sb.Append(indent);
1601.                 if (bAnonymous == false) {
1602.                     sb.Append("<complexType name='");
1603.                     sb.Append(FullRefName);
1604.                     sb.Append('/'');
1605.                 }
1606.                 else {
1607.                     sb.Append("<complexType ");
1608.                 }
1609.                 if (BaseName != null) {
1610.                     sb.Append(" base='");
1611.                     sb.Append(BaseName);
1612.                     sb.Append('/'');
1613.                 }
1614.                 if ((IsSealed == true) && (bAnonymous == false))
1615.                     sb.Append(" final='#all'");
1616.                 bool bEmpty = IsEmpty;
1617.                 if (bEmpty)
1618.                     sb.Append("/>");
1619.                 else
1620.                     sb.Append('>');
1621.                 textWriter.WriteLine(sb);
1622.                 if (bEmpty)
1623.                     return;
1624.                 
1625.                 base.PrintBody(textWriter, sb, indent);
1626.                 
1627.                 textWriter.Write(indent);
1628.                 textWriter.WriteLine("</complexType>");
1629.                 
1630.                 return;
1631.             }
1632.             
1633.             
1634.             internal void PrintMessageWsdl(TextWriter textWriter, StringBuilder sb, string indent, ArrayList refNames)
1635.             {
1636.                 Util.Log("RealSchemaType.PrintMessageWsdl " + Name);
1637.                 
1638.                 string indent1 = IndentP(indent);
1639.                 string indent2 = IndentP(indent1);
1640.                 string indent3 = IndentP(indent2);
1641.                 string ns = null;
1642.                 string nsPrefix = null;
1643.                 MethodInfo method = null;
1644.                 string methodName = null;
1645.                 string overloadedName = null;
1646.                 bool bIsOneWay = false;
1647.                 
1648.                 string useNS = null;
1649.                 if (_xns.IsInteropType)
1650.                     useNS = _xns.Name;
1651.                 else {
1652.                     sb.Length = 0;
1653.                     
1654.                     WsdlGenerator.QualifyName(sb, _xns.Name, Name);
1655.                     useNS = sb.ToString();
1656.                 }
1657.                 XMLNamespace methodXns = _xns.LookupSchemaNamespace(useNS, _xns.Assem);
1658.                 
1659.                 //Debug.Assert(methodXns != null, "Namespace is null");
1660.                 
1661.                 int methodsLength = 0;
1662.                 if (_methods != null)
1663.                     methodsLength = _methods.Length;
1664.                 
1665.                 if (methodsLength > 0) {
1666.                     ns = methodXns.Namespace;
1667.                     nsPrefix = methodXns.Prefix;
1668.                 }
1669.                 
1670.                 refNames.Add(Name);
1671.                 
1672.                 for (int i = 0; i < methodsLength; i++) {
1673.                     method = _methods[i];
1674.                     bIsOneWay = RemotingServices.IsOneWay(method);
1675.                     methodName = PrintMethodName(method);
1676.                     sb.Length = 0;
1677.                     WsdlGenerator.QualifyName(sb, Name, _methodTypes[2 * i]);
1678.                     overloadedName = sb.ToString();
1679.                     
1680.                     // Message element
1681.                     sb.Length = 0;
1682.                     sb.Append("/n");
1683.                     sb.Append(indent);
1684.                     sb.Append("<message name='");
1685.                     sb.Append(overloadedName + "Input");
1686.                     sb.Append("'>");
1687.                     textWriter.WriteLine(sb);
1688.                     
1689.                     PhonySchemaType phony = _phony[i];
1690.                     
1691.                     
1692.                     if (phony._inParamTypes != null) {
1693.                         for (int iparam = 0; iparam < phony._inParamTypes.Count; iparam++) {
1694.                             sb.Length = 0;
1695.                             sb.Append(indent1);
1696.                             sb.Append("<part name='");
1697.                             sb.Append(phony._inParamNames[iparam]);
1698.                             sb.Append("' type='");
1699.                             sb.Append(phony._inParamTypes[iparam]);
1700.                             sb.Append("'/>");
1701.                             textWriter.WriteLine(sb);
1702.                         }
1703.                         
1704.                         sb.Length = 0;
1705.                         sb.Append(indent);
1706.                         sb.Append("</message>");
1707.                         textWriter.WriteLine(sb);
1708.                         
1709.                         if (!bIsOneWay) {
1710.                             sb.Length = 0;
1711.                             sb.Append(indent);
1712.                             sb.Append("<message name='");
1713.                             sb.Append(overloadedName + "Output");
1714.                             sb.Append("'>");
1715.                             textWriter.WriteLine(sb);
1716.                             
1717.                             if (phony._returnType != null || phony._outParamTypes != null) {
1718.                                 if (phony._returnType != null) {
1719.                                     sb.Length = 0;
1720.                                     sb.Append(indent1);
1721.                                     sb.Append("<part name='");
1722.                                     sb.Append(phony._returnName);
1723.                                     sb.Append("' type='");
1724.                                     sb.Append(phony._returnType);
1725.                                     sb.Append("'/>");
1726.                                     textWriter.WriteLine(sb);
1727.                                 }
1728.                                 
1729.                                 if (phony._outParamTypes != null) {
1730.                                     for (int iparam = 0; iparam < phony._outParamTypes.Count; iparam++) {
1731.                                         sb.Length = 0;
1732.                                         sb.Append(indent1);
1733.                                         sb.Append("<part name='");
1734.                                         sb.Append(phony._outParamNames[iparam]);
1735.                                         sb.Append("' type='");
1736.                                         sb.Append(phony._outParamTypes[iparam]);
1737.                                         sb.Append("'/>");
1738.                                         textWriter.WriteLine(sb);
1739.                                     }
1740.                                 }
1741.                             }
1742.                             
1743.                             sb.Length = 0;
1744.                             sb.Append(indent);
1745.                             sb.Append("</message>");
1746.                             textWriter.WriteLine(sb);
1747.                         }
1748.                     }
1749.                 }
1750.                 
1751.                 // PortType Element
1752.                 sb.Length = 0;
1753.                 sb.Append("/n");
1754.                 sb.Append(indent);
1755.                 sb.Append("<portType name='");
1756.                 sb.Append(Name);
1757.                 sb.Append("PortType");
1758.                 sb.Append("'>");
1759.                 textWriter.WriteLine(sb);
1760.                 
1761.                 for (int i = 0; i < methodsLength; i++) {
1762.                     method = _methods[i];
1763.                     PhonySchemaType phony = _phony[i];
1764.                     
1765.                     bIsOneWay = RemotingServices.IsOneWay(method);
1766.                     methodName = PrintMethodName(method);
1767.                     sb.Length = 0;
1768.                     sb.Append("tns:");
1769.                     WsdlGenerator.QualifyName(sb, Name, _methodTypes[2 * i]);
1770.                     overloadedName = sb.ToString();
1771.                     
1772.                     sb.Length = 0;
1773.                     sb.Append(indent1);
1774.                     sb.Append("<operation name='");
1775.                     sb.Append(methodName);
1776.                     sb.Append("'");
1777.                     if (phony != null && phony._paramNamesOrder.Count > 0) {
1778.                         
1779.                         sb.Append(" parameterOrder='");
1780.                         bool bfirst = true;
1781.                         foreach (string param in phony._paramNamesOrder) {
1782.                             if (!bfirst)
1783.                                 sb.Append(" ");
1784.                             sb.Append(param);
1785.                             bfirst = false;
1786.                         }
1787.                         sb.Append("'");
1788.                     }
1789.                     
1790.                     sb.Append(">");
1791.                     textWriter.WriteLine(sb);
1792.                     
1793.                     sb.Length = 0;
1794.                     sb.Append(indent2);
1795.                     sb.Append("<input name='");
1796.                     sb.Append(_methodTypes[2 * i]);
1797.                     sb.Append("Request' ");
1798.                     sb.Append("message='");
1799.                     sb.Append(overloadedName);
1800.                     sb.Append("Input");
1801.                     sb.Append("'/>");
1802.                     textWriter.WriteLine(sb);
1803.                     
1804.                     if (!bIsOneWay) {
1805.                         sb.Length = 0;
1806.                         sb.Append(indent2);
1807.                         sb.Append("<output name='");
1808.                         sb.Append(_methodTypes[2 * i]);
1809.                         sb.Append("Response' ");
1810.                         
1811.                         sb.Append("message='");
1812.                         sb.Append(overloadedName);
1813.                         sb.Append("Output");
1814.                         sb.Append("'/>");
1815.                         textWriter.WriteLine(sb);
1816.                     }
1817.                     
1818.                     sb.Length = 0;
1819.                     sb.Append(indent1);
1820.                     sb.Append("</operation>");
1821.                     textWriter.WriteLine(sb);
1822.                 }
1823.                 
1824.                 sb.Length = 0;
1825.                 sb.Append(indent);
1826.                 sb.Append("</portType>");
1827.                 textWriter.WriteLine(sb);
1828.                 
1829.                 
1830.                 // Binding 
1831.                 sb.Length = 0;
1832.                 sb.Append("/n");
1833.                 sb.Append(indent);
1834.                 sb.Append("<binding name='");
1835.                 sb.Append(Name);
1836.                 sb.Append("Binding");
1837.                 sb.Append("' ");
1838.                 sb.Append("type='tns:");
1839.                 sb.Append(Name);
1840.                 sb.Append("PortType");
1841.                 sb.Append("'>");
1842.                 textWriter.WriteLine(sb);
1843.                 
1844.                 sb.Length = 0;
1845.                 sb.Append(indent1);
1846.                 sb.Append("<soap:binding style='rpc' transport='http://schemas.xmlsoap.org/soap/http'/>");
1847.                 textWriter.WriteLine(sb);
1848.                 
1849.                 if (_type.IsInterface || IsSUDSType)
1850.                     PrintSuds(_type, _implIFaces, _nestedTypes, textWriter, sb, indent);
1851.                 // Some namespaces have no suds types
1852.                 
1853.                 if (!_xns.IsClassesPrinted) {
1854.                     for (int i = 0; i < _xns._realSchemaTypes.Count; i++) {
1855.                         RealSchemaType rsType = (RealSchemaType)_xns._realSchemaTypes[i];
1856.                         Type type = rsType._type;
1857.                         Util.Log("RealSchemaType.PrintMessageWsd suds realSchemaType " + type);
1858.                         if (!rsType.Type.IsInterface && !rsType.IsSUDSType) {
1859.                             Util.Log("RealSchemaType.PrintMessageWsd suds realSchemaType 2 " + type.BaseType + " " + typeof(MulticastDelegate).IsAssignableFrom(type));
1860.                             ;
1861.                             
1862.                             Type[] iFaces = GetIntroducedInterfaces(rsType._type);
1863.                             string[] implIFaces = null;
1864.                             bool bUsedFaces = false;
1865.                             if (iFaces.Length > 0) {
1866.                                 implIFaces = new string[iFaces.Length];
1867.                                 for (int j = 0; i < iFaces.Length; i++) {
1868.                                     string fns;
1869.                                     Assembly fassem;
1870.                                     Util.Log("RealSchemaType.PrintMessageWsdl iFace " + iFaces[j].Name);
1871.                                     bool bInteropType = WsdlGenerator.GetNSAndAssembly(iFaces[j], out fns, out fassem);
1872.                                     XMLNamespace xns = _xns.LookupSchemaNamespace(fns, fassem);
1873.                                     Debug.Assert(xns != null, "SchemaType should have been found");
1874.                                     sb.Length = 0;
1875.                                     sb.Append(xns.Prefix);
1876.                                     sb.Append(':');
1877.                                     sb.Append(iFaces[j].Name);
1878.                                     implIFaces[j] = sb.ToString();
1879.                                     if (implIFaces[j].Length > 0)
1880.                                         bUsedFaces = true;
1881.                                 }
1882.                             }
1883.                             if (!bUsedFaces)
1884.                                 implIFaces = null;
1885.                             
1886.                             PrintSuds(type, implIFaces, rsType._nestedTypes, textWriter, sb, indent);
1887.                         }
1888.                     }
1889.                     _xns.IsClassesPrinted = true;
1890.                 }
1891.                 
1892.                 
1893.                 for (int i = 0; i < methodsLength; i++) {
1894.                     method = _methods[i];
1895.                     methodName = PrintMethodName(method);
1896.                     bIsOneWay = RemotingServices.IsOneWay(method);
1897.                     
1898.                     //binding operation
1899.                     sb.Length = 0;
1900.                     sb.Append(indent1);
1901.                     sb.Append("<operation name='");
1902.                     sb.Append(methodName);
1903.                     sb.Append("'>");
1904.                     textWriter.WriteLine(sb);
1905.                     
1906.                     sb.Length = 0;
1907.                     sb.Append(indent2);
1908.                     sb.Append("<soap:operation soapAction='");
1909.                     string soapAction = SoapServices.GetSoapActionFromMethodBase(method);
1910.                     if ((soapAction != null) || (soapAction.Length > 0)) {
1911.                         sb.Append(soapAction);
1912.                     }
1913.                     else {
1914.                         sb.Append(ns);
1915.                         sb.Append('#');
1916.                         sb.Append(methodName);
1917.                     }
1918.                     sb.Append("'/>");
1919.                     textWriter.WriteLine(sb);
1920.                     
1921.                     if (_methodAttributes != null && (i < _methodAttributes.Length) && _methodAttributes[i] != null) {
1922.                         // Suds for method attributes
1923.                         // Attributes are only for public methods,
1924.                         // _method contains public and additional qualified interface methods
1925.                         // The public methods are at the beginning of _methods
1926.                         sb.Length = 0;
1927.                         sb.Append(indent2);
1928.                         sb.Append("<suds:method attributes='");
1929.                         sb.Append(_methodAttributes[i]);
1930.                         sb.Append("'/>");
1931.                         textWriter.WriteLine(sb);
1932.                     }
1933.                     
1934.                     sb.Length = 0;
1935.                     sb.Append(indent2);
1936.                     sb.Append("<input name='");
1937.                     sb.Append(_methodTypes[2 * i]);
1938.                     sb.Append("Request'>");
1939.                     textWriter.WriteLine(sb);
1940.                     
1941.                     sb.Length = 0;
1942.                     sb.Append(indent3);
1943.                     sb.Append("<soap:body use='encoded' encodingStyle='http://schemas.xmlsoap.org/soap/encoding/' namespace='");
1944.                     string interopNamespace = SoapServices.GetXmlNamespaceForMethodCall(method);
1945.                     if (interopNamespace == null)
1946.                         sb.Append(ns);
1947.                     else
1948.                         sb.Append(interopNamespace);
1949.                     sb.Append("'/>");
1950.                     textWriter.WriteLine(sb);
1951.                     
1952.                     sb.Length = 0;
1953.                     sb.Append(indent2);
1954.                     sb.Append("</input>");
1955.                     textWriter.WriteLine(sb);
1956.                     
1957.                     if (!bIsOneWay) {
1958.                         sb.Length = 0;
1959.                         sb.Append(indent2);
1960.                         sb.Append("<output name='");
1961.                         sb.Append(_methodTypes[2 * i]);
1962.                         sb.Append("Response'>");
1963.                         textWriter.WriteLine(sb);
1964.                         
1965.                         sb.Length = 0;
1966.                         sb.Append(indent3);
1967.                         sb.Append("<soap:body use='encoded' encodingStyle='http://schemas.xmlsoap.org/soap/encoding/' namespace='");
1968.                         interopNamespace = SoapServices.GetXmlNamespaceForMethodResponse(method);
1969.                         if (interopNamespace == null)
1970.                             sb.Append(ns);
1971.                         else
1972.                             sb.Append(interopNamespace);
1973.                         sb.Append("'/>");
1974.                         textWriter.WriteLine(sb);
1975.                         
1976.                         sb.Length = 0;
1977.                         sb.Append(indent2);
1978.                         sb.Append("</output>");
1979.                         textWriter.WriteLine(sb);
1980.                     }
1981.                     
1982.                     sb.Length = 0;
1983.                     sb.Append(indent1);
1984.                     sb.Append("</operation>");
1985.                     textWriter.WriteLine(sb);
1986.                 }
1987.                 
1988.                 sb.Length = 0;
1989.                 sb.Append(indent);
1990.                 sb.Append("</binding>");
1991.                 textWriter.WriteLine(sb);
1992.             }
1993.             
1994.             private void PrintSuds(Type type, string[] implIFaces, Type[] nestedTypes, TextWriter textWriter, StringBuilder sb, string indent)
1995.             {
1996.                 Util.Log("RealSchemaType.PrintSuds " + type + " implIFaces " + implIFaces + " nestedTypes " + nestedTypes);
1997.                 string indent1 = IndentP(indent);
1998.                 string indent2 = IndentP(indent1);
1999.                 string indent3 = IndentP(indent2);
2000.                 
2001.                 string sudsEnd = null;
2002.                 // Type, interface, extends information
2003.                 sb.Length = 0;
2004.                 sb.Append(indent1);
2005.                 if (type.IsInterface) {
2006.                     sb.Append("<suds:interface type='");
2007.                     sudsEnd = "</suds:interface>";
2008.                     
2009.                     
2010.                 }
2011.                 else if (type.IsValueType) {
2012.                     sb.Append("<suds:struct type='");
2013.                     sudsEnd = "</suds:struct>";
2014.                 }
2015.                 else {
2016.                     sb.Append("<suds:class type='");
2017.                     sudsEnd = "</suds:class>";
2018.                 }
2019.                 sb.Append(_xns.Prefix);
2020.                 sb.Append(':');
2021.                 sb.Append(WsdlGenerator.RefName(type));
2022.                 sb.Append("'");
2023.                 
2024.                 Type baseType = type.BaseType;
2025.                 if (IsNotSystemDefinedRoot(type, baseType)) {
2026.                     XMLNamespace xns = _WsdlGenerator.GetNamespace(baseType);
2027.                     sb.Append(" extends='");
2028.                     sb.Append(xns.Prefix);
2029.                     sb.Append(':');
2030.                     sb.Append(baseType.Name);
2031.                     sb.Append("'");
2032.                     
2033.                 }
2034.                 
2035.                 if (baseType != null && baseType.FullName == "System.EnterpriseServices.ServicedComponent")
2036.                     sb.Append(" rootType='ServicedComponent'");
2037.                 else if (typeof(Delegate).IsAssignableFrom(type) || typeof(MulticastDelegate).IsAssignableFrom(type))
2038.                     sb.Append(" rootType='Delegate'");
2039.                 else if (typeof(MarshalByRefObject).IsAssignableFrom(type))
2040.                     sb.Append(" rootType='MarshalByRefObject'");
2041.                 else if (typeof(ISerializable).IsAssignableFrom(type))
2042.                     sb.Append(" rootType='ISerializable'");
2043.                 
2044.                 if (implIFaces == null && nestedTypes == null)
2045.                     sb.Append("/>");
2046.                 else
2047.                     sb.Append(">");
2048.                 
2049.                 textWriter.WriteLine(sb);
2050.                 
2051.                 string extendAttribute = null;
2052.                 if (type.IsInterface)
2053.                     extendAttribute = "<suds:extends type='";
2054.                 else
2055.                     extendAttribute = "<suds:implements type='";
2056.                 
2057.                 
2058.                 if (implIFaces != null) {
2059.                     for (int j = 0; j < implIFaces.Length; j++) {
2060.                         if (!(implIFaces[j] == null || implIFaces[j] == String.Empty)) {
2061.                             sb.Length = 0;
2062.                             sb.Append(indent2);
2063.                             sb.Append(extendAttribute);
2064.                             sb.Append(implIFaces[j]);
2065.                             sb.Append("'/>");
2066.                             textWriter.WriteLine(sb);
2067.                         }
2068.                     }
2069.                 }
2070.                 
2071.                 if (nestedTypes != null) {
2072.                     for (int j = 0; j < nestedTypes.Length; j++) {
2073.                         sb.Length = 0;
2074.                         sb.Append(indent2);
2075.                         sb.Append("<suds:nestedType name='");
2076.                         sb.Append(nestedTypes[j].Name);
2077.                         sb.Append("' type='");
2078.                         sb.Append(_xns.Prefix);
2079.                         sb.Append(':');
2080.                         sb.Append(WsdlGenerator.RefName(nestedTypes[j]));
2081.                         sb.Append("'/>");
2082.                         textWriter.WriteLine(sb);
2083.                     }
2084.                 }
2085.                 
2086.                 if (implIFaces != null || nestedTypes != null) {
2087.                     sb.Length = 0;
2088.                     sb.Append(indent1);
2089.                     sb.Append(sudsEnd);
2090.                     textWriter.WriteLine(sb);
2091.                 }
2092.             }
2093.             
2094.             
2095.             private static string ProcessArray(Type type, XMLNamespace xns)
2096.             {
2097.                 Util.Log("RealSchemaType.ProcessArray Enter " + type);
2098.                 string qname = null;
2099.                 bool bbinary = false;
2100.                 Type elementType = type.GetElementType();
2101.                 string elementTypeName = "ArrayOf";
2102.                 while (elementType.IsArray) {
2103.                     elementTypeName = elementTypeName + "ArrayOf";
2104.                     elementType = elementType.GetElementType();
2105.                 }
2106.                 
2107.                 qname = RealSchemaType.TypeName(elementType, true, xns);
2108.                 int index = qname.IndexOf(":");
2109.                 string prefix = qname.Substring(0, index);
2110.                 string wireName = qname.Substring(index + 1);
2111.                 Util.Log("RealSchemaType.ProcessArray qname " + qname + " wirename " + wireName);
2112.                 int rank = type.GetArrayRank();
2113.                 string rankStr = "";
2114.                 if (rank > 1)
2115.                     rankStr = rank.ToString(CultureInfo.InvariantCulture);
2116.                 string csname = elementTypeName + wireName.Substring(0, 1).ToUpper(CultureInfo.InvariantCulture) + wireName.Substring(1) + rankStr;
2117.                 csname = csname.Replace('+', 'N');
2118.                 // need to get rid of + in nested classes
2119.                 ArraySchemaType ast = xns.LookupArraySchemaType(csname);
2120.                 if (ast == null) {
2121.                     ArraySchemaType cstype = new ArraySchemaType(type, csname, SchemaBlockType.ComplexContent, false);
2122.                     Restriction restriction = new Restriction();
2123.                     SchemaAttribute attribute = new SchemaAttribute();
2124.                     if (bbinary)
2125.                         attribute.AddArray(qname);
2126.                     else {
2127.                         string arrayTypeName = type.Name;
2128.                         index = arrayTypeName.IndexOf("[");
2129.                         attribute.AddArray(qname + arrayTypeName.Substring(index));
2130.                     }
2131.                     
2132.                     restriction.AddArray(attribute);
2133.                     cstype.AddParticle(restriction);
2134.                     xns.AddArraySchemaType(cstype);
2135.                 }
2136.                 
2137.                 string returnStr = xns.Prefix + ":" + csname;
2138.                 Util.Log("RealSchemaType.ProcessArray Exit " + returnStr);
2139.                 return returnStr;
2140.             }
2141.             
2142.             
2143.             
2144.             static internal string TypeName(Type type, bool bEmbedded, XMLNamespace thisxns)
2145.             {
2146.                 Util.Log("RealSchemaType.TypeName entry " + type + " bEmbedded " + bEmbedded + " xns " + thisxns.Name);
2147.                 string typeName = null;
2148.                 if (type.IsArray)
2149.                     return ProcessArray(type, thisxns);
2150.                 
2151.                 string clrTypeName = WsdlGenerator.RefName(type);
2152.                 Type clrType = type;
2153.                 
2154.                 // If ref type the name ends in &
2155.                 if (type.IsByRef) {
2156.                     clrType = type.GetElementType();
2157.                     clrTypeName = WsdlGenerator.RefName(clrType);
2158.                     if (clrType.IsArray)
2159.                         return ProcessArray(clrType, thisxns);
2160.                 }
2161.                 
2162.                 typeName = SudsConverter.MapClrTypeToXsdType(clrType);
2163.                 
2164.                 if (typeName == null) {
2165.                     string ns = type.Namespace;
2166.                     Assembly assem = type.Module.Assembly;
2167.                     XMLNamespace xns = null;
2168.                     Util.Log("RealSchemaType.TypeName realNS " + ns);
2169.                     xns = (XMLNamespace)thisxns.Generator._typeToInteropNS[type];
2170.                     
2171.                     if (xns == null) {
2172.                         xns = thisxns.LookupSchemaNamespace(ns, assem);
2173.                         if (xns == null) {
2174.                             xns = thisxns.Generator.LookupNamespace(ns, assem);
2175.                             if (xns == null) {
2176.                                 xns = thisxns.Generator.AddNamespace(ns, assem);
2177.                             }
2178.                             thisxns.DependsOnSchemaNS(xns, false);
2179.                         }
2180.                         Util.Log("RealSchemaType.TypeName depended NS with assem equals " + xns.Name);
2181.                     }
2182.                     StringBuilder sb = new StringBuilder(256);
2183.                     
2184.                     sb.Append(xns.Prefix);
2185.                     sb.Append(':');
2186.                     sb.Append(clrTypeName);
2187.                     typeName = sb.ToString();
2188.                 }
2189.                 
2190.                 Util.Log("RealSchemaType.TypeName exit " + typeName);
2191.                 return typeName;
2192.             }
2193.             
2194.             
2195.             private static Type[] GetIntroducedInterfaces(Type type)
2196.             {
2197.                 ArrayList ifaceA = new ArrayList();
2198.                 Type[] typeA = type.GetInterfaces();
2199.                 // remove system interfaces.
2200.                 foreach (Type itype in typeA) {
2201.                     if (!itype.FullName.StartsWith("System.")) {
2202.                         ifaceA.Add(itype);
2203.                         Util.Log("RealSchemaType.GetIntroducedInterfaces " + type + " Interfaces " + itype);
2204.                     }
2205.                 }
2206.                 
2207.                 Util.Log("RealSchemaType.GetIntroducedInterfaces " + type + " typeInterface? " + type.IsInterface + " number of interfaces " + typeA.Length);
2208.                 
2209.                 Type[] ifaceTypes = new Type[ifaceA.Count];
2210.                 for (int i = 0; i < ifaceA.Count; i++)
2211.                     ifaceTypes[i] = (Type)ifaceA[i];
2212.                 return ifaceTypes;
2213.             }
2214.             
2215.             private static void FindMethodAttributes(Type type, MethodInfo[] infos, ref string[] methodAttributes, BindingFlags bFlags)
2216.             {
2217.                 Util.Log("RealSchemaType.FindMethodAttributes Enter " + type);
2218.                 Type baseType = type;
2219.                 ArrayList inherit = new ArrayList();
2220.                 while (true) {
2221.                     baseType = baseType.BaseType;
2222.                     
2223.                     Util.Log("RealSchemaType.FindMethodAttributes baseType " + baseType);
2224.                     if (baseType != null && !baseType.FullName.StartsWith("System."))
2225.                         inherit.Add(baseType);
2226.                     else
2227.                         break;
2228.                 }
2229.                 
2230.                 StringBuilder sb = new StringBuilder();
2231.                 for (int i = 0; i < infos.Length; i++) {
2232.                     MethodBase info = (MethodBase)infos[i];
2233.                     sb.Length = 0;
2234.                     MethodAttributes ma = info.Attributes;
2235.                     bool bVirtual = info.IsVirtual;
2236.                     bool bNewSlot = ((ma & MethodAttributes.NewSlot) == MethodAttributes.NewSlot);
2237.                     Util.Log("RealSchemaType.FindMethodAttributes " + info.Name + " bVirtual " + bVirtual + " bNewSlot " + bNewSlot + " hidebysig " + info.IsHideBySig);
2238.                     if (info.IsPublic)
2239.                         sb.Append("public");
2240.                     else if (info.IsFamily)
2241.                         sb.Append("protected");
2242.                     else if (info.IsAssembly)
2243.                         sb.Append("internal");
2244.                     
2245.                     // See if method hides inherited methods
2246.                     bool bHides = false;
2247.                     for (int j = 0; j < inherit.Count; j++) {
2248.                         baseType = (Type)inherit[j];
2249.                         ParameterInfo[] paramInfos = info.GetParameters();
2250.                         Type[] types = new Type[paramInfos.Length];
2251.                         for (int itype = 0; itype < types.Length; itype++) {
2252.                             types[itype] = paramInfos[itype].ParameterType;
2253.                         }
2254.                         MethodInfo baseInfo = baseType.GetMethod(info.Name, types);
2255.                         if (baseInfo != null) {
2256.                             // Hides
2257.                             if (sb.Length > 0)
2258.                                 sb.Append(" ");
2259.                             if (bNewSlot || baseInfo.IsFinal)
2260.                                 sb.Append("new");
2261.                             else if (baseInfo.IsVirtual && bVirtual)
2262.                                 sb.Append("override");
2263.                             else
2264.                                 sb.Append("new");
2265.                             bHides = true;
2266.                             break;
2267.                         }
2268.                     }
2269.                     if (!bHides && bVirtual) {
2270.                         if (sb.Length > 0)
2271.                             sb.Append(" ");
2272.                         sb.Append("virtual");
2273.                     }
2274.                     
2275.                     if (sb.Length > 0) {
2276.                         methodAttributes[i] = sb.ToString();
2277.                         Util.Log("RealSchemaType.FindMethodAttributes Exit " + info.Name + " " + methodAttributes[i]);
2278.                     }
2279.                 }
2280.             }
2281.             
2282.             private static MethodInfo[] GetIntroducedMethods(Type type, ref string[] methodAttributes)
2283.             {
2284.                 Util.Log("RealSchemaType.GetIntroducedMethods " + type);
2285.                 
2286.                 
2287.                 // Methods in the class are either the class public methods or interface qualified methods
2288.                 
2289.                 BindingFlags bFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public;
2290.                 MethodInfo[] methodInfos = type.GetMethods(bFlags);
2291.                 //public methods (including unqualified interface methods)
2292.                 if (type.IsInterface)
2293.                     return methodInfos;
2294.                 
2295.                 // Find method attributes for public methods
2296.                 methodAttributes = new string[methodInfos.Length];
2297.                 FindMethodAttributes(type, methodInfos, ref methodAttributes, bFlags);
2298.                 
2299.                 // Get any class methods which are interface qualifed methods.
2300.                 // interface qualified methods are not public in the metadata.
2301.                 ArrayList additionalInfos = new ArrayList();
2302.                 Type[] itypeA = type.GetInterfaces();
2303.                 foreach (Type itype in itypeA) {
2304.                     InterfaceMapping im = type.GetInterfaceMap(itype);
2305.                     foreach (MethodInfo mi in im.TargetMethods) {
2306.                         if (!mi.IsPublic && type.GetMethod(mi.Name, bFlags | BindingFlags.NonPublic) != null) {
2307.                             additionalInfos.Add(mi);
2308.                         }
2309.                     }
2310.                 }
2311.                 
2312.                 // Combine all the methodinfos into one structure
2313.                 MethodInfo[] finalMethodInfos = null;
2314.                 if (additionalInfos.Count > 0) {
2315.                     finalMethodInfos = new MethodInfo[methodInfos.Length + additionalInfos.Count];
2316.                     for (int i = 0; i < methodInfos.Length; i++)
2317.                         finalMethodInfos[i] = methodInfos[i];
2318.                     for (int i = 0; i < additionalInfos.Count; i++)
2319.                         finalMethodInfos[methodInfos.Length + i] = (MethodInfo)additionalInfos[i];
2320.                 }
2321.                 else
2322.                     finalMethodInfos = methodInfos;
2323.                 
2324.                 return finalMethodInfos;
2325.             }
2326.             
2327.             static internal string PrintMethodName(MethodInfo methodInfo)
2328.             {
2329.                 string methodName = methodInfo.Name;
2330.                 int lastDot = 0;
2331.                 int prevDot = 0;
2332.                 
2333.                 for (int i = 0; i < methodName.Length; i++) {
2334.                     if (methodName[i] == '.') {
2335.                         prevDot = lastDot;
2336.                         lastDot = i;
2337.                     }
2338.                 }
2339.                 
2340.                 string iname = methodName;
2341.                 
2342.                 if (prevDot > 0)
2343.                     iname = methodName.Substring(prevDot + 1);
2344.                 
2345.                 return iname;
2346.             }
2347.             
2348.             private static FieldInfo[] GetInstanceFields(Type type)
2349.             {
2350.                 Util.Log("RealSchemaType.GetIntroducedFields " + type);
2351.                 
2352.                 BindingFlags bFlags = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public;
2353.                 
2354.                 if (!s_marshalByRefType.IsAssignableFrom(type))
2355.                     bFlags |= BindingFlags.NonPublic;
2356.                 
2357.                 FieldInfo[] fields = type.GetFields(bFlags);
2358.                 Util.Log("RealSchemaType.GetIntroducedFields length " + fields.Length);
2359.                 int actualLength = fields.Length;
2360.                 if (actualLength == 0)
2361.                     return (emptyFieldSet);
2362.                 
2363.                 for (int i = 0; i < fields.Length; i++) {
2364.                     Util.Log("RealSchemaType.GetInstanceFields field " + fields[i].Name + " " + fields[i].FieldType + " type " + type);
2365.                     if (fields[i].IsStatic) {
2366.                         Debug.Assert(false, "Static Field");
2367.                         Util.Log("RealSchemaType.GetInstanceFields field static " + fields[i].FieldType);
2368.                         --actualLength;
2369.                         fields[i] = fields[actualLength];
2370.                         fields[actualLength] = null;
2371.                     }
2372.                 }
2373.                 
2374.                 if (actualLength < fields.Length) {
2375.                     FieldInfo[] ifields = new FieldInfo[actualLength];
2376.                     Array.Copy(fields, ifields, actualLength);
2377.                     Util.Log("RealSchemaType.GetInstanceFields adjust length " + actualLength);
2378.                     return (ifields);
2379.                 }
2380.                 
2381.                 return (fields);
2382.             }
2383.             
2384.             // Instance fields
2385.             private WsdlGenerator _WsdlGenerator;
2386.             private Type _type;
2387.             private string _serviceEndpoint;
2388.             private Hashtable _typeToServiceEndpoint;
2389.             private bool _bUnique;
2390.             private XMLNamespace _xns;
2391.             private bool _bStruct;
2392.             private string[] _implIFaces;
2393.             
2394.             private Type[] _iFaces;
2395.             private MethodInfo[] _methods;
2396.             private string[] _methodAttributes;
2397.             private string[] _methodTypes;
2398.             private FieldInfo[] _fields;
2399.             private PhonySchemaType[] _phony;
2400.             internal Type[] _nestedTypes;
2401.             
2402.             // Static fields
2403.             private static Type[] emptyTypeSet = new Type[0];
2404.             private static MethodInfo[] emptyMethodSet = new MethodInfo[0];
2405.             private static FieldInfo[] emptyFieldSet = new FieldInfo[0];
2406.         }
2407.         
2408.         private class XMLNamespace
2409.         {
2410.             internal XMLNamespace(string name, Assembly assem, string serviceEndpoint, Hashtable typeToServiceEndpoint, string prefix, bool bInteropType, WsdlGenerator generator)
2411.             {
2412.                 Util.Log("XMLNamespace.XMLNamespace Enter " + name + " serviceEndpoint " + serviceEndpoint + " prefix " + prefix + " bInteropType " + bInteropType);
2413.                 _name = name;
2414.                 _assem = assem;
2415.                 _bUnique = false;
2416.                 _bInteropType = bInteropType;
2417.                 _generator = generator;
2418.                 StringBuilder sb = new StringBuilder(256);
2419.                 Assembly systemAssembly = typeof(string).Module.Assembly;
2420.                 
2421.                 // Remove leading . for an empty namespace
2422.                 
2423.                 if (!_bInteropType) {
2424.                     if (assem == systemAssembly) {
2425.                         sb.Append(SoapServices.CodeXmlNamespaceForClrTypeNamespace(name, null));
2426.                     }
2427.                     else if (assem != null) {
2428.                         sb.Append(SoapServices.CodeXmlNamespaceForClrTypeNamespace(name, assem.FullName));
2429.                     }
2430.                 }
2431.                 else {
2432.                     sb.Append(name);
2433.                 }
2434.                 _namespace = sb.ToString();
2435.                 _prefix = prefix;
2436.                 _dependsOnSchemaNS = new ArrayList();
2437.                 _realSUDSTypes = new ArrayList();
2438.                 _dependsOnSUDSNS = new ArrayList();
2439.                 _realSchemaTypes = new ArrayList();
2440.                 _phonySchemaTypes = new ArrayList();
2441.                 _simpleSchemaTypes = new ArrayList();
2442.                 _arraySchemaTypes = new ArrayList();
2443.                 _xnsImports = new ArrayList();
2444.                 _serviceEndpoint = serviceEndpoint;
2445.                 _typeToServiceEndpoint = typeToServiceEndpoint;
2446.                 Util.Log("XMLNamespace.XMLNamespace exit " + _namespace);
2447.             }
2448.             
2449.             internal string Name {
2450.                 get { return (_name); }
2451.             }
2452.             internal Assembly Assem {
2453.                 get { return (_assem); }
2454.             }
2455.             internal string Prefix {
2456.                 get { return (_prefix); }
2457.             }
2458.             internal string Namespace {
2459.                 get { return (_namespace); }
2460.             }
2461.             
2462.             internal bool IsInteropType {
2463.                 get { return (_bInteropType); }
2464.             }
2465.             
2466.             internal WsdlGenerator Generator {
2467.                 get { return (_generator); }
2468.             }
2469.             
2470.             internal bool IsClassesPrinted {
2471.                 get { return _bClassesPrinted; }
2472.                 set { _bClassesPrinted = value; }
2473.             }
2474.             
2475.             
2476.             //internal XMLNamespace(String name, Assembly assem, String serviceEndpoint, Hashtable typeToServiceEndpoint, String prefix, bool bInteropType, WsdlGenerator generator ){
2477.             
2478. /*
2479.             internal SchemaType LookupSchemaType(Type type)
2480.             {
2481.                 return (SchemaType)_typeToSchemaType[type];
2482.             }
2484.             internal Type LookupType(SchemaType stype)
2485.             {
2486.                 return (Type)_schemaTypeToType[stype];
2487.             }
2488.             */            
2489.             
2490.             internal Type LookupSchemaType(string name)
2491.             {
2492.                 Type returnType = null;
2493.                 RealSchemaType rsType = LookupRealSchemaType(name);
2494.                 if (rsType != null)
2495.                     returnType = rsType.Type;
2496.                 
2497.                 SimpleSchemaType ssType = LookupSimpleSchemaType(name);
2498.                 if (ssType != null)
2499.                     returnType = ssType.Type;
2500.                 
2501.                 ArraySchemaType asType = LookupArraySchemaType(name);
2502.                 if (asType != null)
2503.                     returnType = asType.Type;
2504.                 
2505.                 Util.Log("XMLNamespace.LookupSchemaType " + name + " return " + returnType);
2506.                 return (returnType);
2507.             }
2508.             
2509.             internal SimpleSchemaType LookupSimpleSchemaType(string name)
2510.             {
2511.                 Util.Log("XMLNamespace.LookupSimpleSchemaType " + name);
2512.                 for (int i = 0; i < _simpleSchemaTypes.Count; i++) {
2513.                     SimpleSchemaType ssType = (SimpleSchemaType)_simpleSchemaTypes[i];
2514.                     if (ssType.FullRefName == name)
2515.                         return (ssType);
2516.                 }
2517.                 
2518.                 return (null);
2519.             }
2520.             
2521.             internal bool CheckForSchemaContent()
2522.             {
2523.                 if (_arraySchemaTypes.Count > 0 || _simpleSchemaTypes.Count > 0)
2524.                     return true;
2525.                 
2526.                 if (_realSchemaTypes.Count == 0)
2527.                     return false;
2528.                 
2529.                 bool bRealSchema = false;
2530.                 for (int i = 0; i < _realSchemaTypes.Count; i++) {
2531.                     RealSchemaType rsType = (RealSchemaType)_realSchemaTypes[i];
2532.                     if (!rsType.Type.IsInterface && !rsType.IsSUDSType) {
2533.                         bRealSchema = true;
2534.                         break;
2535.                     }
2536.                 }
2537.                 
2538.                 if (bRealSchema)
2539.                     return true;
2540.                 else
2541.                     return false;
2542.             }
2543.             
2544.             internal RealSchemaType LookupRealSchemaType(string name)
2545.             {
2546.                 Util.Log("XMLNamespace.LookupRealSchemaType " + name);
2547.                 Debug.Assert(_phonySchemaTypes.Count == 0, "PhonyTypes present");
2548.                 for (int i = 0; i < _realSchemaTypes.Count; i++) {
2549.                     RealSchemaType rsType = (RealSchemaType)_realSchemaTypes[i];
2550.                     if (rsType.FullRefName == name)
2551.                         return (rsType);
2552.                 }
2553.                 
2554.                 return (null);
2555.             }
2556.             
2557.             internal ArraySchemaType LookupArraySchemaType(string name)
2558.             {
2559.                 Util.Log("XMLNamespace.LookupArraySchemaType " + name);
2560.                 //Debug.Assert(_phonySchemaTypes.Count == 0, "PhonyTypes present");
2561.                 for (int i = 0; i < _arraySchemaTypes.Count; i++) {
2562.                     ArraySchemaType asType = (ArraySchemaType)_arraySchemaTypes[i];
2563.                     if (asType.Name == name)
2564.                         return (asType);
2565.                 }
2566.                 
2567.                 return (null);
2568.             }
2569.             
2570.             internal void AddRealSUDSType(RealSchemaType rsType)
2571.             {
2572.                 Util.Log("XMLNamespace.AddRealSUDSType " + rsType.Type);
2573.                 _realSUDSTypes.Add(rsType);
2574.                 //_typeToSchemaType[rsType.Type] = rsType;
2575.                 //_schemaTypeToType[rsType] = rsType.Type;
2576.                 return;
2577.             }
2578.             
2579.             internal void AddRealSchemaType(RealSchemaType rsType)
2580.             {
2581.                 Util.Log("XMLNamespace.AddRealSchemaType " + rsType.Type);
2582.                 Debug.Assert(LookupRealSchemaType(rsType.Name) == null, "Duplicate Type found");
2583.                 _realSchemaTypes.Add(rsType);
2584.                 if (rsType.IsUnique)
2585.                     _bUnique = true;
2586.                 //_typeToSchemaType[rsType.Type] = rsType;
2587.                 //_schemaTypeToType[rsType] = rsType.Type;
2588.                 return;
2589.             }
2590.             
2591.             internal void AddArraySchemaType(ArraySchemaType asType)
2592.             {
2593.                 Debug.Assert(LookupArraySchemaType(asType.Name) == null, "Duplicate Type found");
2594.                 _arraySchemaTypes.Add(asType);
2595.                 //_typeToSchemaType[asType.Type] = asType;
2596.                 //_schemaTypeToType[asType] = asType.Type;
2597.                 return;
2598.             }
2599.             
2600.             internal void AddSimpleSchemaType(SimpleSchemaType ssType)
2601.             {
2602.                 Util.Log("XMLNamespace.AddSimpleSchemaType " + ssType.Type);
2603.                 Debug.Assert(LookupSimpleSchemaType(ssType.Type.Name) == null, "Duplicate Type found");
2604.                 _simpleSchemaTypes.Add(ssType);
2605.                 //_typeToSchemaType[ssType.Type] = ssType;
2606.                 //_schemaTypeToType[ssType] = ssType.Type;
2607.                 return;
2608.             }
2609.             
2610.             internal PhonySchemaType LookupPhonySchemaType(string name)
2611.             {
2612.                 Util.Log("XMLNamespace.LookupPhonySchemaType " + name);
2613.                 for (int i = 0; i < _phonySchemaTypes.Count; i++) {
2614.                     PhonySchemaType type = (PhonySchemaType)_phonySchemaTypes[i];
2615.                     if (type.Name == name)
2616.                         return (type);
2617.                 }
2618.                 
2619.                 return (null);
2620.             }
2621.             
2622.             internal void AddPhonySchemaType(PhonySchemaType phType)
2623.             {
2624.                 Util.Log("XMLNamespace.AddPhonySchemaType " + phType.Name);
2625.                 PhonySchemaType overloadedType = LookupPhonySchemaType(phType.Name);
2626.                 if (overloadedType != null)
2627.                     phType.ElementName = phType.Name + overloadedType.OverloadedType();
2628.                 _phonySchemaTypes.Add(phType);
2629.                 
2630.                 return;
2631.             }
2632.             
2633.             internal XMLNamespace LookupSchemaNamespace(string ns, Assembly assem)
2634.             {
2635.                 Util.Log("XMLNamespace.LookupSchemaNamespace " + ns);
2636.                 for (int i = 0; i < _dependsOnSchemaNS.Count; i++) {
2637.                     XMLNamespace xns = (XMLNamespace)_dependsOnSchemaNS[i];
2638.                     if ((xns.Name == ns) && (xns.Assem == assem))
2639.                         return (xns);
2640.                 }
2641.                 
2642.                 return (null);
2643.             }
2644.             
2645.             internal void DependsOnSchemaNS(XMLNamespace xns, bool bImport)
2646.             {
2647.                 Util.Log("XMLNamespace.DependsOnSchemaNS " + Namespace + " depends on " + xns.Namespace + " bImport " + bImport);
2648.                 if (LookupSchemaNamespace(xns.Name, xns.Assem) != null)
2649.                     return;
2650.                 
2651.                 _dependsOnSchemaNS.Add(xns);
2652.                 if (bImport && Namespace != xns.Namespace)
2653.                     _xnsImports.Add(xns);
2654.                 return;
2655.             }
2656.             
2657.             private XMLNamespace LookupSUDSNamespace(string ns, Assembly assem)
2658.             {
2659.                 Util.Log("XMLNamespace.LookupSUDSNamespace " + ns);
2660.                 for (int i = 0; i < _dependsOnSUDSNS.Count; i++) {
2661.                     XMLNamespace xns = (XMLNamespace)_dependsOnSUDSNS[i];
2662.                     if ((xns.Name == ns) && (xns.Assem == assem))
2663.                         return (xns);
2664.                 }
2665.                 
2666.                 return (null);
2667.             }
2668.             
2669.             internal void DependsOnSUDSNS(XMLNamespace xns)
2670.             {
2671.                 Util.Log("XMLNamespace.DependsOnSUDSNS " + xns.Name + " " + xns.Assem);
2672.                 if (LookupSUDSNamespace(xns.Name, xns.Assem) != null)
2673.                     return;
2674.                 
2675.                 _dependsOnSUDSNS.Add(xns);
2676.                 return;
2677.             }
2678.             
2679.             internal void Resolve()
2680.             {
2681.                 Util.Log("XMLNamespace.Resolve");
2682.                 StringBuilder sb = new StringBuilder(256);
2683.                 for (int i = 0; i < _realSchemaTypes.Count; i++)
2684.                     ((RealSchemaType)_realSchemaTypes[i]).Resolve(sb);
2685.                 
2686.                 return;
2687.             }
2688.             
2689.             internal void PrintDependsOnWsdl(TextWriter textWriter, StringBuilder sb, string indent, Hashtable usedNames)
2690.             {
2691.                 Util.Log("XMLNamespace.PrintDependsOn " + _name + " targetNameSpace " + Namespace);
2692.                 if (_dependsOnSchemaNS.Count > 0) {
2693.                     for (int i = 0; i < _dependsOnSchemaNS.Count; i++) {
2694.                         XMLNamespace xns = (XMLNamespace)_dependsOnSchemaNS[i];
2695.                         if (!usedNames.ContainsKey(xns.Prefix)) {
2696.                             usedNames[xns.Prefix] = null;
2697.                             sb.Length = 0;
2698.                             sb.Append(indent);
2699.                             sb.Append("xmlns:");
2700.                             sb.Append(xns.Prefix);
2701.                             sb.Append("='");
2702.                             sb.Append(xns.Namespace);
2703.                             sb.Append("'");
2704.                             textWriter.WriteLine(sb);
2705.                         }
2706.                     }
2707.                 }
2708.             }
2709.             
2710.             internal void PrintSchemaWsdl(TextWriter textWriter, StringBuilder sb, string indent)
2711.             {
2712.                 Util.Log("XMLNamespace.PrintSchemaWsdl " + Namespace + " _realSchemaTypes.Count " + _realSchemaTypes.Count);
2713.                 // Print schema types
2714.                 
2715.                 bool bReal = false;
2716.                 
2717.                 /*
2718.                 for(int i=0;i<_realSchemaTypes.Count;i++)
2719.                 {
2720.                     RealSchemaType rsType = (RealSchemaType) _realSchemaTypes[i];
2721.                     if(!rsType.Type.IsInterface && !rsType.IsSUDSType)
2722.                         bReal = true;
2723.                 }
2724.                 */                
2725.                 
2726. if ((_simpleSchemaTypes.Count > 0) || (_realSchemaTypes.Count > 0) || (_arraySchemaTypes.Count > 0)) {
2727.                     bReal = true;
2728.                 }
2729.                 
2730.                 // Print schema types
2731.                 if (bReal) {
2732.                     // schema begin
2733.                     string indent1 = IndentP(indent);
2734.                     string indent2 = IndentP(indent1);
2735.                     string indent3 = IndentP(indent2);
2736.                     string indent4 = IndentP(indent3);
2737.                     sb.Length = 0;
2738.                     sb.Append(indent);
2739.                     sb.Append("<schema ");
2740.                     sb.Append("targetNamespace='");
2741.                     sb.Append(Namespace);
2742.                     sb.Append("'");
2743.                     textWriter.WriteLine(sb);
2744.                     
2745.                     sb.Length = 0;
2746.                     sb.Append(indent2);
2747.                     sb.Append("xmlns='");
2748.                     sb.Append(SudsConverter.GetXsdVersion(_generator._xsdVersion));
2749.                     sb.Append("'");
2750.                     textWriter.WriteLine(sb);
2751.                     
2752.                     sb.Length = 0;
2753.                     sb.Append(indent2);
2754.                     sb.Append("elementFormDefault='unqualified' attributeFormDefault='unqualified'>");
2755.                     textWriter.WriteLine(sb);
2756.                     
2757.                     // Write import statements
2758.                     foreach (XMLNamespace xns in _xnsImports) {
2759.                         sb.Length = 0;
2760.                         sb.Append(indent1);
2761.                         sb.Append("<import namespace='");
2762.                         sb.Append(xns.Namespace);
2763.                         sb.Append("'/>");
2764.                         textWriter.WriteLine(sb);
2765.                     }
2766.                     
2767.                     
2768.                     for (int i = 0; i < _simpleSchemaTypes.Count; i++) {
2769.                         SimpleSchemaType ssType = (SimpleSchemaType)_simpleSchemaTypes[i];
2770.                         ssType.PrintSchemaType(textWriter, sb, indent1, false);
2771.                     }
2772.                     
2773.                     for (int i = 0; i < _realSchemaTypes.Count; i++) {
2774.                         RealSchemaType rsType = (RealSchemaType)_realSchemaTypes[i];
2775.                         if (!rsType.Type.IsInterface && !rsType.IsSUDSType)
2776.                             rsType.PrintSchemaType(textWriter, sb, indent1, false);
2777.                     }
2778.                     
2779.                     for (int i = 0; i < _arraySchemaTypes.Count; i++) {
2780.                         ArraySchemaType asType = (ArraySchemaType)_arraySchemaTypes[i];
2781.                         asType.PrintSchemaType(textWriter, sb, indent1, false);
2782.                     }
2783.                     
2784.                     
2785.                     /*
2786.                     for(int i=0;i<_phonySchemaTypes.Count;i++)
2787.                     {
2788.                         PhonySchemaType psType = (PhonySchemaType) _phonySchemaTypes[i];
2789.                         psType.PrintSchemaType(textWriter, sb, indent1, true);
2790.                     }
2791.                     */                    
2792.                     
2793. sb.Length = 0;
2794.                     sb.Append(indent);
2795.                     sb.Append("</schema>");
2796.                     textWriter.WriteLine(sb);
2797.                     
2798.                     
2799.                 }
2800.             }
2801.             
2802.             internal void PrintMessageWsdl(TextWriter textWriter, StringBuilder sb, string indent, ArrayList refNames)
2803.             {
2804.                 Util.Log("XmlNamespace.PrintMessageWsdl");
2805.                 for (int i = 0; i < _realSUDSTypes.Count; i++)
2806.                     ((RealSchemaType)_realSUDSTypes[i]).PrintMessageWsdl(textWriter, sb, indent, refNames);
2807.                 
2808.                 if (_realSUDSTypes.Count == 0 && _realSchemaTypes.Count > 0) {
2809.                     // If no suds type, we still generate a binding section to print the Suds Extendsions
2810.                     // We only need to do this once, because all the realschema types will be placed into
2811.                     // one binding
2812.                     ((RealSchemaType)_realSchemaTypes[0]).PrintMessageWsdl(textWriter, sb, indent, new ArrayList());
2813.                 }
2814.             }
2815.             
2816.             // Fields
2817.             private string _name;
2818.             private Assembly _assem;
2819.             private string _namespace;
2820.             private string _prefix;
2821.             internal bool _bUnique;
2822.             private ArrayList _dependsOnSUDSNS;
2823.             private ArrayList _realSUDSTypes;
2824.             private ArrayList _dependsOnSchemaNS;
2825.             internal ArrayList _realSchemaTypes;
2826.             private ArrayList _phonySchemaTypes;
2827.             private ArrayList _simpleSchemaTypes;
2828.             private ArrayList _arraySchemaTypes;
2829.             private bool _bInteropType;
2830.             private string _serviceEndpoint;
2831.             private Hashtable _typeToServiceEndpoint;
2832.             private WsdlGenerator _generator;
2833.             private ArrayList _xnsImports;
2834.             private bool _bClassesPrinted = false;
2835.             //private Hashtable _typeToSchemaType = new Hashtable();
2836.             //private Hashtable _schemaTypeToType = new Hashtable();
2837.             
2838.             
2839.         }
2840.         
2841.         static internal string IndentP(string indentStr)
2842.         {
2843.             return indentStr + " ";
2844.         }
2845.         
2846.     }
2847. }