void ImportMessageParts()
{
SoapMethodStubInfo method = (SoapMethodStubInfo)MethodStubInfo;
ImportMessage(method.InputMembersMapping, InputMessage);
ImportMessage(method.OutputMembersMapping, OutputMessage);
foreach (SoapHeaderMapping hf in method.Headers)
{
if (hf.Custom)
{
continue;
}
Message msg = new Message();
msg.Name = Operation.Name + hf.HeaderType.Name;
MessagePart part = new MessagePart();
part.Name = hf.HeaderType.Name;
msg.Parts.Add(part);
ServiceDescription.Messages.Add(msg);
if (method.Use == SoapBindingUse.Literal)
{
// MS.NET reflects header classes in a weird way. The root element
// name is the CLR class name unless it is specified in an XmlRootAttribute.
// The usual is to use the xml type name by default, but not in this case.
XmlRootAttribute root;
XmlAttributes ats = new XmlAttributes(hf.HeaderType);
if (ats.XmlRoot != null)
{
root = ats.XmlRoot;
}
else
{
root = new XmlRootAttribute(hf.HeaderType.Name);
}
if (root.Namespace == null)
{
root.Namespace = TypeInfo.LogicalType.GetWebServiceLiteralNamespace(ServiceDescription.TargetNamespace);
}
if (root.ElementName == null)
{
root.ElementName = hf.HeaderType.Name;
}
XmlTypeMapping mapping = ReflectionImporter.ImportTypeMapping(hf.HeaderType, root);
part.Element = new XmlQualifiedName(mapping.ElementName, mapping.Namespace);
SchemaExporter.ExportTypeMapping(mapping);
}
else
{
XmlTypeMapping mapping = SoapReflectionImporter.ImportTypeMapping(hf.HeaderType, TypeInfo.LogicalType.GetWebServiceEncodedNamespace(ServiceDescription.TargetNamespace));
part.Type = new XmlQualifiedName(mapping.ElementName, mapping.Namespace);
SoapSchemaExporter.ExportTypeMapping(mapping);
}
}
}
public void Reflect(Type type, string url)
{
XmlSchemaExporter schemaExporter = new XmlSchemaExporter(Schemas);
SoapSchemaExporter soapSchemaExporter = new SoapSchemaExporter(Schemas);
if (WSConfig.IsSupported(WSProtocol.HttpSoap))
{
new Soap11ProtocolReflector().Reflect(this, type, url, schemaExporter, soapSchemaExporter);
}
#if NET_2_0
if (WSConfig.IsSupported(WSProtocol.HttpSoap12))
{
new Soap12ProtocolReflector().Reflect(this, type, url, schemaExporter, soapSchemaExporter);
}
#endif
if (WSConfig.IsSupported(WSProtocol.HttpGet))
{
new HttpGetProtocolReflector().Reflect(this, type, url, schemaExporter, soapSchemaExporter);
}
#if ONLY_1_1
if (WSConfig.IsSupported(WSProtocol.HttpPost) || WSConfig.IsSupported(WSProtocol.HttpPostLocalhost))
#else
if (WSConfig.IsSupported(WSProtocol.HttpPost))
#endif
{ new HttpPostProtocolReflector().Reflect(this, type, url, schemaExporter, soapSchemaExporter); }
int i = 0;
while (i < types.Schemas.Count)
{
if (types.Schemas[i].Items.Count == 0)
{
types.Schemas.RemoveAt(i);
}
else
{
i++;
}
}
if (serviceDescriptions.Count == 1)
{
serviceDescriptions[0].Types = types;
}
else
{
foreach (ServiceDescription d in serviceDescriptions)
{
d.Types = new Types();
for (int n = 0; n < types.Schemas.Count; n++)
{
ProtocolReflector.AddImport(d, types.Schemas[n].TargetNamespace, GetSchemaUrl(url, n));
}
}
}
}
internal void Reflect(ServiceDescriptionReflector serviceReflector, Type type, string url, XmlSchemaExporter xxporter, SoapSchemaExporter sxporter)
{
portNames = new CodeIdentifiers();
this.serviceReflector = serviceReflector;
serviceUrl = url;
serviceType = type;
schemaExporter = xxporter;
soapSchemaExporter = sxporter;
typeInfo = TypeStubManager.GetTypeStub(type, ProtocolName);
ServiceDescription desc = ServiceDescriptions [typeInfo.LogicalType.WebServiceNamespace];
if (desc == null)
{
desc = new ServiceDescription();
desc.TargetNamespace = typeInfo.LogicalType.WebServiceNamespace;
desc.Name = typeInfo.LogicalType.WebServiceName;
ServiceDescriptions.Add(desc);
}
ImportService(desc, typeInfo, url);
}
void ImportMessage(XmlMembersMapping members, Message msg)
{
SoapMethodStubInfo method = (SoapMethodStubInfo)MethodStubInfo;
bool needsEnclosingElement = (method.ParameterStyle == SoapParameterStyle.Wrapped &&
method.SoapBindingStyle == SoapBindingStyle.Document);
if (needsEnclosingElement)
{
MessagePart part = new MessagePart();
part.Name = "parameters";
XmlQualifiedName qname = new XmlQualifiedName(members.ElementName, members.Namespace);
if (method.Use == SoapBindingUse.Literal)
{
part.Element = qname;
}
else
{
part.Type = qname;
}
msg.Parts.Add(part);
}
else
{
for (int n = 0; n < members.Count; n++)
{
MessagePart part = new MessagePart();
part.Name = members[n].MemberName;
if (method.Use == SoapBindingUse.Literal)
{
if (members[n].Any)
{
part.Type = new XmlQualifiedName("any", members[n].Namespace);
}
else
{
part.Element = new XmlQualifiedName(members[n].ElementName, members[n].Namespace);
}
}
else
{
string namesp = members[n].TypeNamespace;
if (namesp == "")
{
namesp = members[n].Namespace;
}
part.Name = members[n].ElementName;
part.Type = new XmlQualifiedName(members[n].TypeName, namesp);
}
msg.Parts.Add(part);
}
}
if (method.Use == SoapBindingUse.Literal)
{
SchemaExporter.ExportMembersMapping(members);
}
else
{
SoapSchemaExporter.ExportMembersMapping(members, needsEnclosingElement);
}
}
protected override bool ReflectMethod()
{
LogicalTypeInfo ti = TypeStubManager.GetLogicalTypeInfo(ServiceType);
HttpOperationBinding sob = new HttpOperationBinding();
sob.Location = "/" + MethodStubInfo.Name;
OperationBinding.Extensions.Add(sob);
if (!Method.IsVoid)
{
MimeXmlBinding mxb = new MimeXmlBinding();
mxb.Part = "Body";
OperationBinding.Output.Extensions.Add(mxb);
MessagePart part = new MessagePart();
part.Name = "Body";
XmlTypeMapping map = ReflectionImporter.ImportTypeMapping(Method.ReturnType, ti.GetWebServiceLiteralNamespace(ServiceDescription.TargetNamespace));
XmlQualifiedName qname = new XmlQualifiedName(map.ElementName, map.Namespace);
part.Element = qname;
OutputMessage.Parts.Add(part);
SchemaExporter.ExportTypeMapping(map);
}
XmlReflectionMember[] mems = new XmlReflectionMember [Method.Parameters.Length];
for (int n = 0; n < Method.Parameters.Length; n++)
{
ParameterInfo param = Method.Parameters [n];
XmlReflectionMember mem = new XmlReflectionMember();
mem.MemberName = param.Name;
Type ptype = param.ParameterType;
if (ptype.IsByRef)
{
ptype = ptype.GetElementType();
}
mem.MemberType = ptype;
mems [n] = mem;
}
XmlMembersMapping memap = ReflectionImporter.ImportMembersMapping("", ti.WebServiceAbstractNamespace, mems, false);
bool allPrimitives = true;
for (int n = 0; n < memap.Count; n++)
{
XmlMemberMapping mem = memap[n];
MessagePart part = new MessagePart();
XmlQualifiedName pqname;
if (mem.TypeNamespace == "")
{
pqname = new XmlQualifiedName(mem.TypeName, XmlSchema.Namespace);
}
else
{
pqname = new XmlQualifiedName(mem.TypeName, mem.TypeNamespace);
allPrimitives = false;
}
part.Type = pqname;
part.Name = mem.ElementName;
InputMessage.Parts.Add(part);
}
if (!allPrimitives)
{
SoapSchemaExporter.ExportMembersMapping(memap);
}
return(true);
}
