protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
writer.WriteRaw(GetToken().OuterXml);
writer.WriteStartElement("Timestamp");
writer.WriteXmlnsAttribute("", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");
writer.WriteAttributeString("Id", "Timestamp-79");
//Created
writer.WriteStartElement("Created");
writer.WriteString(this.token.ValidFrom.ToString("yyyy-MM-ddTHH:mm:ssZ"));
writer.WriteEndElement();
//Expires
writer.WriteStartElement("Expires");
writer.WriteString(this.token.ValidTo.ToString("yyyy-MM-ddTHH:mm:ssZ"));
writer.WriteEndElement();
writer.WriteEndElement();
}
public void Serialize(Type type, object graph)
{
if (graph == null)
{
writer.WriteAttributeString("i", "nil", XmlSchema.InstanceNamespace, "true");
}
else if (type == typeof(XmlElement))
{
((XmlElement)graph).WriteTo(Writer);
}
else if (type == typeof(XmlNode []))
{
foreach (var xn in (XmlNode [])graph)
{
xn.WriteTo(Writer);
}
}
else
{
QName resolvedQName = null;
if (resolver != null)
{
XmlDictionaryString rname, rns;
if (resolver.TryResolveType(graph != null ? graph.GetType() : typeof(object), type, default_resolver, out rname, out rns))
{
resolvedQName = new QName(rname.Value, rns.Value);
}
}
Type actualType = graph.GetType();
SerializationMap map;
map = types.FindUserMap(actualType);
// For some collection types, the actual type does not matter. So get nominal serialization type instead.
// (The code below also covers the lines above, but I don't remove above lines to avoid extra search cost.)
if (map == null)
{
// FIXME: not sure if type.IsInterface is the correct condition to determine whether items are serialized with i:type or not. (e.g. bug #675144 server response).
actualType = types.GetSerializedType(type.IsInterface ? type : actualType);
map = types.FindUserMap(actualType);
}
// If it is still unknown, then register it.
if (map == null)
{
types.Add(actualType);
map = types.FindUserMap(actualType);
}
bool explicityType = false;
if (type != actualType)
{
// Check if underlying type of Nullable, mismatch the current type.
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
explicityType = (type.GetGenericArguments() [0] != actualType);
}
else
{
explicityType = true;
}
}
if (explicityType && (map == null || map.OutputXsiType))
{
QName qname = resolvedQName ?? types.GetXmlName(actualType);
string name = qname.Name;
string ns = qname.Namespace;
if (qname == QName.Empty)
{
name = XmlConvert.EncodeLocalName(actualType.Name);
ns = KnownTypeCollection.DefaultClrNamespaceBase + actualType.Namespace;
}
else if (XmlSchemaType.GetBuiltInSimpleType(new QName(qname.Name, XmlSchema.Namespace)) != null)
{
ns = XmlSchema.Namespace;
}
if (writer.LookupPrefix(ns) == null) // it goes first (extraneous, but it makes att order compatible)
{
writer.WriteXmlnsAttribute(null, ns);
}
writer.WriteStartAttribute("i", "type", XmlSchema.InstanceNamespace);
writer.WriteQualifiedName(name, ns);
writer.WriteEndAttribute();
}
QName predef = KnownTypeCollection.GetPredefinedTypeName(actualType);
if (predef != QName.Empty)
{
SerializePrimitive(type, graph, predef);
}
else
{
map.Serialize(graph, this);
}
}
}
public override void WriteStartObject(
XmlDictionaryWriter writer, object graph)
{
Type rootType = type;
if (root_name.Value == "")
{
throw new InvalidDataContractException("Type '" + type.ToString() +
"' cannot have a DataContract attribute Name set to null or empty string.");
}
if (graph == null)
{
if (names_filled)
{
writer.WriteStartElement(root_name.Value, root_ns.Value);
}
else
{
writer.WriteStartElement(root_name, root_ns);
}
writer.WriteAttributeString("i", "nil", XmlSchema.InstanceNamespace, "true");
return;
}
QName rootQName = null;
XmlDictionaryString name, ns;
var graphType = graph.GetType();
if (DataContractResolver != null && DataContractResolver.TryResolveType(graphType, type, default_resolver, out name, out ns))
{
rootQName = new QName(name.Value, ns.Value);
}
// It is error unless 1) TypeResolver resolved the type name, 2) the object is the exact type, 3) the object is known or 4) the type is primitive.
QName collectionQName;
if (KnownTypeCollection.IsInterchangeableCollectionType(type, graphType, out collectionQName))
{
graphType = type;
rootQName = collectionQName;
}
else if (graphType != type && rootQName == null && IsUnknownType(type, graphType))
{
throw new SerializationException(String.Format("Type '{0}' is unexpected. The type should either be registered as a known type, or DataContractResolver should be used.", graphType));
}
QName instName = rootQName;
rootQName = rootQName ?? known_types.GetQName(rootType);
QName graph_qname = known_types.GetQName(graphType);
known_types.Add(graphType);
if (names_filled)
{
writer.WriteStartElement(root_name.Value, root_ns.Value);
}
else
{
writer.WriteStartElement(root_name, root_ns);
}
if (rootQName != graph_qname || rootQName.Namespace != KnownTypeCollection.MSSimpleNamespace && !rootType.IsEnum)
{
//FIXME: Hack, when should the "i:type" be written?
//Not used in case of enums
writer.WriteXmlnsAttribute("i", XmlSchema.InstanceNamespace);
}
if (root_ns.Value != rootQName.Namespace)
{
if (rootQName.Namespace != KnownTypeCollection.MSSimpleNamespace)
{
writer.WriteXmlnsAttribute(null, rootQName.Namespace);
}
}
if (rootQName == graph_qname)
{
return;
}
/* Different names */
known_types.Add(rootType);
instName = instName ?? KnownTypeCollection.GetPredefinedTypeName(graphType);
if (instName == QName.Empty)
{
/* Not a primitive type */
instName = graph_qname;
}
else
{
/* FIXME: Hack, .. see test WriteObject7 () */
instName = new QName(instName.Name, XmlSchema.Namespace);
}
/* // disabled as it now generates extraneous i:type output.
* // output xsi:type as rootType is not equivalent to the graph's type.
* writer.WriteStartAttribute ("i", "type", XmlSchema.InstanceNamespace);
* writer.WriteQualifiedName (instName.Name, instName.Namespace);
* writer.WriteEndAttribute ();
*/
}
protected override void OnWriteStartFilterElement(XmlDictionaryWriter writer)
{
base.OnWriteStartFilterElement(writer);
writer.WriteAttributeString("Dialect", "http://schemas.microsoft.com/2008/1/ActiveDirectory/Dialect/LdapQuery");
writer.WriteXmlnsAttribute("adlq", "http://schemas.microsoft.com/2008/1/ActiveDirectory/Dialect/LdapQuery");
}
public static void TestC14NInclusivePrefixes()
{
TestCase tc = TestConfigHelper.GetTest("TestC14NInclusivePrefixes");
int count = 0;
foreach (var input in tc.Inputs)
{
count++;
string rwTypeStr = input.Arguments[0].Value;
ReaderWriterFactory.ReaderWriterType rwType = (ReaderWriterFactory.ReaderWriterType)Enum.Parse(typeof(ReaderWriterFactory.ReaderWriterType), rwTypeStr, true);
Encoding encoding = Encoding.GetEncoding(input.Arguments[1].Value);
bool mustSupportV14N = input.Arguments[2].Value.ToLower() == "true";
MemoryStream ms = new MemoryStream();
XmlWriter w = ReaderWriterFactory.CreateXmlWriter(rwType, ms, encoding);
XmlDictionaryWriter writer = w as XmlDictionaryWriter;
if (writer == null)
{
writer = XmlDictionaryWriter.CreateDictionaryWriter(w);
}
if (!writer.CanCanonicalize)
{
Assert.False(mustSupportV14N,
string.Format("Error, writer {0},{1} should support C14N, but it doesn't!", rwTypeStr, encoding.ToString()));
continue;
}
string myDefaultNamespace = "http://mynamespace";
string myNamespace1 = "http://mynamespace1";
string myNamespace2 = "http://mynamespace2";
string myNamespace3 = "http://mynamespace3";
string myNamespace4 = "http://mynamespace4";
writer.WriteStartElement("Root");
writer.WriteXmlnsAttribute("p1", myNamespace1);
writer.WriteAttributeString("p1", "a", null, "b");
writer.WriteStartElement("", "Element1", myDefaultNamespace);
writer.WriteAttributeString("p3", "c", myNamespace3, "d");
writer.WriteStartElement("Element2");
MemoryStream canonicalStream = new MemoryStream();
writer.StartCanonicalization(canonicalStream, false, new string[] { "p3", "p2", "p1", "" });
writer.WriteStartElement("pre", "Element3", myNamespace2);
writer.WriteAttributeString("pre2", "attrName", myNamespace4, "attrValue");
writer.WriteStartElement("Element4", "");
writer.WriteStartAttribute("attr1");
writer.WriteQualifiedName("foo", myNamespace1);
writer.WriteEndAttribute();
writer.WriteStartAttribute("attr2");
writer.WriteQualifiedName("bar", myNamespace3);
writer.WriteEndAttribute();
writer.WriteString("Hello world");
writer.WriteEndElement(); // Element4
writer.WriteEndElement(); // pre:Element3
writer.EndCanonicalization();
writer.WriteEndElement(); // Element2
writer.WriteEndElement(); // Element1
writer.WriteEndElement(); // Root
writer.Flush();
byte[] canonicalDoc = canonicalStream.ToArray();
byte[] fullDoc = ms.ToArray();
writer.Close(); // Finished creating the document
XmlDsigExcC14NTransform transform = new XmlDsigExcC14NTransform();
transform.InclusiveNamespacesPrefixList = "p3 p2 p1 #default";
transform.LoadInput(new MemoryStream(canonicalDoc));
Stream transformedOutput = transform.GetOutput(typeof(Stream)) as Stream;
byte[] outputFromSecurity = StreamToByteArray(transformedOutput);
//Finished creating the doc from the security class
Helper.DumpToFile(fullDoc);
Helper.DumpToFile(canonicalDoc);
Helper.DumpToFile(outputFromSecurity);
Assert.True(Enumerable.SequenceEqual(outputFromSecurity, canonicalDoc), $"TestC14NInclusivePrefixes test variation #{count} failed");
}
}
private void WriteXmlnsAttribute(XmlDictionaryWriter writer, string namespaceUri)
{
string prefix = _xmlNamespaceManager.LookupPrefix(namespaceUri);
writer.WriteXmlnsAttribute(prefix, namespaceUri);
}
// it only supports negotiation so far ...
protected override void OnWriteBodyContents(XmlDictionaryWriter w)
{
string ns = Constants.WstNamespace;
string nsu = Constants.WsuNamespace;
w.WriteStartElement("t", "RequestSecurityTokenResponse", ns);
w.WriteXmlnsAttribute("u", nsu);
w.WriteAttributeString("Context", Context);
if (Authenticator != null)
{
w.WriteStartElement("t", "Authenticator", ns);
w.WriteStartElement("t", "CombinedHash", ns);
w.WriteBase64(Authenticator, 0, Authenticator.Length);
w.WriteEndElement();
w.WriteEndElement();
}
if (TokenType != null)
{
w.WriteElementString("t", "TokenType", ns, TokenType);
}
if (RequestedSecurityToken != null)
{
w.WriteStartElement("t", "RequestedSecurityToken", ns);
serializer.WriteToken(w, RequestedSecurityToken);
w.WriteEndElement();
}
if (RequestedAttachedReference != null)
{
w.WriteStartElement("t", "RequestedAttachedReference", ns);
serializer.WriteKeyIdentifierClause(w, RequestedAttachedReference);
w.WriteEndElement();
}
if (RequestedUnattachedReference != null)
{
w.WriteStartElement("t", "RequestedUnattachedReference", ns);
serializer.WriteKeyIdentifierClause(w, RequestedUnattachedReference);
w.WriteEndElement();
}
if (RequestedProofToken != null)
{
w.WriteStartElement("t", "RequestedProofToken", ns);
if (RequestedProofToken is SecurityToken)
{
serializer.WriteToken(w, (SecurityToken)RequestedProofToken);
}
else if (RequestedProofToken is SecurityKeyIdentifierClause)
{
serializer.WriteKeyIdentifierClause(w, (SecurityKeyIdentifierClause)RequestedProofToken);
}
else
{
string ens = EncryptedXml.XmlEncNamespaceUrl;
w.WriteStartElement("e", "EncryptedKey", ens);
w.WriteStartElement("EncryptionMethod", ens);
w.WriteAttributeString("Algorithm", Constants.WstTlsnegoProofTokenType);
w.WriteEndElement();
w.WriteStartElement("CipherData", ens);
w.WriteStartElement("CipherValue", ens);
byte [] base64 = (byte [])RequestedProofToken;
w.WriteBase64(base64, 0, base64.Length);
w.WriteEndElement();
w.WriteEndElement();
w.WriteEndElement();
}
w.WriteEndElement();
}
if (Lifetime != null)
{
w.WriteStartElement("t", "Lifetime", ns);
if (Lifetime.Created != DateTime.MinValue)
{
w.WriteElementString("Created", nsu, XmlConvert.ToString(Lifetime.Created.ToUniversalTime(), Constants.LifetimeFormat));
}
if (Lifetime.Expires != DateTime.MaxValue)
{
w.WriteElementString("Expires", nsu, XmlConvert.ToString(Lifetime.Expires.ToUniversalTime(), Constants.LifetimeFormat));
}
w.WriteEndElement();
}
//w.WriteElementString ("t", "KeySize", ns, XmlConvert.ToString (KeySize));
if (BinaryExchange != null)
{
BinaryExchange.WriteTo(w);
}
w.WriteEndElement();
}
private void AddSchemaType(XmlDictionaryWriter writer, TypeToBuild toBuild, string name, bool isArray = false, string @namespace = null, bool isAttribute = false, bool isListWithoutWrapper = false)
{
var type = toBuild.Type;
var typeInfo = type.GetTypeInfo();
if (typeInfo.IsByRef)
{
type = typeInfo.GetElementType();
}
var typeName = type.GetSerializedTypeName();
if (writer.TryAddSchemaTypeFromXmlSchemaProviderAttribute(type, name, SoapSerializer.XmlSerializer, _xmlNamespaceManager))
{
return;
}
var underlyingType = Nullable.GetUnderlyingType(type);
//if type is a nullable non-system struct
if (underlyingType?.IsValueType == true && !underlyingType.IsEnum && underlyingType.Namespace != null && underlyingType.Namespace != "System" && !underlyingType.Namespace.StartsWith("System."))
{
AddSchemaType(writer, new TypeToBuild(underlyingType)
{
ChildElementName = toBuild.TypeName
}, name, isArray, @namespace, isAttribute);
return;
}
writer.WriteStartElement(isAttribute ? "attribute" : "element", Namespaces.XMLNS_XSD);
// Check for null, since we may use empty NS
if (@namespace != null)
{
writer.WriteAttributeString("targetNamespace", @namespace);
}
else if (typeInfo.IsEnum || underlyingType?.IsEnum == true ||
(typeInfo.IsValueType && typeInfo.Namespace != null && (typeInfo.Namespace == "System" || typeInfo.Namespace.StartsWith("System."))) ||
(type.Name == "String") ||
(type.Name == "Byte[]"))
{
XmlQualifiedName xsTypename;
if (typeof(DateTimeOffset).IsAssignableFrom(type))
{
if (string.IsNullOrEmpty(name))
{
name = typeName;
}
Namespaces.AddNamespaceIfNotAlreadyPresentAndGetPrefix(_xmlNamespaceManager, "nsdto", Namespaces.SYSTEM_NS);
xsTypename = new XmlQualifiedName(typeName, Namespaces.SYSTEM_NS);
_buildDateTimeOffset = true;
}
else if (typeInfo.IsEnum)
{
xsTypename = new XmlQualifiedName(typeName, _xmlNamespaceManager.LookupNamespace("tns"));
_enumToBuild.Enqueue(type);
}
else if (underlyingType?.IsEnum == true)
{
xsTypename = new XmlQualifiedName(underlyingType.GetSerializedTypeName(), _xmlNamespaceManager.LookupNamespace("tns"));
_enumToBuild.Enqueue(underlyingType);
}
else
{
if (underlyingType != null)
{
xsTypename = ResolveType(underlyingType);
writer.WriteAttributeString("nillable", "true");
}
else
{
xsTypename = ResolveType(type);
}
}
if (isAttribute)
{
// skip occurence
}
else if (isArray)
{
writer.WriteAttributeString("minOccurs", "0");
writer.WriteAttributeString("maxOccurs", "unbounded");
writer.WriteAttributeString("nillable", "true");
}
else
{
writer.WriteAttributeString("minOccurs", type.IsValueType ? "1" : "0");
writer.WriteAttributeString("maxOccurs", "1");
}
if (string.IsNullOrEmpty(name))
{
name = xsTypename.Name;
}
writer.WriteAttributeString("name", name);
writer.WriteAttributeString("type", $"{_xmlNamespaceManager.LookupPrefix(xsTypename.Namespace)}:{xsTypename.Name}");
}
else
{
var newTypeToBuild = new TypeToBuild(type);
if (!string.IsNullOrWhiteSpace(toBuild.ChildElementName))
{
newTypeToBuild.ChildElementName = toBuild.ChildElementName;
SetUniqueNameForDynamicType(newTypeToBuild);
}
writer.WriteAttributeString("minOccurs", "0");
if (isArray)
{
writer.WriteAttributeString("maxOccurs", "unbounded");
writer.WriteAttributeString("nillable", "true");
}
else
{
writer.WriteAttributeString("maxOccurs", "1");
}
if (type == typeof(Stream) || typeof(Stream).IsAssignableFrom(type))
{
name = "StreamBody";
writer.WriteAttributeString("name", name);
writer.WriteAttributeString("type", $"{_xmlNamespaceManager.LookupPrefix(Namespaces.XMLNS_XSD)}:base64Binary");
}
else if (type.IsArray)
{
if (string.IsNullOrEmpty(name))
{
name = typeName;
}
writer.WriteAttributeString("name", name);
writer.WriteAttributeString("type", "tns:" + newTypeToBuild.TypeName);
_complexTypeToBuild.Enqueue(newTypeToBuild);
}
else if (typeof(IEnumerable).IsAssignableFrom(type))
{
if (type.GetGenericType().Name == "String")
{
if (string.IsNullOrEmpty(name))
{
name = typeName;
}
var ns = $"q{_namespaceCounter++}";
writer.WriteXmlnsAttribute(ns, Namespaces.ARRAYS_NS);
writer.WriteAttributeString("name", name);
writer.WriteAttributeString("nillable", "true");
writer.WriteAttributeString("type", $"{ns}:{newTypeToBuild.TypeName}");
_arrayToBuild.Enqueue(type);
}
else
{
if (string.IsNullOrEmpty(name))
{
name = typeName;
}
writer.WriteAttributeString("name", name);
if (!isArray)
{
writer.WriteAttributeString("nillable", "true");
}
if (isListWithoutWrapper)
{
newTypeToBuild = new TypeToBuild(newTypeToBuild.Type.GetGenericType());
}
if (newTypeToBuild.IsAnonumous)
{
AddSchemaComplexType(writer, newTypeToBuild);
}
else
{
writer.WriteAttributeString("type", "tns:" + newTypeToBuild.TypeName);
_complexTypeToBuild.Enqueue(newTypeToBuild);
}
}
}
else if (toBuild.IsAnonumous)
{
writer.WriteAttributeString("name", name);
AddSchemaComplexType(writer, newTypeToBuild);
}
else
{
if (string.IsNullOrEmpty(name))
{
name = typeName;
}
writer.WriteAttributeString("name", name);
writer.WriteAttributeString("type", "tns:" + newTypeToBuild.TypeName);
_complexTypeToBuild.Enqueue(newTypeToBuild);
}
}
writer.WriteEndElement(); // element
}
private void AddTypes(XmlDictionaryWriter writer)
{
writer.WriteStartElement("wsdl", "types", Namespaces.WSDL_NS);
writer.WriteStartElement("schema", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("elementFormDefault", "qualified");
writer.WriteAttributeString("targetNamespace", TargetNameSpace);
writer.WriteStartElement("import", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("namespace", Namespaces.ARRAYS_NS);
writer.WriteEndElement();
writer.WriteStartElement("import", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("namespace", Namespaces.SYSTEM_NS);
writer.WriteEndElement();
foreach (var operation in _service.Operations)
{
// input parameters of operation
writer.WriteStartElement("element", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("name", operation.Name);
if (!operation.IsMessageContractRequest && operation.InParameters.Length == 0)
{
writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD);
writer.WriteEndElement();
}
else
{
WriteParameters(writer, operation.InParameters, operation.IsMessageContractRequest);
}
writer.WriteEndElement(); // element
// output parameter / return of operation
writer.WriteStartElement("element", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("name", operation.Name + "Response");
if (operation.DispatchMethod.ReturnType != typeof(void) && operation.DispatchMethod.ReturnType != typeof(Task))
{
var returnType = operation.DispatchMethod.ReturnType;
if (returnType.IsConstructedGenericType && returnType.GetGenericTypeDefinition() == typeof(Task <>))
{
returnType = returnType.GetGenericArguments().First();
}
var doWriteInlineType = true;
if (operation.IsMessageContractResponse)
{
doWriteInlineType = IsWrappedMessageContractType(returnType);
}
if (doWriteInlineType)
{
var elementAttribute = operation.DispatchMethod.ReturnType.GetCustomAttribute <XmlElementAttribute>();
var elementName = string.IsNullOrWhiteSpace(elementAttribute?.ElementName) ? null : elementAttribute.ElementName;
var xmlRootAttr = returnType.GetTypeInfo().GetCustomAttributes <XmlRootAttribute>().FirstOrDefault();
var typeRootName = string.IsNullOrWhiteSpace(xmlRootAttr?.ElementName) ? null : xmlRootAttr.ElementName;
var returnName = elementName
?? operation.DispatchMethod.ReturnParameter.GetCustomAttribute <MessageParameterAttribute>()?.Name
?? typeRootName
?? operation.Name + "Result";
writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD);
writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD);
AddSchemaType(writer, returnType, returnName);
writer.WriteEndElement();
writer.WriteEndElement();
}
else
{
var type = GetMessageContractBodyType(returnType);
writer.WriteAttributeString("type", "tns:" + type.Name);
_complexTypeToBuild.Enqueue(new TypeToBuild(returnType));
}
}
else
{
if (!operation.IsMessageContractResponse)
{
writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD);
writer.WriteEndElement();
}
}
WriteParameters(writer, operation.OutParameters, operation.IsMessageContractResponse);
writer.WriteEndElement(); // element
}
while (_complexTypeToBuild.Count > 0)
{
var toBuild = _complexTypeToBuild.Dequeue();
AddSchemaComplexType(writer, toBuild);
}
while (_enumToBuild.Count > 0)
{
Type toBuild = _enumToBuild.Dequeue();
if (toBuild.IsByRef)
{
toBuild = toBuild.GetElementType();
}
var typeName = toBuild.GetSerializedTypeName();
if (!_builtEnumTypes.Contains(toBuild.Name))
{
writer.WriteStartElement("simpleType", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("name", typeName);
writer.WriteStartElement("restriction", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("base", $"{_xmlNamespaceManager.LookupPrefix(Namespaces.XMLNS_XSD)}:string");
foreach (var value in Enum.GetValues(toBuild))
{
writer.WriteStartElement("enumeration", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("value", value.ToString());
writer.WriteEndElement(); // enumeration
}
writer.WriteEndElement(); // restriction
writer.WriteEndElement(); // simpleType
_builtEnumTypes.Add(toBuild.Name);
}
}
writer.WriteEndElement(); // schema
while (_arrayToBuild.Count > 0)
{
var toBuild = _arrayToBuild.Dequeue();
var toBuildName = toBuild.GetSerializedTypeName();
if (!_buildArrayTypes.Contains(toBuildName))
{
writer.WriteStartElement("schema", Namespaces.XMLNS_XSD);
writer.WriteXmlnsAttribute("tns", Namespaces.ARRAYS_NS);
writer.WriteAttributeString("elementFormDefault", "qualified");
writer.WriteAttributeString("targetNamespace", Namespaces.ARRAYS_NS);
writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("name", toBuildName);
writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD);
AddSchemaType(writer, toBuild.GetGenericType(), null, true);
writer.WriteEndElement(); // sequence
writer.WriteEndElement(); // complexType
writer.WriteStartElement("element", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("name", toBuildName);
writer.WriteAttributeString("nillable", "true");
writer.WriteAttributeString("type", "tns:" + toBuildName);
writer.WriteEndElement(); // element
writer.WriteEndElement(); // schema
_buildArrayTypes.Add(toBuildName);
}
}
if (_buildDateTimeOffset)
{
writer.WriteStartElement("schema", Namespaces.XMLNS_XSD);
writer.WriteXmlnsAttribute("tns", Namespaces.SYSTEM_NS);
writer.WriteAttributeString("elementFormDefault", "qualified");
writer.WriteAttributeString("targetNamespace", Namespaces.SYSTEM_NS);
writer.WriteStartElement("import", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("namespace", Namespaces.SERIALIZATION_NS);
writer.WriteEndElement();
writer.WriteStartElement("complexType", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("name", "DateTimeOffset");
writer.WriteStartElement("annotation", Namespaces.XMLNS_XSD);
writer.WriteStartElement("appinfo", Namespaces.XMLNS_XSD);
writer.WriteElementString("IsValueType", Namespaces.SERIALIZATION_NS, "true");
writer.WriteEndElement(); // appinfo
writer.WriteEndElement(); // annotation
writer.WriteStartElement("sequence", Namespaces.XMLNS_XSD);
AddSchemaType(writer, typeof(DateTime), "DateTime", false);
AddSchemaType(writer, typeof(short), "OffsetMinutes", false);
writer.WriteEndElement(); // sequence
writer.WriteEndElement(); // complexType
writer.WriteStartElement("element", Namespaces.XMLNS_XSD);
writer.WriteAttributeString("name", "DateTimeOffset");
writer.WriteAttributeString("nillable", "true");
writer.WriteAttributeString("type", "tns:DateTimeOffset");
writer.WriteEndElement();
writer.WriteEndElement(); // schema
}
writer.WriteEndElement(); // wsdl:types
}
protected override void OnWriteStartHeader(XmlDictionaryWriter writer, MessageVersion messageVersion)
{
writer.WriteStartElement("wsse", Name, Namespace);
writer.WriteXmlnsAttribute("wsu", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd");
writer.WriteAttributeString("s:mustUnderstand", "1");
}