/// <summary>
/// When overridden in a derived class, writes the XML declaration with the version "1.0".
/// </summary>
public override void WriteStartDocument()
{
_innerWriter.WriteStartDocument();
if (_tracingWriter != null)
{
_tracingWriter.WriteStartDocument();
}
}
public void WriteStartDocument()
{
Assert.AreEqual(WriteState.Start, w.WriteState, "#1");
w.WriteStartDocument();
Assert.AreEqual(WriteState.Start, w.WriteState, "#2");
w.WriteStartDocument(true);
Assert.AreEqual(WriteState.Start, w.WriteState, "#3");
// So, it does nothing
}
public void ProcessingInstructions ()
{
MemoryStream ms = new MemoryStream ();
XmlDictionaryWriter w = XmlDictionaryWriter.CreateBinaryWriter (ms, null, null);
w.WriteStartDocument ();
w.WriteProcessingInstruction ("myPI", "myValue");
}
public virtual Task WriteMessageAsync(Message message, Stream stream)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
ThrowIfMismatchedMessageVersion(message);
XmlDictionaryWriter xmlWriter = XmlDictionaryWriter.CreateTextWriter(stream, _writeEncoding, false);
if (_optimizeWriteForUtf8)
{
message.WriteMessage(xmlWriter);
}
else
{
xmlWriter.WriteStartDocument();
message.WriteMessage(xmlWriter);
xmlWriter.WriteEndDocument();
}
xmlWriter.Flush();
xmlWriter.Dispose();
return(Task.CompletedTask);
}
protected override void OnWriteStartMessage(XmlDictionaryWriter writer)
{
if (!_messageEncoder._optimizeWriteForUTF8)
{
writer.WriteStartDocument();
}
}
private void WriteMessage(Message message, Stream stream, string startInfo, string boundary, string startUri, bool writeMessageHeaders)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message"));
}
if (stream == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException("stream"), message);
}
base.ThrowIfMismatchedMessageVersion(message);
message.Properties.Encoder = this;
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
}
XmlDictionaryWriter writer = this.TakeStreamedWriter(stream, startInfo, boundary, startUri, writeMessageHeaders);
if (this.writeEncoding.WebName == "utf-8")
{
message.WriteMessage(writer);
}
else
{
writer.WriteStartDocument();
message.WriteMessage(writer);
writer.WriteEndDocument();
}
writer.Flush();
this.ReturnStreamedWriter(writer);
}
public WriteMessageAsyncResult(Message message, Stream stream, TextMessageEncoder textEncoder, AsyncCallback callback, object state)
: base(callback, state)
{
this.message = message;
this.textEncoder = textEncoder;
this.xmlWriter = textEncoder.TakeStreamedWriter(stream);
this.eventTraceActivity = null;
if (TD.TextMessageEncodingStartIsEnabled())
{
this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
TD.TextMessageEncodingStart(this.eventTraceActivity);
}
if (!textEncoder.optimizeWriteForUTF8)
{
xmlWriter.WriteStartDocument();
}
IAsyncResult result = message.BeginWriteMessage(this.xmlWriter, PrepareAsyncCompletion(onWriteMessage), this);
if (SyncContinue(result))
{
this.Complete(true);
}
}
private void WriteObjectWithInstance(XmlObjectSerializer xm, Person p,
string fileName)
{
// Use either the XmlDataContractSerializer or NetDataContractSerializer,
// or any other class that inherits from XmlObjectSerializer to write with.
Console.WriteLine(xm.GetType());
using (Stream fs = new FileStream(fileName, FileMode.Create))
{
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs))
{
//This does not work
//xm.WriteObject(writer, p);
//This works
////xm.WriteObject(fs, p);
// Use the writer to start a document.
writer.WriteStartDocument(true);
// Use the serializer to write the start,
// content, and end data.
xm.WriteStartObject(writer, p);
xm.WriteObjectContent(writer, p);
xm.WriteEndObject(writer);
writer.WriteEndDocument();
Console.WriteLine("Done writing {0}", fileName);
}
};
}
public static void WriteObjectData(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 serializer to write the start of the
// object data. Use it again to write the object
// data.
ser.WriteStartObject(writer, p);
ser.WriteObjectContent(writer, p);
// Use the serializer to write the end of the
// object data. Then use the writer to write the end
// of the document.
ser.WriteEndObject(writer);
writer.WriteEndDocument();
Console.WriteLine("Done");
// Close and release the writer resources.
writer.Flush();
fs.Flush();
fs.Close();
}
public override void WriteMessage(Message message, Stream stream)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message"));
}
if (stream == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException("stream"), message);
}
base.ThrowIfMismatchedMessageVersion(message);
message.Properties.Encoder = this;
XmlDictionaryWriter writer = this.TakeStreamedWriter(stream);
if (this.optimizeWriteForUTF8)
{
message.WriteMessage(writer);
}
else
{
writer.WriteStartDocument();
message.WriteMessage(writer);
writer.WriteEndDocument();
}
writer.Flush();
this.ReturnStreamedWriter(writer);
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
}
}
public override async Task WriteMessageAsync(Message message, Stream stream)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull(nameof(message));
}
if (stream == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(stream)), message);
}
ThrowIfMismatchedMessageVersion(message);
message.Properties.Encoder = this;
XmlDictionaryWriter xmlWriter = TakeStreamedWriter(stream);
if (_optimizeWriteForUTF8)
{
await message.WriteMessageAsync(xmlWriter);
}
else
{
xmlWriter.WriteStartDocument();
await message.WriteMessageAsync(xmlWriter);
xmlWriter.WriteEndDocument();
}
xmlWriter.Flush();
ReturnStreamedWriter(xmlWriter);
await stream.FlushAsync();
}
public static void FragmentTest()
{
string rwTypeStr = "Text";
ReaderWriterFactory.ReaderWriterType rwType = (ReaderWriterFactory.ReaderWriterType)
Enum.Parse(typeof(ReaderWriterFactory.ReaderWriterType), rwTypeStr, true);
Encoding encoding = Encoding.GetEncoding("utf-8");
int numberOfNestedFragments = 1;
MemoryStream ms1 = new MemoryStream();
MemoryStream ms2 = new MemoryStream();
XmlDictionaryWriter writer1 = (XmlDictionaryWriter)ReaderWriterFactory.CreateXmlWriter(rwType, ms1, encoding);
XmlDictionaryWriter writer2 = (XmlDictionaryWriter)ReaderWriterFactory.CreateXmlWriter(rwType, ms2, encoding);
Assert.True(FragmentHelper.CanFragment(writer1));
Assert.True(FragmentHelper.CanFragment(writer2));
writer1.WriteStartDocument(); writer2.WriteStartDocument();
writer1.WriteStartElement(ReaderWriterConstants.RootElementName); writer2.WriteStartElement(ReaderWriterConstants.RootElementName);
SimulateWriteFragment(writer1, true, numberOfNestedFragments);
SimulateWriteFragment(writer2, false, numberOfNestedFragments);
writer1.WriteEndElement(); writer2.WriteEndElement();
writer1.WriteEndDocument(); writer2.WriteEndDocument();
writer1.Flush();
writer2.Flush();
byte[] doc1 = ms1.ToArray();
byte[] doc2 = ms2.ToArray();
CompareArrays(doc1, 0, doc2, 0, doc1.Length);
}
protected override void OnWriteStartEnvelope(XmlDictionaryWriter writer)
{
writer.WriteStartDocument();
writer.WriteStartElement("s", "Envelope", "http://schemas.xmlsoap.org/soap/envelope/");
writer.WriteAttributeString("xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
writer.WriteAttributeString("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
}
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
writer.WriteStartDocument();
var serializer = new XmlSerializer(_typeToSerialize);
serializer.Serialize(writer, _objectToEncode);
writer.WriteEndDocument();
}
public void save(Stream s)
{
XmlDictionaryWriter xdw = XmlDictionaryWriter.CreateTextWriter(s, Encoding.UTF8);
xdw.WriteStartDocument();
dcs.WriteObject(xdw, this);
xdw.Close();
}
public void UseCase1()
{
Console.WriteLine();
MemoryStream ms = new MemoryStream();
XmlDictionaryWriter w = XmlDictionaryWriter.CreateBinaryWriter(ms, null, null);
w.WriteStartDocument(true);
w.WriteStartElement("root");
w.WriteAttributeString("a", "");
w.WriteComment("");
w.WriteWhitespace(" ");
w.WriteStartElement("AAA", "urn:AAA");
w.WriteEndElement();
w.WriteStartElement("ePfix", "AAA", "urn:AAABBB");
w.WriteEndElement();
w.WriteStartElement("AAA");
w.WriteCData("CCC\u3005\u4E00CCC");
w.WriteString("AAA&AAA");
w.WriteRaw("DDD&DDD");
w.WriteCharEntity('\u4E01');
w.WriteComment("COMMENT");
w.WriteEndElement();
w.WriteStartElement("AAA");
w.WriteAttributeString("BBB", "bbb");
// mhm, how namespace URIs are serialized then?
w.WriteAttributeString("pfix", "BBB", "urn:bbb", "bbbbb");
// 0x26-0x3F
w.WriteAttributeString("CCC", "urn:ccc", "ccccc");
w.WriteAttributeString("DDD", "urn:ddd", "ddddd");
w.WriteAttributeString("CCC", "urn:ddd", "cdcdc");
// XmlLang
w.WriteXmlAttribute("lang", "ja");
Assert.AreEqual("ja", w.XmlLang, "XmlLang");
// XmlSpace
w.WriteStartAttribute("xml", "space", "http://www.w3.org/XML/1998/namespace");
w.WriteString("pre");
w.WriteString("serve");
w.WriteEndAttribute();
Assert.AreEqual(XmlSpace.Preserve, w.XmlSpace, "XmlSpace");
w.WriteAttributeString("xml", "base", "http://www.w3.org/XML/1998/namespace", "local:hogehoge");
w.WriteString("CCC");
w.WriteBase64(new byte [] { 0x20, 0x20, 0x20, 0xFF, 0x80, 0x30 }, 0, 6);
w.WriteEndElement();
// this WriteEndElement() should result in one more
// 0x3C, but .net does not output it.
w.WriteEndElement();
w.WriteEndDocument();
w.Close();
Assert.AreEqual(usecase1_result, ms.ToArray());
}
public async Task <PlotEntity> Save(PlotEntity entity)
{
Stream myStream;
SaveFileDialog saveFileDialog1 = new SaveFileDialog
{
RestoreDirectory = true
};
string str = null;
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
if ((myStream = saveFileDialog1.OpenFile()) != null)
{
TextWriter tw = new StreamWriter(myStream);
str = saveFileDialog1.FileName;
entity.Name = str;
foreach (double s in entity.BuildData)
{
tw.WriteLine(s.ToString());
}
tw.Close();
myStream.Close();
}
}
progressChanged(this, new PlotEventArgs(10));
DataContractSerializer dcs = new DataContractSerializer(typeof(PlotEntity));
using (Stream stream = new FileStream(str + ".xml", FileMode.Create, FileAccess.Write))
{
using (XmlDictionaryWriter writer =
XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8))
{
writer.WriteStartDocument();
dcs.WriteObject(writer, entity);
}
}
progressChanged(this, new PlotEventArgs(30));
var zipFile = ZipFile.Open(str + ".zip", ZipArchiveMode.Create);
progressChanged(this, new PlotEventArgs(40));
zipFile.CreateEntryFromFile(str + ".xml", "meta.xml");
progressChanged(this, new PlotEventArgs(50));
zipFile.CreateEntryFromFile(entity.AudioFilePath, "audio.wav");
progressChanged(this, new PlotEventArgs(70));
zipFile.Dispose();
File.Delete(str);
File.Delete(str + ".xml");
File.Delete(entity.AudioFilePath);
progressChanged(this, new PlotEventArgs(100));
progressChanged(this, new PlotEventArgs(0));
return(entity);
}
static void Speichern(string filename, LernMoment moment)
{
DataContractSerializer serializer = new DataContractSerializer(typeof(LernMoment));
using (Stream stream = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8))
{
writer.WriteStartDocument();
serializer.WriteObject(writer, moment);
}
}
}
public void UnosAutomobilaUFajl(string filename, List <Automobil> automobili)
{
DataContractSerializer dcs = new DataContractSerializer(typeof(List <Automobil>));
using (Stream stream = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8))
{
writer.WriteStartDocument();
dcs.WriteObject(writer, automobili);
}
}
}
public void UpisivanjeKorisnikaUFajl(string filename, List <Korisnik> korisnici)
{
DataContractSerializer dcs = new DataContractSerializer(typeof(List <Korisnik>));
using (Stream stream = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8))
{
writer.WriteStartDocument();
dcs.WriteObject(writer, korisnici);
}
}
}
public override async Task WriteMessageAsync(Message message, Stream stream)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(message)));
}
if (stream == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException(nameof(stream)), message);
}
ThrowIfMismatchedMessageVersion(message);
EventTraceActivity eventTraceActivity = null;
if (WcfEventSource.Instance.TextMessageEncodingStartIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
WcfEventSource.Instance.TextMessageEncodingStart(eventTraceActivity);
}
message.Properties.Encoder = this;
XmlDictionaryWriter xmlWriter = TakeStreamedWriter(stream);
if (_optimizeWriteForUTF8)
{
await message.WriteMessageAsync(xmlWriter);
}
else
{
xmlWriter.WriteStartDocument();
await message.WriteMessageAsync(xmlWriter);
xmlWriter.WriteEndDocument();
}
await xmlWriter.FlushAsync();
ReturnStreamedWriter(xmlWriter);
if (WcfEventSource.Instance.StreamedMessageWrittenByEncoderIsEnabled())
{
WcfEventSource.Instance.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message));
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
}
}
public static void ConSerializer <T>(this T toSerialize, string filename)
{
DataContractSerializer dcs = new DataContractSerializer(typeof(T));
using (Stream stream = new FileStream(filename, FileMode.Create, FileAccess.Write))
{
using (XmlDictionaryWriter writer =
XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8))
{
writer.WriteStartDocument();
dcs.WriteObject(writer, toSerialize);
}
}
}
static void Main(string[] args)
{
//CreditCardServiceReference.CreditCardServiceClient cc = new CreditCardServiceReference.CreditCardServiceClient();
PaymentClient pc = new PaymentClient();
Console.WriteLine("Enter credit card no.");
string cno = Console.ReadLine();
Console.WriteLine("Enter credit card Expiry date");
DateTime expd = Convert.ToDateTime(Console.ReadLine());
SelfHostingServicePaymentLibraray.CreditCard cc = new SelfHostingServicePaymentLibraray.CreditCard();
cc.CCNo = cno; cc.ExpDate = expd;
bool result = false;
try
{
result = pc.ValidateCard(cc);
}
catch (FaultException ex)
{
Console.WriteLine(ex.Message);
}
catch (ProtocolException ex)
{
Console.WriteLine(ex.Message);
}
if (result)
{
Console.WriteLine("Valid");
}
else
{
Console.WriteLine("Invalid");
}
DataContractSerializer dcs = new DataContractSerializer(typeof(CreditCard));
using (Stream stream = new FileStream(@"D:\Tesco batch5\WCF\CarPoolingPaymentClient\file.xml", FileMode.Create, FileAccess.Write))
{
using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8))
{
writer.WriteStartDocument();
dcs.WriteObject(writer, cc);
}
}
Console.ReadLine();
}
public void Serialize(string path, Type t, Object o)
{
var dcs = new DataContractSerializer(t);
using (Stream stream = new FileStream(path, FileMode.Create, FileAccess.Write))
{
using (XmlDictionaryWriter writer =
XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8))
{
writer.WriteStartDocument();
dcs.WriteObject(writer, o);
}
}
}
protected override void OnWriteStartEnvelope(XmlDictionaryWriter writer)
{
writer.WriteStartDocument();
if (_message.Version.Envelope == EnvelopeVersion.Soap11)
{
writer.WriteStartElement("s", "Envelope", "http://schemas.xmlsoap.org/soap/envelope/");
}
else
{
writer.WriteStartElement("s", "Envelope", "http://www.w3.org/2003/05/soap-envelope");
}
writer.WriteAttributeString("xmlns:xsd", "http://www.w3.org/2001/XMLSchema");
writer.WriteAttributeString("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
}
public byte[] GetByteArray(string body)
{
MemoryStream stream = new MemoryStream();
DataContractSerializer s = new DataContractSerializer(typeof(string));
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(stream);
writer.WriteStartDocument();
s.WriteStartObject(writer, body);
s.WriteObjectContent(writer, body);
s.WriteEndObject(writer);
writer.Flush();
stream.Position = 0;
return(stream.ToArray());
}
protected override void OnWriteStartEnvelope(XmlDictionaryWriter writer)
{
writer.WriteStartDocument();
if (Message.Version.Envelope == EnvelopeVersion.Soap11)
{
writer.WriteStartElement("s", "Envelope", Namespaces.SOAP11_ENVELOPE_NS);
}
else
{
writer.WriteStartElement("s", "Envelope", Namespaces.SOAP12_ENVELOPE_NS);
}
writer.WriteXmlnsAttribute("xsd", Namespaces.XMLNS_XSD);
writer.WriteXmlnsAttribute("xsi", Namespaces.XMLNS_XSI);
}
private static void Serialize <T>(ref T obj, string fileName, ref Exception ex)
{
string fullName = string.Format("{0}{1}.xml", ConfigurationManager.AppSettings["SerializeLocation"], fileName);
#region Error Xml Format
XmlDocument doc = new XmlDocument();
XmlNode ErrorDetailsNode = doc.CreateElement("ErrorDetails");
XmlNode ExceptionTypeNode = doc.CreateElement("ExceptionType");
ExceptionTypeNode.InnerText = ex.GetType().ToString();
ErrorDetailsNode.AppendChild(ExceptionTypeNode);
XmlNode MessageNode = doc.CreateElement("Message");
MessageNode.InnerText = ex.Message;
ErrorDetailsNode.AppendChild(MessageNode);
XmlNode InnerExceptionNode = doc.CreateElement("InnerException");
InnerExceptionNode.InnerText = ex.InnerException != null ? ex.InnerException.Message : "";
ErrorDetailsNode.AppendChild(InnerExceptionNode);
XmlNode StackTraceNode = doc.CreateElement("StackTrace");
StackTraceNode.InnerText = ex.StackTrace;
ErrorDetailsNode.AppendChild(StackTraceNode);
doc.AppendChild(ErrorDetailsNode);
#endregion
DataContractSerializer s = new DataContractSerializer(typeof(T));
XmlSerializer xs = new XmlSerializer(typeof(XmlDocument));
using (System.IO.FileStream fs = File.Open(fullName, FileMode.Create))
{
XmlDictionaryWriter writer = XmlDictionaryWriter.CreateTextWriter(fs);
writer.WriteStartDocument(true);
writer.WriteStartElement("FailedSaveCall");
s.WriteStartObject(writer, obj);
s.WriteObjectContent(writer, obj);
s.WriteEndObject(writer);
xs.Serialize(writer, doc);
writer.WriteEndElement();
writer.WriteEndDocument();
}
}
static public bool Store(string path, JsonDictionary map, bool overwrite = true)
{
MemoryStream stream = new MemoryStream();
XmlDictionaryWriter xmlWriter = JsonReaderWriterFactory.CreateJsonWriter(stream);
// 取得したXmlDictionaryWriterに対して、xmlを構築
xmlWriter.WriteStartDocument();
xmlWriter.WriteStartElement("root");
xmlWriter.WriteAttributeString("type", "object");
// mapのkeyをタグ名、valueを値としてnodeを作成
foreach (KeyValuePair <string, string> pair in map)
{
// mapのキー名でタグを作成
xmlWriter.WriteStartElement(pair.Key);
// これはなくてもOKだった
//xmlWriter.WriteAttributeString("type", "string");
xmlWriter.WriteValue(pair.Value);
xmlWriter.WriteEndElement();
}
// rootノードの閉じタグ
xmlWriter.WriteEndElement();
xmlWriter.Flush();
// JSON形式の文字列を得る
stream.Position = 0;
// 上書きしない場合は存在チェック
if (!overwrite)
{
if (File.Exists(path))
{
MessageBox.Show("指定したファイル[" + path + "]は既に存在します。", "ファイル書き込みエラー");
}
return(false);
}
// 書き込み
var writer = new StreamWriter(path);
writer.Write(new StreamReader(stream).ReadToEnd());
stream.Close();
return(true);
}
void WriteMessage(Message message, Stream stream, string startInfo, string boundary, string startUri, bool writeMessageHeaders)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message"));
}
if (stream == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException("stream"), message);
}
ThrowIfMismatchedMessageVersion(message);
EventTraceActivity eventTraceActivity = null;
if (TD.MtomMessageEncodingStartIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
TD.MtomMessageEncodingStart(eventTraceActivity);
}
message.Properties.Encoder = this;
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
}
XmlDictionaryWriter xmlWriter = TakeStreamedWriter(stream, startInfo, boundary, startUri, writeMessageHeaders);
if (this.writeEncoding.WebName == "utf-8")
{
message.WriteMessage(xmlWriter);
}
else
{
xmlWriter.WriteStartDocument();
message.WriteMessage(xmlWriter);
xmlWriter.WriteEndDocument();
}
xmlWriter.Flush();
ReturnStreamedWriter(xmlWriter);
if (TD.StreamedMessageWrittenByEncoderIsEnabled())
{
TD.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message));
}
}