| public ReadValueChunk ( char buffer, int index, int count ) : int | ||
| buffer | char | |
| index | int | |
| count | int | |
| return | int | |
private int ReadContentAsBinary(byte[] buffer, int index, int count)
{
Debug.Assert(decoder != null);
if (isEnd)
{
Reset();
return(0);
}
decoder.SetNextOutputBuffer(buffer, index, count);
for (;;)
{
// use streaming ReadValueChunk if the reader supports it
if (canReadValueChunk)
{
for (;;)
{
if (valueOffset < valueChunkLength)
{
int decodedCharsCount = decoder.Decode(valueChunk, valueOffset, valueChunkLength - valueOffset);
valueOffset += decodedCharsCount;
}
if (decoder.IsFull)
{
return(decoder.DecodedCount);
}
Debug.Assert(valueOffset == valueChunkLength);
if ((valueChunkLength = reader.ReadValueChunk(valueChunk, 0, ChunkSize)) == 0)
{
break;
}
valueOffset = 0;
}
}
else
{
// read what is reader.Value
string value = reader.Value;
int decodedCharsCount = decoder.Decode(value, valueOffset, value.Length - valueOffset);
valueOffset += decodedCharsCount;
if (decoder.IsFull)
{
return(decoder.DecodedCount);
}
}
valueOffset = 0;
// move to next textual node in the element content; throw on sub elements
if (!MoveToNextContentNode(true))
{
isEnd = true;
return(decoder.DecodedCount);
}
}
}
internal async Task WriteNodeAsync_CallSyncReader(XmlReader reader, bool defattr)
{
bool canReadChunk = reader.CanReadValueChunk;
int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth;
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
await WriteStartElementAsync(reader.Prefix, reader.LocalName, reader.NamespaceURI).ConfigureAwait(false);
await WriteAttributesAsync(reader, defattr).ConfigureAwait(false);
if (reader.IsEmptyElement)
{
await WriteEndElementAsync().ConfigureAwait(false);
break;
}
break;
case XmlNodeType.Text:
if (canReadChunk)
{
if (_writeNodeBuffer == null)
{
_writeNodeBuffer = new char[WriteNodeBufferSize];
}
int read;
while ((read = reader.ReadValueChunk(_writeNodeBuffer, 0, WriteNodeBufferSize)) > 0)
{
await this.WriteCharsAsync(_writeNodeBuffer, 0, read).ConfigureAwait(false);
}
}
else
{
await WriteStringAsync(reader.Value).ConfigureAwait(false);
}
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
await WriteWhitespaceAsync(reader.Value).ConfigureAwait(false);
break;
case XmlNodeType.CDATA:
await WriteCDataAsync(reader.Value).ConfigureAwait(false);
break;
case XmlNodeType.EntityReference:
await WriteEntityRefAsync(reader.Name).ConfigureAwait(false);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
await WriteProcessingInstructionAsync(reader.Name, reader.Value).ConfigureAwait(false);
break;
case XmlNodeType.DocumentType:
await WriteDocTypeAsync(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value).ConfigureAwait(false);
break;
case XmlNodeType.Comment:
await WriteCommentAsync(reader.Value).ConfigureAwait(false);
break;
case XmlNodeType.EndElement:
await WriteFullEndElementAsync().ConfigureAwait(false);
break;
}
} while (reader.Read() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));
}
// Copies the current node from the given reader to the writer (including child nodes), and if called on an element moves the XmlReader
// to the corresponding end element.
public virtual void WriteNode(XmlReader reader, bool defattr)
{
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:
WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
WriteAttributes(reader, defattr);
if (reader.IsEmptyElement)
{
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)
{
this.WriteChars(_writeNodeBuffer, 0, read);
}
}
else
{
WriteString(reader.Value);
}
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
WriteWhitespace(reader.Value);
break;
case XmlNodeType.CDATA:
WriteCData(reader.Value);
break;
case XmlNodeType.EntityReference:
WriteEntityRef(reader.Name);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.DocumentType:
WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.Comment:
WriteComment(reader.Value);
break;
case XmlNodeType.EndElement:
WriteFullEndElement();
break;
}
} while (reader.Read() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));
}
// Copies the current node from the given reader to the writer (including child nodes), and if called on an element moves the XmlReader
// to the corresponding end element.
public virtual void WriteNode(XmlReader reader, bool defattr)
{
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:
WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
WriteAttributes(reader, defattr);
if (reader.IsEmptyElement)
{
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)
{
this.WriteChars(_writeNodeBuffer, 0, read);
}
}
else
{
WriteString(reader.Value);
}
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
WriteWhitespace(reader.Value);
break;
case XmlNodeType.CDATA:
WriteCData(reader.Value);
break;
case XmlNodeType.EntityReference:
WriteEntityRef(reader.Name);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.DocumentType:
WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.Comment:
WriteComment(reader.Value);
break;
case XmlNodeType.EndElement:
WriteFullEndElement();
break;
}
} while (reader.Read() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));
}
// Copies the current node from the given reader to the writer (including child nodes), and if called on an element moves the XmlReader
// to the corresponding end element.
//use sync methods on the reader
internal async Task WriteNodeAsync_CallSyncReader(XmlReader reader, bool defattr)
{
bool canReadChunk = reader.CanReadValueChunk;
int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth;
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
await WriteStartElementAsync(reader.Prefix, reader.LocalName, reader.NamespaceURI).ConfigureAwait(false);
await WriteAttributesAsync(reader, defattr).ConfigureAwait(false);
if (reader.IsEmptyElement)
{
await WriteEndElementAsync().ConfigureAwait(false);
break;
}
break;
case XmlNodeType.Text:
if (canReadChunk)
{
if (_writeNodeBuffer == null)
{
_writeNodeBuffer = new char[WriteNodeBufferSize];
}
int read;
while ((read = reader.ReadValueChunk(_writeNodeBuffer, 0, WriteNodeBufferSize)) > 0)
{
await this.WriteCharsAsync(_writeNodeBuffer, 0, read).ConfigureAwait(false);
}
}
else
{
await WriteStringAsync(reader.Value).ConfigureAwait(false);
}
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
await WriteWhitespaceAsync(reader.Value).ConfigureAwait(false);
break;
case XmlNodeType.CDATA:
await WriteCDataAsync(reader.Value).ConfigureAwait(false);
break;
case XmlNodeType.EntityReference:
await WriteEntityRefAsync(reader.Name).ConfigureAwait(false);
break;
case XmlNodeType.XmlDeclaration:
case XmlNodeType.ProcessingInstruction:
await WriteProcessingInstructionAsync(reader.Name, reader.Value).ConfigureAwait(false);
break;
case XmlNodeType.DocumentType:
await WriteDocTypeAsync(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value).ConfigureAwait(false);
break;
case XmlNodeType.Comment:
await WriteCommentAsync(reader.Value).ConfigureAwait(false);
break;
case XmlNodeType.EndElement:
await WriteFullEndElementAsync().ConfigureAwait(false);
break;
}
} while (reader.Read() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));
}
public override int ReadValueChunk(char[] buffer, int index, int count)
{
CheckAsync();
return(_coreReader.ReadValueChunk(buffer, index, count));
}
public virtual void WriteNode(XmlReader reader, bool defattr)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
bool canReadValueChunk = reader.CanReadValueChunk;
int num = (reader.NodeType == XmlNodeType.None) ? -1 : reader.Depth;
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
this.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
this.WriteAttributes(reader, defattr);
if (reader.IsEmptyElement)
{
this.WriteEndElement();
}
break;
case XmlNodeType.Text:
int num2;
if (!canReadValueChunk)
{
this.WriteString(reader.Value);
break;
}
if (this.writeNodeBuffer == null)
{
this.writeNodeBuffer = new char[0x400];
}
while ((num2 = reader.ReadValueChunk(this.writeNodeBuffer, 0, 0x400)) > 0)
{
this.WriteChars(this.writeNodeBuffer, 0, num2);
}
break;
case XmlNodeType.CDATA:
this.WriteCData(reader.Value);
break;
case XmlNodeType.EntityReference:
this.WriteEntityRef(reader.Name);
break;
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.XmlDeclaration:
this.WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.Comment:
this.WriteComment(reader.Value);
break;
case XmlNodeType.DocumentType:
this.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
this.WriteWhitespace(reader.Value);
break;
case XmlNodeType.EndElement:
this.WriteFullEndElement();
break;
}
}
while (reader.Read() && ((num < reader.Depth) || ((num == reader.Depth) && (reader.NodeType == XmlNodeType.EndElement))));
}
public virtual void WriteNode(XmlReader reader, bool defattr)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
bool canReadValueChunk = reader.CanReadValueChunk;
int num = (reader.NodeType == XmlNodeType.None) ? -1 : reader.Depth;
do
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
this.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
this.WriteAttributes(reader, defattr);
if (reader.IsEmptyElement)
{
this.WriteEndElement();
}
break;
case XmlNodeType.Text:
int num2;
if (!canReadValueChunk)
{
this.WriteString(reader.Value);
break;
}
if (this.writeNodeBuffer == null)
{
this.writeNodeBuffer = new char[0x400];
}
while ((num2 = reader.ReadValueChunk(this.writeNodeBuffer, 0, 0x400)) > 0)
{
this.WriteChars(this.writeNodeBuffer, 0, num2);
}
break;
case XmlNodeType.CDATA:
this.WriteCData(reader.Value);
break;
case XmlNodeType.EntityReference:
this.WriteEntityRef(reader.Name);
break;
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.XmlDeclaration:
this.WriteProcessingInstruction(reader.Name, reader.Value);
break;
case XmlNodeType.Comment:
this.WriteComment(reader.Value);
break;
case XmlNodeType.DocumentType:
this.WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value);
break;
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
this.WriteWhitespace(reader.Value);
break;
case XmlNodeType.EndElement:
this.WriteFullEndElement();
break;
}
}while (reader.Read() && ((num < reader.Depth) || ((num == reader.Depth) && (reader.NodeType == XmlNodeType.EndElement))));
}
