1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
//------------------------------------------------------------------------------
// <copyright file="HttpProtocolReflector.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
namespace System.Web.Services.Description {
using System.Web.Services;
using System.Web.Services.Protocols;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.Schema;
using System.Collections;
using System;
using System.Reflection;
using System.Web.Services.Configuration;
internal abstract class HttpProtocolReflector : ProtocolReflector {
MimeReflector[] reflectors;
protected HttpProtocolReflector() {
Type[] reflectorTypes = WebServicesSection.Current.MimeReflectorTypes;
reflectors = new MimeReflector[reflectorTypes.Length];
for (int i = 0; i < reflectors.Length; i++) {
MimeReflector reflector = (MimeReflector)Activator.CreateInstance(reflectorTypes[i]);
reflector.ReflectionContext = this;
reflectors[i] = reflector;
}
}
protected bool ReflectMimeParameters() {
bool handled = false;
for (int i = 0; i < reflectors.Length; i++) {
if (reflectors[i].ReflectParameters())
handled = true;
}
return handled;
}
protected bool ReflectMimeReturn() {
if (Method.ReturnType == typeof(void)) {
Message outputMessage = OutputMessage;
return true;
}
bool handled = false;
for (int i = 0; i < reflectors.Length; i++) {
if (reflectors[i].ReflectReturn()) {
handled = true;
break;
}
}
return handled;
}
protected bool ReflectUrlParameters() {
if (!HttpServerProtocol.AreUrlParametersSupported(Method))
return false;
ReflectStringParametersMessage();
OperationBinding.Input.Extensions.Add(new HttpUrlEncodedBinding());
return true;
}
internal void ReflectStringParametersMessage() {
Message inputMessage = InputMessage;
foreach (ParameterInfo parameterInfo in Method.InParameters) {
MessagePart part = new MessagePart();
part.Name = XmlConvert.EncodeLocalName(parameterInfo.Name);
if (parameterInfo.ParameterType.IsArray) {
string typeNs = DefaultNamespace;
if (typeNs.EndsWith("/", StringComparison.Ordinal))
typeNs += "AbstractTypes";
else
typeNs += "/AbstractTypes";
string typeName = "StringArray";
if (!ServiceDescription.Types.Schemas.Contains(typeNs)) {
XmlSchema schema = new XmlSchema();
schema.TargetNamespace = typeNs;
ServiceDescription.Types.Schemas.Add(schema);
XmlSchemaElement element = new XmlSchemaElement();
element.Name = "String";
element.SchemaTypeName = new XmlQualifiedName("string", XmlSchema.Namespace);
element.MinOccurs = decimal.Zero;
element.MaxOccurs = decimal.MaxValue;
XmlSchemaSequence all = new XmlSchemaSequence();
all.Items.Add(element);
XmlSchemaComplexContentRestriction restriction = new XmlSchemaComplexContentRestriction();
restriction.BaseTypeName = new XmlQualifiedName(Soap.ArrayType, Soap.Encoding);
restriction.Particle = all;
XmlSchemaImport import = new XmlSchemaImport();
import.Namespace = restriction.BaseTypeName.Namespace;
XmlSchemaComplexContent model = new XmlSchemaComplexContent();
model.Content = restriction;
XmlSchemaComplexType type = new XmlSchemaComplexType();
type.Name = typeName;
type.ContentModel = model;
schema.Items.Add(type);
schema.Includes.Add(import);
}
part.Type = new XmlQualifiedName(typeName, typeNs);
}
else {
part.Type = new XmlQualifiedName("string", XmlSchema.Namespace);
}
inputMessage.Parts.Add(part);
}
}
internal string MethodUrl {
get {
WebMethodAttribute methodAttribute = Method.MethodAttribute;
string name = methodAttribute.MessageName;
if (name.Length == 0) name = Method.Name;
return "/" + name;
}
}
}
}
|
