public void WriteTo(XmlDictionaryWriter writer) { writer.WriteStartElement(XmlEncryptionStrings.Prefix, ElementName, XD.XmlEncryptionDictionary.Namespace); if (this.algorithmDictionaryString != null) { writer.WriteStartAttribute(XD.XmlSignatureDictionary.Algorithm, null); writer.WriteString(this.algorithmDictionaryString); writer.WriteEndAttribute(); } else { writer.WriteAttributeString(XD.XmlSignatureDictionary.Algorithm, null, this.algorithm); } if (this.algorithm == XD.SecurityAlgorithmDictionary.RsaOaepKeyWrap.Value) { writer.WriteStartElement(XmlSignatureStrings.Prefix, XD.XmlSignatureDictionary.DigestMethod, XD.XmlSignatureDictionary.Namespace); writer.WriteStartAttribute(XD.XmlSignatureDictionary.Algorithm, null); writer.WriteString(XD.SecurityAlgorithmDictionary.Sha1Digest); writer.WriteEndAttribute(); writer.WriteEndElement(); } writer.WriteEndElement(); // EncryptionMethod }
public virtual void WriteXml(XmlDictionaryWriter writer, SamlSerializer samlSerializer, SecurityTokenSerializer keyInfoSerializer) { this.CheckObjectValidity(); if (writer == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("writer")); } if (samlSerializer == null) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("samlSerializer")); } SamlDictionary samlDictionary = samlSerializer.DictionaryManager.SamlDictionary; writer.WriteStartElement(samlDictionary.PreferredPrefix.Value, samlDictionary.Action, samlDictionary.Namespace); if (this.ns != null) { writer.WriteStartAttribute(samlDictionary.ActionNamespaceAttribute, null); writer.WriteString(this.ns); writer.WriteEndAttribute(); } writer.WriteString(this.action); writer.WriteEndElement(); }
public void UseCase2 () { XmlDictionary dic = new XmlDictionary (); MemoryStream ms = new MemoryStream (); XmlDictionaryWriter w = XmlDictionaryWriter.CreateBinaryWriter (ms, dic, null); XmlDictionaryString empty = dic.Add (String.Empty); // empty ns w.WriteStartElement (dic.Add ("FOO"), empty); // non-dic string w.WriteStartElement ("BAR"); // second time ns w.WriteStartElement (dic.Add ("FOO"), empty); // first time dic string but prior non-dic name existed w.WriteStartElement (dic.Add ("BAR"), empty); w.WriteEndElement (); w.WriteEndElement (); w.WriteEndElement (); // dicstr w/ ns with empty prefix w.WriteStartElement (dic.Add ("BAR"), dic.Add ("urn:bar")); // with prefix w.WriteStartElement ("ppp", dic.Add ("BAR"), dic.Add ("urn:bar")); w.WriteChars (new char [] {'x', 'y', 'z'}, 0, 3); // w.WriteString ("xyz"); // the same as WriteChars() w.WriteEndElement (); w.WriteString ("bbbb"); w.WriteCData ("ccc"); w.WriteValue (new Guid ("11112222333344445555666677778888")); w.WriteEndElement (); w.WriteStartElement ("FOO"); w.WriteStartAttribute ("AAA"); w.WriteValue (new Guid ("11112222333344445555666677778888")); w.WriteEndAttribute (); w.WriteStartAttribute ("BBB"); w.WriteValue (TimeSpan.Zero); w.WriteEndAttribute (); w.WriteStartAttribute ("CC"); w.WriteValue (new UniqueId ("uuid-00000000-0000-0000-0000-000000000000-1")); w.WriteEndAttribute (); w.WriteStartElement ("XX"); w.WriteValue (true); w.WriteValue (false); w.WriteEndElement (); w.WriteStartElement ("xx", "aaa", "urn:zzz"); w.WriteEndElement (); w.WriteEndElement (); w.Close (); Assert.AreEqual (usecase2_result, ms.ToArray ()); }
protected override void WriteAdditionalElements(XmlDictionaryWriter writer, DictionaryManager dictionaryManager) { if (this.carriedKeyName != null) { writer.WriteStartElement(EncryptedKey.CarriedKeyElementName, EncryptedType.NamespaceUri); writer.WriteString(this.carriedKeyName); writer.WriteEndElement(); } if (this.referenceList == null) { return; } this.referenceList.WriteTo(writer, dictionaryManager); }
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion) { string createdTime = GetCurrentServerTime().ToString("yyyy-MM-ddTHH:mm:ss.fffZ", CultureInfo.InvariantCulture); writer.WriteAttributeString("s", "mustUnderstand", null, "1"); writer.WriteStartElement("UsernameToken"); writer.WriteStartElement("Username"); writer.WriteString(_credential.UserName); writer.WriteEndElement(); writer.WriteStartElement("Password"); writer.WriteAttributeString("Type", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordDigest"); writer.WriteString(ComputePasswordDigest(_credential.Password, _token.GetNonceBytes(), createdTime)); writer.WriteEndElement(); writer.WriteStartElement("Nonce"); writer.WriteAttributeString("EncodingType", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary"); writer.WriteBase64(_token.GetNonceBytes(), 0, _token.GetNonceBytes().Length); writer.WriteEndElement(); writer.WriteStartElement("Created", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"); writer.WriteString(createdTime); writer.WriteEndElement(); writer.WriteEndElement(); writer.Flush(); }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { writer.WriteStartElement("root"); writer.WriteAttributeString("type", "object"); writer.WriteStartElement("ErrorMessage"); writer.WriteAttributeString("type", "string"); writer.WriteString(this.validationException.ValidationResult.ErrorMessage); writer.WriteEndElement(); writer.WriteStartElement("MemberNames"); writer.WriteAttributeString("type", "array"); foreach (var member in this.validationException.ValidationResult.MemberNames) { writer.WriteStartElement("item"); writer.WriteAttributeString("type", "string"); writer.WriteString(member); writer.WriteEndElement(); } writer.WriteEndElement(); writer.WriteEndElement(); }
public void WriteTo(XmlDictionaryWriter writer) { writer.WriteStartElement("e", EncryptedType.EncryptionMethodElement.ElementName, System.IdentityModel.XD.XmlEncryptionDictionary.Namespace); if (this.algorithmDictionaryString != null) { writer.WriteStartAttribute(System.IdentityModel.XD.XmlSignatureDictionary.Algorithm, (XmlDictionaryString)null); writer.WriteString(this.algorithmDictionaryString); writer.WriteEndAttribute(); } else { writer.WriteAttributeString(System.IdentityModel.XD.XmlSignatureDictionary.Algorithm, (XmlDictionaryString)null, this.algorithm); } if (this.algorithm == System.IdentityModel.XD.SecurityAlgorithmDictionary.RsaOaepKeyWrap.Value) { writer.WriteStartElement("", System.IdentityModel.XD.XmlSignatureDictionary.DigestMethod, System.IdentityModel.XD.XmlSignatureDictionary.Namespace); writer.WriteStartAttribute(System.IdentityModel.XD.XmlSignatureDictionary.Algorithm, (XmlDictionaryString)null); writer.WriteString(System.IdentityModel.XD.SecurityAlgorithmDictionary.Sha1Digest); writer.WriteEndAttribute(); writer.WriteEndElement(); } writer.WriteEndElement(); }
private void WriteSoap12Fault(XmlDictionaryWriter writer) { // NOTE: This default culture is a hack until a better localisation solution is // built. At this stage it assumes the current thread culture var defaultCulture = CultureInfo.CurrentCulture; var faultString = _faultStringOverride ?? (_exception.InnerException != null ? _exception.InnerException.Message : _exception.Message); var faultDetail = ExtractFaultDetailsAsXmlElement(_exception); var prefix = writer.LookupPrefix(Namespaces.SOAP12_ENVELOPE_NS) ?? "s"; writer.WriteStartElement(prefix, "Fault", Namespaces.SOAP12_ENVELOPE_NS); writer.WriteStartElement(prefix, "Code", Namespaces.SOAP12_ENVELOPE_NS); writer.WriteStartElement(prefix, "Value", Namespaces.SOAP12_ENVELOPE_NS); writer.WriteString(prefix + ":Sender"); writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteStartElement(prefix, "Reason", Namespaces.SOAP12_ENVELOPE_NS); writer.WriteStartElement(prefix, "Text", Namespaces.SOAP12_ENVELOPE_NS); writer.WriteAttributeString("xml", "lang", null, defaultCulture.IetfLanguageTag); writer.WriteString(faultString); writer.WriteEndElement(); writer.WriteEndElement(); if (faultDetail != null) { writer.WriteStartElement(prefix, "Detail", Namespaces.SOAP12_ENVELOPE_NS); faultDetail.WriteTo(writer); writer.WriteEndElement(); } writer.WriteEndElement(); }
public override void WriteTo(XmlDictionaryWriter writer, DictionaryManager dictionaryManager) { XmlDictionaryString localName = this.isCanonicalizationMethod ? dictionaryManager.XmlSignatureDictionary.CanonicalizationMethod : dictionaryManager.XmlSignatureDictionary.Transform; XmlDictionaryString str2 = this.includeComments ? dictionaryManager.SecurityAlgorithmDictionary.ExclusiveC14nWithComments : dictionaryManager.SecurityAlgorithmDictionary.ExclusiveC14n; writer.WriteStartElement(this.prefix, localName, dictionaryManager.XmlSignatureDictionary.Namespace); writer.WriteStartAttribute(dictionaryManager.XmlSignatureDictionary.Algorithm, null); if (str2 != null) { writer.WriteString(str2); } else { writer.WriteString(str2.Value); } writer.WriteEndAttribute(); if (this.InclusiveNamespacesPrefixList != null) { writer.WriteStartElement(this.inclusiveListElementPrefix, dictionaryManager.ExclusiveC14NDictionary.InclusiveNamespaces, dictionaryManager.ExclusiveC14NDictionary.Namespace); writer.WriteAttributeString(dictionaryManager.ExclusiveC14NDictionary.PrefixList, null, this.InclusiveNamespacesPrefixList); writer.WriteEndElement(); } writer.WriteEndElement(); }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { writer.WriteStartElement("root"); writer.WriteAttributeString("type", "object"); XElement root = exMsg.Root; foreach (XElement el in root.Descendants()) { writer.WriteStartElement(el.Name.ToString()); writer.WriteAttributeString("type", "string"); writer.WriteString(el.Value.ToString()); writer.WriteEndElement(); } writer.WriteEndElement(); }
public override void WriteTo(XmlDictionaryWriter writer, DictionaryManager dictionaryManager) { string prefix = ""; XmlDictionaryString namespaceUri = dictionaryManager.XmlSignatureDictionary.Namespace; writer.WriteStartElement(prefix, dictionaryManager.XmlSignatureDictionary.SignedInfo, namespaceUri); if (base.Id != null) { writer.WriteAttributeString(dictionaryManager.UtilityDictionary.IdAttribute, null, base.Id); } base.WriteCanonicalizationMethod(writer, dictionaryManager); base.WriteSignatureMethod(writer, dictionaryManager); for (int i = 0; i < this.count; i++) { writer.WriteStartElement(prefix, dictionaryManager.XmlSignatureDictionary.Reference, namespaceUri); writer.WriteStartAttribute(dictionaryManager.XmlSignatureDictionary.URI, null); writer.WriteString("#"); writer.WriteString(this.references[i].id); writer.WriteEndAttribute(); writer.WriteStartElement(prefix, dictionaryManager.XmlSignatureDictionary.Transforms, namespaceUri); if (this.addEnvelopedSignatureTransform) { writer.WriteStartElement(prefix, dictionaryManager.XmlSignatureDictionary.Transform, namespaceUri); writer.WriteStartAttribute(dictionaryManager.XmlSignatureDictionary.Algorithm, null); writer.WriteString(dictionaryManager.XmlSignatureDictionary.EnvelopedSignature); writer.WriteEndAttribute(); writer.WriteEndElement(); } writer.WriteStartElement(prefix, dictionaryManager.XmlSignatureDictionary.Transform, namespaceUri); writer.WriteStartAttribute(dictionaryManager.XmlSignatureDictionary.Algorithm, null); writer.WriteString(dictionaryManager.SecurityAlgorithmDictionary.ExclusiveC14n); writer.WriteEndAttribute(); writer.WriteEndElement(); writer.WriteEndElement(); writer.WriteStartElement(prefix, dictionaryManager.XmlSignatureDictionary.DigestMethod, namespaceUri); writer.WriteStartAttribute(dictionaryManager.XmlSignatureDictionary.Algorithm, null); if (this.digestMethodDictionaryString != null) { writer.WriteString(this.digestMethodDictionaryString); } else { writer.WriteString(this.digestMethod); } writer.WriteEndAttribute(); writer.WriteEndElement(); byte[] digest = this.references[i].digest; writer.WriteStartElement(prefix, dictionaryManager.XmlSignatureDictionary.DigestValue, namespaceUri); writer.WriteBase64(digest, 0, digest.Length); writer.WriteEndElement(); writer.WriteEndElement(); } writer.WriteEndElement(); }
internal static void Serialize(MessageDictionary messageDictionary, XmlDictionaryWriter writer) { Requires.NotNull(messageDictionary, "messageDictionary"); Requires.NotNull(writer, "writer"); writer.WriteStartElement("root"); writer.WriteAttributeString("type", "object"); foreach (var pair in messageDictionary) { bool include = false; string type = "string"; MessagePart partDescription; if (messageDictionary.Description.Mapping.TryGetValue(pair.Key, out partDescription)) { Assumes.True(partDescription != null); if (partDescription.IsRequired || partDescription.IsNondefaultValueSet(messageDictionary.Message)) { include = true; Type formattingType = partDescription.PreferredFormattingType; if (IsNumeric(formattingType)) { type = "number"; } else if (formattingType.IsAssignableFrom(typeof(bool))) { type = "boolean"; } } } else { // This is extra data. We always write it out. include = true; } if (include) { writer.WriteStartElement(pair.Key); writer.WriteAttributeString("type", type); writer.WriteString(pair.Value); writer.WriteEndElement(); } } writer.WriteEndElement(); }
public void WriteTo(XmlDictionaryWriter writer, DictionaryManager dictionaryManager) { writer.WriteStartElement(this.prefix, dictionaryManager.XmlSignatureDictionary.SignatureValue, dictionaryManager.XmlSignatureDictionary.Namespace); if (this.id != null) { writer.WriteAttributeString(dictionaryManager.UtilityDictionary.IdAttribute, null, this.id); } if (this.signatureText != null) { writer.WriteString(this.signatureText); } else { writer.WriteBase64(this.signatureValue, 0, this.signatureValue.Length); } writer.WriteEndElement(); }
public void WriteTo(XmlDictionaryWriter writer) { writer.WriteStartElement(this.coordinationStrings.Prefix, this.coordinationXmlDictionaryStrings.Register, this.coordinationXmlDictionaryStrings.Namespace); XmlDictionaryString str = WSAtomicTransactionStrings.ProtocolToWellKnownName(this.Protocol, this.protocolVersion); writer.WriteStartElement(this.coordinationXmlDictionaryStrings.Protocol, this.coordinationXmlDictionaryStrings.Namespace); writer.WriteString(str); writer.WriteEndElement(); this.ParticipantProtocolService.WriteTo(MessagingVersionHelper.AddressingVersion(this.protocolVersion), writer, this.coordinationXmlDictionaryStrings.ParticipantProtocolService, this.coordinationXmlDictionaryStrings.Namespace); if (this.Loopback != Guid.Empty) { writer.WriteStartElement("mstx", XD.DotNetAtomicTransactionExternalDictionary.Loopback, XD.DotNetAtomicTransactionExternalDictionary.Namespace); writer.WriteValue(this.Loopback); writer.WriteEndElement(); } writer.WriteEndElement(); }
protected override void OnBodyToString(XmlDictionaryWriter writer) { long? contentLength = this.GetHttpContentLength(); string contentString = null; if (this.IsRequest) { contentString = contentLength.HasValue ? SR.MessageBodyIsHttpRequestMessageWithKnownContentLength(contentLength.Value) : SR.MessageBodyIsHttpRequestMessageWithUnknownContentLength; } else { contentString = contentLength.HasValue ? SR.MessageBodyIsHttpResponseMessageWithKnownContentLength(contentLength.Value) : SR.MessageBodyIsHttpResponseMessageWithUnknownContentLength; } writer.WriteString(contentString); }
private void WriteFaultCodeElement(XmlDictionaryWriter writer, FaultCode code, string localName) { var prefix = writer.LookupPrefix(_constants.EnvelopeNamespace); if (!string.IsNullOrEmpty(code.Namespace) && code.Namespace != _constants.EnvelopeNamespace) { prefix = writer.LookupPrefix(code.Namespace) ?? "custom"; } var name = code.Name; writer.WriteStartElement(localName, _constants.EnvelopeNamespace); writer.WriteStartElement("Value", _constants.EnvelopeNamespace); if (!code.IsPredefinedFault) { if (prefix == "custom") { writer.WriteXmlnsAttribute(prefix, code.Namespace); } } else { if (code.IsReceiverFault) { name = "Receiver"; } if (code.IsSenderFault) { name = "Sender"; } } writer.WriteString($"{prefix}:{name}"); writer.WriteEndElement(); if (code.SubCode != null) { WriteFaultCodeElement(writer, code.SubCode, "Subcode"); } writer.WriteEndElement(); }
public void SetDecryptedBody(byte[] decryptedBodyContent) { if (this.state != BodyState.Buffered) { throw TraceUtility.ThrowHelperError(this.CreateBadStateException("SetDecryptedBody"), this); } MemoryStream stream = new MemoryStream(); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream); writer.WriteStartElement(this.envelopePrefix, XD.MessageDictionary.Envelope, this.Version.Envelope.DictionaryNamespace); XmlAttributeHolder.WriteAttributes(this.envelopeAttributes, writer); writer.WriteStartElement(this.bodyPrefix, XD.MessageDictionary.Body, this.Version.Envelope.DictionaryNamespace); XmlAttributeHolder.WriteAttributes(this.bodyAttributes, writer); writer.WriteString(" "); writer.WriteEndElement(); writer.WriteEndElement(); writer.Flush(); this.decryptedBuffer = ContextImportHelper.SpliceBuffers(decryptedBodyContent, stream.GetBuffer(), (int)stream.Length, 2); this.bodyDecrypted = true; this.state = BodyState.Decrypted; }
private void WriteUserNamePassword(XmlDictionaryWriter writer, string id, string userName, string password) { writer.WriteStartElement(XD.SecurityJan2004Dictionary.Prefix.Value, XD.SecurityJan2004Dictionary.UserNameTokenElement, XD.SecurityJan2004Dictionary.Namespace); // <wsse:UsernameToken writer.WriteAttributeString(XD.UtilityDictionary.Prefix.Value, XD.UtilityDictionary.IdAttribute, XD.UtilityDictionary.Namespace, id); // wsu:Id="..." writer.WriteElementString(XD.SecurityJan2004Dictionary.Prefix.Value, XD.SecurityJan2004Dictionary.UserNameElement, XD.SecurityJan2004Dictionary.Namespace, userName); // ><wsse:Username>...</wsse:Username> if (password != null) { writer.WriteStartElement(XD.SecurityJan2004Dictionary.Prefix.Value, XD.SecurityJan2004Dictionary.PasswordElement, XD.SecurityJan2004Dictionary.Namespace); if (_tokenSerializer.EmitBspRequiredAttributes) { writer.WriteAttributeString(XD.SecurityJan2004Dictionary.TypeAttribute, null, SecurityJan2004Strings.UPTokenPasswordTextValue); } writer.WriteString(password); // <wsse:Password>...</wsse:Password> writer.WriteEndElement(); } writer.WriteEndElement(); // </wsse:UsernameToken> }
public void SerializePrimitive(Type type, object graph, QName qname) { string label; if (TrySerializeAsReference(false, graph, out label)) { return; } if (label != null) { Writer.WriteAttributeString("z", "Id", KnownTypeCollection.MSSimpleNamespace, label); } bool isDateTimeOffset = false; // Handle DateTimeOffset type and DateTimeOffset? if (type == typeof(DateTimeOffset)) { isDateTimeOffset = true; } else if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>)) { isDateTimeOffset = type.GetGenericArguments() [0] == typeof(DateTimeOffset); } // It is the only exceptional type that does not serialize to string but serializes into complex element. if (isDateTimeOffset) { var v = (DateTimeOffset)graph; writer.WriteStartElement("DateTime", KnownTypeCollection.DefaultClrNamespaceSystem); SerializePrimitive(typeof(DateTime), DateTime.SpecifyKind(v.DateTime.Subtract(v.Offset), DateTimeKind.Utc), KnownTypeCollection.GetPredefinedTypeName(typeof(DateTime))); writer.WriteEndElement(); writer.WriteStartElement("OffsetMinutes", KnownTypeCollection.DefaultClrNamespaceSystem); SerializePrimitive(typeof(int), v.Offset.TotalMinutes, KnownTypeCollection.GetPredefinedTypeName(typeof(int))); writer.WriteEndElement(); } else { writer.WriteString(KnownTypeCollection.PredefinedTypeObjectToString(graph)); } }
public static void SerializeStruct(XmlDictionaryWriter writer, object value) { Type valueType = value.GetType(); Dictionary <string, MemberInfo> dataMembers = GetDataMembers(valueType); if (valueType.IsDefined(typeof(DataContractAttribute), false)) { writer.WriteStartElement(XmlRpcProtocol.Struct); foreach (KeyValuePair <string, MemberInfo> member in dataMembers) { object elementValue = null; if (member.Value is PropertyInfo) { elementValue = ((PropertyInfo)member.Value).GetValue(value, BindingFlags.Instance | BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.NonPublic, null, null, CultureInfo.CurrentCulture); } else if (member.Value is FieldInfo) { elementValue = ((FieldInfo)member.Value).GetValue(value); } if (elementValue != null) { writer.WriteStartElement(XmlRpcProtocol.Member); writer.WriteStartElement(XmlRpcProtocol.Name); writer.WriteString(member.Key); writer.WriteEndElement(); writer.WriteStartElement(XmlRpcProtocol.Value); Serialize(writer, elementValue); writer.WriteEndElement(); // value writer.WriteEndElement(); // member } } writer.WriteEndElement(); // struct } }
//</snippet6> //<snippet7> public static void WriteObjectContentInDocument(string path) { // Create the object to serialize. Person p = new Person("Lynn", "Tsoflias", 9876); // Create the writer. FileStream fs = new FileStream(path, FileMode.Create); XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs); NetDataContractSerializer ser = new NetDataContractSerializer(); // Use the writer to start a document. writer.WriteStartDocument(true); // Use the writer to write the root element. writer.WriteStartElement("Company"); // Use the writer to write an element. writer.WriteElementString("Name", "Microsoft"); // Use the serializer to write the start, content, // and end data. ser.WriteStartObject(writer, p); writer.WriteStartAttribute("localName"); writer.WriteString("My Value"); writer.WriteEndAttribute(); ser.WriteObjectContent(writer, p); ser.WriteEndObject(writer); // Use the writer to write the end element // and end of the document. writer.WriteEndElement(); writer.WriteEndDocument(); // Close and release the writer resources. writer.Flush(); fs.Flush(); fs.Close(); }
public void WriteTo(XmlDictionaryWriter writer) { writer.WriteStartElement(this.coordinationStrings.Prefix, this.coordinationXmlDictionaryStrings.CreateCoordinationContext, this.coordinationXmlDictionaryStrings.Namespace); if (this.expiresPresent) { writer.WriteStartElement(this.coordinationXmlDictionaryStrings.Expires, this.coordinationXmlDictionaryStrings.Namespace); writer.WriteValue((long)this.Expires); writer.WriteEndElement(); } if (this.CurrentContext != null) { this.CurrentContext.WriteTo(writer, this.coordinationXmlDictionaryStrings.CurrentContext, this.coordinationXmlDictionaryStrings.Namespace); } writer.WriteStartElement(this.coordinationXmlDictionaryStrings.CoordinationType, this.coordinationXmlDictionaryStrings.Namespace); writer.WriteString(this.atomicTransactionXmlDictionaryStrings.Namespace); writer.WriteEndElement(); if (this.IsolationLevel != System.Transactions.IsolationLevel.Serializable) { writer.WriteStartElement("mstx", XD.DotNetAtomicTransactionExternalDictionary.IsolationLevel, XD.DotNetAtomicTransactionExternalDictionary.Namespace); writer.WriteValue((int)this.IsolationLevel); writer.WriteEndElement(); } writer.WriteEndElement(); }
public void WriteJson(XmlDictionaryWriter writer) { writer.WriteStartElement(this.Name); writer.WriteAttributeString("type", "object"); writer.WriteStartElement(MetadataStrings.TypeString); writer.WriteAttributeString("type", "string"); writer.WriteString(String.Format("{0}{1}{2}", this.TypeName, MetadataStrings.NamespaceMarker, this.TypeNamespace)); writer.WriteEndElement(); if (this.IsReadOnly) { writer.WriteStartElement(MetadataStrings.ReadOnlyString); writer.WriteAttributeString("type", "boolean"); writer.WriteValue(this.IsReadOnly); writer.WriteEndElement(); } if (this.IsArray) { writer.WriteStartElement(MetadataStrings.ArrayString); writer.WriteAttributeString("type", "boolean"); writer.WriteValue(this.IsArray); writer.WriteEndElement(); } if (this.Association != null) { writer.WriteStartElement(MetadataStrings.AssociationString); writer.WriteAttributeString("type", "object"); this.Association.WriteJson(writer); writer.WriteEndElement(); } writer.WriteEndElement(); }
public void WriteContentsTo( AddressingVersion addressingVersion, XmlDictionaryWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } #if NET_2_1 if (addressingVersion == AddressingVersion.None) { writer.WriteString(Uri.AbsoluteUri); } else { writer.WriteStartElement("Address", addressingVersion.Namespace); writer.WriteString(Uri.AbsoluteUri); writer.WriteEndElement(); } #else if (addressingVersion == AddressingVersion.None) { writer.WriteString(Uri.AbsoluteUri); } else { writer.WriteStartElement("Address", addressingVersion.Namespace); writer.WriteString(Uri.AbsoluteUri); writer.WriteEndElement(); if (Identity == null) { return; } if (Headers != null) { foreach (AddressHeader ah in Headers) { ah.WriteAddressHeader(writer); } } writer.WriteStartElement("Identity", Constants.WsaIdentityUri); X509CertificateEndpointIdentity x509 = Identity as X509CertificateEndpointIdentity; if (x509 != null) { KeyInfo ki = new KeyInfo(); KeyInfoX509Data x = new KeyInfoX509Data(); foreach (X509Certificate2 cert in x509.Certificates) { x.AddCertificate(cert); } ki.AddClause(x); ki.GetXml().WriteTo(writer); } else { DataContractSerializer ds = new DataContractSerializer(Identity.IdentityClaim.GetType()); ds.WriteObject(writer, Identity.IdentityClaim); } writer.WriteEndElement(); } #endif }
public void WriteValue(XmlDictionaryWriter writer, object value) { if (_isArray) { switch (_typeCode) { case TypeCode.Byte: { byte[] arrayValue = (byte[])value; writer.WriteBase64(arrayValue, 0, arrayValue.Length); } break; case TypeCode.Boolean: { bool[] arrayValue = (bool[])value; writer.WriteArray(null, _itemName, _itemNamespace, arrayValue, 0, arrayValue.Length); } break; case TypeCode.DateTime: { DateTime[] arrayValue = (DateTime[])value; writer.WriteArray(null, _itemName, _itemNamespace, arrayValue, 0, arrayValue.Length); } break; case TypeCode.Decimal: { decimal[] arrayValue = (decimal[])value; writer.WriteArray(null, _itemName, _itemNamespace, arrayValue, 0, arrayValue.Length); } break; case TypeCode.Int32: { Int32[] arrayValue = (Int32[])value; writer.WriteArray(null, _itemName, _itemNamespace, arrayValue, 0, arrayValue.Length); } break; case TypeCode.Int64: { Int64[] arrayValue = (Int64[])value; writer.WriteArray(null, _itemName, _itemNamespace, arrayValue, 0, arrayValue.Length); } break; case TypeCode.Single: { float[] arrayValue = (float[])value; writer.WriteArray(null, _itemName, _itemNamespace, arrayValue, 0, arrayValue.Length); } break; case TypeCode.Double: { double[] arrayValue = (double[])value; writer.WriteArray(null, _itemName, _itemNamespace, arrayValue, 0, arrayValue.Length); } break; default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxInvalidUseOfPrimitiveOperationFormatter)); } } else { switch (_typeCode) { case TypeCode.Boolean: writer.WriteValue((bool)value); break; case TypeCode.DateTime: writer.WriteValue((DateTime)value); break; case TypeCode.Decimal: writer.WriteValue((Decimal)value); break; case TypeCode.Double: writer.WriteValue((double)value); break; case TypeCode.Int32: writer.WriteValue((int)value); break; case TypeCode.Int64: writer.WriteValue((long)value); break; case TypeCode.Single: writer.WriteValue((float)value); break; case TypeCode.String: writer.WriteString((string)value); break; default: throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.SFxInvalidUseOfPrimitiveOperationFormatter)); } } }
protected override void OnWriteHeaderContents(XmlDictionaryWriter writer, MessageVersion messageVersion) { writer.WriteString(this.RootId); }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { writer.WriteString("-- message body is raw binary --"); }
void WriteContentsToNone(XmlDictionaryWriter writer) { writer.WriteString(Uri.AbsoluteUri); }
protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { writer.WriteString(_bodyContent); }
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(); }
// Methods of BodyWriter /// <summary> /// Writes out an XML representation of the instance. /// </summary> /// <param name="writer">The writer to be used to write out the XML content</param> protected override void OnWriteBodyContents(XmlDictionaryWriter writer) { // Write out the wst:RequestSecurityToken start tag writer.WriteStartElement(Constants.Trust.Elements.RequestSecurityToken, Constants.Trust.NamespaceUri); // If we have a non-null, non-empty tokenType... if (this.TokenType != null && this.TokenType.Length > 0) { // Write out the wst:TokenType start tag writer.WriteStartElement(Constants.Trust.Elements.TokenType, Constants.Trust.NamespaceUri); // Write out the tokenType string writer.WriteString(this.TokenType); writer.WriteEndElement(); // wst:TokenType } // If we have a non-null, non-empty requestType... if (this.requestType != null && this.requestType.Length > 0) { // Write out the wst:RequestType start tag writer.WriteStartElement(Constants.Trust.Elements.RequestType, Constants.Trust.NamespaceUri); // Write out the requestType string writer.WriteString(this.requestType); writer.WriteEndElement(); // wst:RequestType } // If we have a non-null appliesTo if (this.AppliesTo != null) { // Write out the wsp:AppliesTo start tag writer.WriteStartElement(Constants.Policy.Elements.AppliesTo, Constants.Policy.NamespaceUri); // Write the appliesTo in WS-Addressing 1.0 format this.AppliesTo.WriteTo(AddressingVersion.WSAddressing10, writer); writer.WriteEndElement(); // wsp:AppliesTo } if (this.requestorEntropy != null) { writer.WriteStartElement(Constants.Trust.Elements.Entropy, Constants.Trust.NamespaceUri); BinarySecretSecurityToken bsst = this.requestorEntropy as BinarySecretSecurityToken; if (bsst != null) { writer.WriteStartElement(Constants.Trust.Elements.BinarySecret, Constants.Trust.NamespaceUri); byte[] key = bsst.GetKeyBytes(); writer.WriteBase64(key, 0, key.Length); writer.WriteEndElement(); // wst:BinarySecret } writer.WriteEndElement(); // wst:Entropy } if (this.keyType != null && this.keyType.Length > 0) { writer.WriteStartElement(Constants.Trust.Elements.KeyType, Constants.Trust.NamespaceUri); writer.WriteString(this.keyType); writer.WriteEndElement(); // wst:KeyType } if (this.KeySize > 0) { writer.WriteStartElement(Constants.Trust.Elements.KeySize, Constants.Trust.NamespaceUri); writer.WriteValue(this.KeySize); writer.WriteEndElement(); // wst:KeySize } writer.WriteEndElement(); // wst:RequestSecurityToken }