[Category("NotDotNet")] // hangs on .NET 1.1
#endif
public void HandleOutAttributeParameters()
{
XmlReflectionMember m = new XmlReflectionMember();
m.MemberName = "hooray";
m.MemberType = typeof(string);
m.XmlAttributes = new XmlAttributes();
m.XmlAttributes.XmlAttribute = new XmlAttributeAttribute();
XmlReflectionImporter imp = new XmlReflectionImporter();
XmlMembersMapping map = imp.ImportMembersMapping(
"elem", "urn:x", new XmlReflectionMember [] { m }, true);
XmlSerializer ser = XmlSerializer.FromMappings(
new XmlMapping [] { map }) [0];
string xml = "<elem xmlns='urn:x' hooray='doh' />";
object [] arr = ser.Deserialize(new StringReader(xml))
as object [];
Assert.IsNotNull(arr, "#1");
Assert.AreEqual(1, arr.Length, "#2");
Assert.AreEqual("doh", arr [0], "#3");
xml = "<elem xmlns='urn:x' hooray='doh'></elem>";
arr = ser.Deserialize(new StringReader(xml)) as object [];
Assert.IsNotNull(arr, "#4");
Assert.AreEqual(1, arr.Length, "#5");
Assert.AreEqual("doh", arr [0], "#6");
}
XmlSerializer GetSerializer(MessageBodyDescription desc)
{
if (bodySerializers.ContainsKey(desc))
{
return(bodySerializers [desc]);
}
int count = desc.Parts.Count + (HasReturnValue(desc) ? 1 : 0);
XmlReflectionMember [] members = new XmlReflectionMember [count];
int ind = 0;
if (HasReturnValue(desc))
{
members [ind++] = CreateReflectionMember(desc.ReturnValue, true);
}
foreach (MessagePartDescription partDesc in desc.Parts)
{
members [ind++] = CreateReflectionMember(partDesc, false);
}
XmlReflectionImporter xmlImporter = new XmlReflectionImporter();
// Register known types into xmlImporter.
foreach (var type in OperationKnownTypes)
{
xmlImporter.IncludeType(type);
}
XmlMembersMapping [] partsMapping = new XmlMembersMapping [1];
partsMapping [0] = xmlImporter.ImportMembersMapping(desc.WrapperName, desc.WrapperNamespace, members, true);
bodySerializers [desc] = XmlSerializer.FromMappings(partsMapping) [0];
return(bodySerializers [desc]);
}
public void ExportXmlSerializable_NestedClassMapping()
{
XmlSchemas schemas = new XmlSchemas();
XmlReflectionMember xmlReflectionMember = new XmlReflectionMember();
XmlSchemaExporter xmlSchemaExporter = new XmlSchemaExporter(schemas);
XmlReflectionImporter xmlReflectionImporter = new XmlReflectionImporter();
//Export mapping for DataSet1 class.
xmlReflectionMember.MemberType = typeof(DataSet1);
XmlMembersMapping xmlMembersMapping = xmlReflectionImporter.ImportMembersMapping("DataSet1Response", "ResponseNamespace",
new XmlReflectionMember [] { xmlReflectionMember }, true);
xmlSchemaExporter.ExportMembersMapping(xmlMembersMapping);
//Export mapping for nested of DataSet1 class.
xmlReflectionMember.MemberType = typeof(DataSet1.DataTable1DataTable);
xmlMembersMapping = xmlReflectionImporter.ImportMembersMapping("DataTable1DataTableResponse", "ResponseNamespace",
new XmlReflectionMember [] { xmlReflectionMember }, true);
xmlSchemaExporter.ExportMembersMapping(xmlMembersMapping);
}
static XmlMembersMapping ImportMembersMapping(XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, bool serviceDefaultIsEncoded, bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle,
string elementName, string elementNamespace, bool nsIsDefault, XmlReflectionMember[] members, bool validate)
{
if (use == SoapBindingUse.Encoded)
{
string ns = (!rpc && paramStyle != SoapParameterStyle.Bare && nsIsDefault) ? GetEncodedNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace;
return(soapImporter.ImportMembersMapping(elementName, ns, members, rpc || paramStyle != SoapParameterStyle.Bare, rpc, validate));
}
else
{
string ns = nsIsDefault ? GetLiteralNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace;
return(xmlImporter.ImportMembersMapping(elementName, ns, members, paramStyle != SoapParameterStyle.Bare));
}
}
private static XmlMembersMapping ImportMembersMapping(XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter, bool serviceDefaultIsEncoded, bool rpc, SoapBindingUse use, SoapParameterStyle paramStyle, string elementName, string elementNamespace, bool nsIsDefault, XmlReflectionMember[] members, bool validate, bool openModel, string key, bool writeAccess)
{
XmlMembersMapping mapping = null;
if (use == SoapBindingUse.Encoded)
{
string ns = ((!rpc && (paramStyle != SoapParameterStyle.Bare)) && nsIsDefault) ? GetEncodedNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace;
mapping = soapImporter.ImportMembersMapping(elementName, ns, members, rpc || (paramStyle != SoapParameterStyle.Bare), rpc, validate, writeAccess ? XmlMappingAccess.Write : XmlMappingAccess.Read);
}
else
{
string str2 = nsIsDefault ? GetLiteralNamespace(elementNamespace, serviceDefaultIsEncoded) : elementNamespace;
mapping = xmlImporter.ImportMembersMapping(elementName, str2, members, paramStyle != SoapParameterStyle.Bare, rpc, openModel, writeAccess ? XmlMappingAccess.Write : XmlMappingAccess.Read);
}
if (mapping != null)
{
mapping.SetKey(key);
}
return(mapping);
}
//
// Constructor
//
public SoapMethodStubInfo(TypeStubInfo typeStub, LogicalMethodInfo source, object kind, XmlReflectionImporter xmlImporter, SoapReflectionImporter soapImporter)
: base(typeStub, source)
{
SoapTypeStubInfo parent = (SoapTypeStubInfo)typeStub;
XmlElementAttribute optional_ns = null;
if (kind == null)
{
Use = parent.LogicalType.BindingUse;
RequestName = "";
RequestNamespace = "";
ResponseName = "";
ResponseNamespace = "";
ParameterStyle = parent.ParameterStyle;
SoapBindingStyle = parent.SoapBindingStyle;
OneWay = false;
// disabled (see bug #332150)
//#if NET_2_0
// if (parent.Type != source.DeclaringType)
// Binding = source.DeclaringType.Name + parent.ProtocolName;
//#endif
}
else if (kind is SoapDocumentMethodAttribute)
{
SoapDocumentMethodAttribute dma = (SoapDocumentMethodAttribute)kind;
Use = dma.Use;
if (Use == SoapBindingUse.Default)
{
if (parent.SoapBindingStyle == SoapBindingStyle.Document)
{
Use = parent.LogicalType.BindingUse;
}
else
{
Use = SoapBindingUse.Literal;
}
}
Action = dma.Action;
Binding = dma.Binding;
RequestName = dma.RequestElementName;
RequestNamespace = dma.RequestNamespace;
ResponseName = dma.ResponseElementName;
ResponseNamespace = dma.ResponseNamespace;
ParameterStyle = dma.ParameterStyle;
if (ParameterStyle == SoapParameterStyle.Default)
{
ParameterStyle = parent.ParameterStyle;
}
OneWay = dma.OneWay;
SoapBindingStyle = SoapBindingStyle.Document;
}
else
{
SoapRpcMethodAttribute rma = (SoapRpcMethodAttribute)kind;
Use = SoapBindingUse.Encoded; // RPC always use encoded
Action = rma.Action;
if (Action != null && Action.Length == 0)
{
Action = null;
}
Binding = rma.Binding;
// When using RPC, MS.NET seems to ignore RequestElementName and
// MessageName, and it always uses the method name
RequestName = source.Name;
ResponseName = source.Name + "Response";
// RequestName = rma.RequestElementName;
// ResponseName = rma.ResponseElementName;
RequestNamespace = rma.RequestNamespace;
ResponseNamespace = rma.ResponseNamespace;
ParameterStyle = SoapParameterStyle.Wrapped;
OneWay = rma.OneWay;
SoapBindingStyle = SoapBindingStyle.Rpc;
// For RPC calls, make all arguments be part of the empty namespace
optional_ns = new XmlElementAttribute();
optional_ns.Namespace = "";
}
if (OneWay)
{
if (source.ReturnType != typeof(void))
{
throw new Exception("OneWay methods should not have a return value.");
}
if (source.OutParameters.Length != 0)
{
throw new Exception("OneWay methods should not have out/ref parameters.");
}
}
BindingInfo binfo = parent.GetBinding(Binding);
if (binfo == null)
{
throw new InvalidOperationException("Type '" + parent.Type + "' is missing WebServiceBinding attribute that defines a binding named '" + Binding + "'.");
}
string serviceNamespace = binfo.Namespace;
if (RequestNamespace == "")
{
RequestNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use);
}
if (ResponseNamespace == "")
{
ResponseNamespace = parent.LogicalType.GetWebServiceNamespace(serviceNamespace, Use);
}
if (RequestName == "")
{
RequestName = Name;
}
if (ResponseName == "")
{
ResponseName = Name + "Response";
}
if (Action == null)
{
Action = serviceNamespace.EndsWith("/") ? (serviceNamespace + Name) : (serviceNamespace + "/" + Name);
}
bool hasWrappingElem = (ParameterStyle == SoapParameterStyle.Wrapped);
bool writeAccessors = (SoapBindingStyle == SoapBindingStyle.Rpc);
XmlReflectionMember [] in_members = BuildRequestReflectionMembers(optional_ns);
XmlReflectionMember [] out_members = BuildResponseReflectionMembers(optional_ns);
if (Use == SoapBindingUse.Literal)
{
xmlImporter.IncludeTypes(source.CustomAttributeProvider);
InputMembersMapping = xmlImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem);
OutputMembersMapping = xmlImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem);
}
else
{
soapImporter.IncludeTypes(source.CustomAttributeProvider);
InputMembersMapping = soapImporter.ImportMembersMapping(RequestName, RequestNamespace, in_members, hasWrappingElem, writeAccessors);
OutputMembersMapping = soapImporter.ImportMembersMapping(ResponseName, ResponseNamespace, out_members, hasWrappingElem, writeAccessors);
}
requestSerializerId = parent.RegisterSerializer(InputMembersMapping);
responseSerializerId = parent.RegisterSerializer(OutputMembersMapping);
object[] o = source.GetCustomAttributes(typeof(SoapHeaderAttribute));
ArrayList allHeaderList = new ArrayList(o.Length);
ArrayList inHeaderList = new ArrayList(o.Length);
ArrayList outHeaderList = new ArrayList(o.Length);
ArrayList faultHeaderList = new ArrayList();
SoapHeaderDirection unknownHeaderDirections = (SoapHeaderDirection)0;
for (int i = 0; i < o.Length; i++)
{
SoapHeaderAttribute att = (SoapHeaderAttribute)o[i];
MemberInfo[] mems = source.DeclaringType.GetMember(att.MemberName);
if (mems.Length == 0)
{
throw new InvalidOperationException("Member " + att.MemberName + " not found in class " + source.DeclaringType.FullName + ".");
}
HeaderInfo header = new HeaderInfo(mems[0], att);
allHeaderList.Add(header);
if (!header.Custom)
{
if ((header.Direction & SoapHeaderDirection.In) != 0)
{
inHeaderList.Add(header);
}
if ((header.Direction & SoapHeaderDirection.Out) != 0)
{
outHeaderList.Add(header);
}
if ((header.Direction & SoapHeaderDirection.Fault) != 0)
{
faultHeaderList.Add(header);
}
}
else
{
unknownHeaderDirections |= header.Direction;
}
}
Headers = (HeaderInfo[])allHeaderList.ToArray(typeof(HeaderInfo));
if (inHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.In) != 0)
{
InHeaders = (HeaderInfo[])inHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(InHeaders);
if (Use == SoapBindingUse.Literal)
{
InputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
InputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
requestHeadersSerializerId = parent.RegisterSerializer(InputHeaderMembersMapping);
}
if (outHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Out) != 0)
{
OutHeaders = (HeaderInfo[])outHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(OutHeaders);
if (Use == SoapBindingUse.Literal)
{
OutputHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
OutputHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
responseHeadersSerializerId = parent.RegisterSerializer(OutputHeaderMembersMapping);
}
if (faultHeaderList.Count > 0 || (unknownHeaderDirections & SoapHeaderDirection.Fault) != 0)
{
FaultHeaders = (HeaderInfo[])faultHeaderList.ToArray(typeof(HeaderInfo));
XmlReflectionMember[] members = BuildHeadersReflectionMembers(FaultHeaders);
if (Use == SoapBindingUse.Literal)
{
FaultHeaderMembersMapping = xmlImporter.ImportMembersMapping("", RequestNamespace, members, false);
}
else
{
FaultHeaderMembersMapping = soapImporter.ImportMembersMapping("", RequestNamespace, members, false, false);
}
faultHeadersSerializerId = parent.RegisterSerializer(FaultHeaderMembersMapping);
}
SoapExtensions = SoapExtension.GetMethodExtensions(source);
}