public void ProcessingInstructions ()
{
MemoryStream ms = new MemoryStream ();
XmlDictionaryWriter w = XmlDictionaryWriter.CreateBinaryWriter (ms, null, null);
w.WriteStartDocument ();
w.WriteProcessingInstruction ("myPI", "myValue");
}
/// <summary>
/// Writes out a processing instruction with a space between the name and text as follows: <?name text?>.
/// </summary>
/// <param name="name">The name of the processing instruction.</param>
/// <param name="text">The text to include in the processing instruction.</param>
public override void WriteProcessingInstruction(string name, string text)
{
_innerWriter.WriteProcessingInstruction(name, text);
if (_tracingWriter != null)
{
_tracingWriter.WriteProcessingInstruction(name, text);
}
}
public override void WriteProcessingInstruction(string name, string text)
{
_innerWriter.WriteProcessingInstruction(name, text);
}
public void CloseWriteAfter()
{
xw.WriteElementString("foo", "bar");
xw.Close();
// WriteEndElement and WriteStartDocument aren't tested here because
// they will always throw different exceptions besides 'The Writer is closed.'
// and there are already tests for those exceptions.
try
{
xw.WriteCData("foo");
Assert.Fail("WriteCData after Close Should have thrown an InvalidOperationException.");
}
catch (InvalidOperationException)
{
// Don't rely on English message assertion.
// It is enough to check an exception occurs.
// Assert.AreEqual ("Exception message is incorrect.", "The Writer is closed.", e.Message);
}
try
{
xw.WriteComment("foo");
Assert.Fail("WriteComment after Close Should have thrown an InvalidOperationException.");
}
catch (InvalidOperationException)
{
// Assert.AreEqual ("Exception message is incorrect.", "The Writer is closed.", e.Message);
}
try
{
xw.WriteProcessingInstruction("foo", "bar");
Assert.Fail("WriteProcessingInstruction after Close Should have thrown an InvalidOperationException.");
}
catch (InvalidOperationException)
{
// Assert.AreEqual ("Exception message is incorrect.", "The Writer is closed.", e.Message);
}
try
{
xw.WriteStartElement("foo", "bar", "baz");
Assert.Fail("WriteStartElement after Close Should have thrown an InvalidOperationException.");
}
catch (InvalidOperationException)
{
// Assert.AreEqual ("Exception message is incorrect.", "The Writer is closed.", e.Message);
}
try
{
xw.WriteAttributeString("foo", "bar");
Assert.Fail("WriteAttributeString after Close Should have thrown an InvalidOperationException.");
}
catch (InvalidOperationException)
{
// Assert.AreEqual ("Exception message is incorrect.", "The Writer is closed.", e.Message);
}
try
{
xw.WriteString("foo");
Assert.Fail("WriteString after Close Should have thrown an InvalidOperationException.");
}
catch (InvalidOperationException)
{
// Assert.AreEqual ("Exception message is incorrect.", "The Writer is closed.", e.Message);
}
}
public void WriteProcessingInstruction()
{
// since this method accepts case-insensitive "XML",
// it throws ArgumentException.
w.WriteProcessingInstruction("T", "D");
}
public static async Task WriteNodeAsync(XmlDictionaryWriter writer, XmlReader reader, bool defattr)
{
char[] writeNodeBuffer = null;
const int WriteNodeBufferSize = 1024;
if (null == reader)
{
throw new ArgumentNullException(nameof(reader));
}
bool canReadChunk = reader.CanReadValueChunk;
int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth;
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
writer.WriteAttributes(reader, defattr);
if (reader.IsEmptyElement)
{
writer.WriteEndElement();
break;
}
break;
case XmlNodeType.Text:
if (canReadChunk)
{
if (writeNodeBuffer == null)
{
writeNodeBuffer = new char[WriteNodeBufferSize];
}
int read;
while ((read = reader.ReadValueChunk(writeNodeBuffer, 0, WriteNodeBufferSize)) > 0)
{
writer.WriteChars(writeNodeBuffer, 0, read);
}
}
else
{
writer.WriteString(await reader.GetValueAsync());
}
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
writer.WriteWhitespace(await reader.GetValueAsync());
break;
case XmlNodeType.CDATA:
writer.WriteCData(await reader.GetValueAsync());
break;
case XmlNodeType.EntityReference:
writer.WriteEntityRef(reader.Name);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(reader.Name, await reader.GetValueAsync());
break;
case XmlNodeType.DocumentType:
writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), await reader.GetValueAsync());
break;
case XmlNodeType.Comment:
writer.WriteComment(await reader.GetValueAsync());
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
break;
}
} while (await reader.ReadAsync() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));
}
protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
{
try
{
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
writer.WriteAttributeString(reader.LocalName, reader.NamespaceURI, reader.Value.Replace(sourcePattern, targetPattern));
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
writer.WriteEndElement();
}
break;
case XmlNodeType.Text:
writer.WriteString(reader.Value.Replace(sourcePattern, targetPattern));
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
writer.WriteWhitespace(reader.Value);
break;
case XmlNodeType.CDATA:
writer.WriteCData(reader.Value);
break;
case XmlNodeType.EntityReference:
writer.WriteEntityRef(reader.Name);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
writer.WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.DocumentType:
writer.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.Comment:
writer.WriteComment(reader.Value);
break;
case XmlNodeType.EndElement:
writer.WriteFullEndElement();
break;
}
}while (reader.Read());
writer.Flush();
}
catch (Exception ex)
{
Console.WriteLine(ex);
throw;
}
}