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
}