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"); }