Terraria v1.4.4.9
Terraria source code documentation
Loading...
Searching...
No Matches
ReadContentAsBinaryHelper.cs
Go to the documentation of this file.
1using System.Threading.Tasks;
2
3namespace System.Xml;
4
5internal sealed class ReadContentAsBinaryHelper
6{
7 private enum State
8 {
9 None,
10 InReadContent,
11 InReadElementContent
12 }
13
14 private readonly XmlReader _reader;
15
16 private State _state;
17
18 private int _valueOffset;
19
20 private bool _isEnd;
21
22 private readonly bool _canReadValueChunk;
23
24 private readonly char[] _valueChunk;
25
26 private int _valueChunkLength;
27
28 private IncrementalReadDecoder _decoder;
29
30 private Base64Decoder _base64Decoder;
31
32 private BinHexDecoder _binHexDecoder;
33
34 internal ReadContentAsBinaryHelper(XmlReader reader)
35 {
36 _reader = reader;
37 _canReadValueChunk = reader.CanReadValueChunk;
38 if (_canReadValueChunk)
39 {
40 _valueChunk = new char[256];
41 }
42 }
43
44 internal static ReadContentAsBinaryHelper CreateOrReset(ReadContentAsBinaryHelper helper, XmlReader reader)
45 {
46 if (helper == null)
47 {
48 return new ReadContentAsBinaryHelper(reader);
49 }
50 helper.Reset();
51 return helper;
52 }
53
54 internal int ReadContentAsBase64(byte[] buffer, int index, int count)
55 {
56 if (buffer == null)
57 {
58 throw new ArgumentNullException("buffer");
59 }
60 if (count < 0)
61 {
62 throw new ArgumentOutOfRangeException("count");
63 }
64 if (index < 0)
65 {
66 throw new ArgumentOutOfRangeException("index");
67 }
68 if (buffer.Length - index < count)
69 {
70 throw new ArgumentOutOfRangeException("count");
71 }
72 switch (_state)
73 {
74 case State.None:
75 if (!_reader.CanReadContentAs())
76 {
77 throw _reader.CreateReadContentAsException("ReadContentAsBase64");
78 }
79 if (!Init())
80 {
81 return 0;
82 }
83 break;
84 case State.InReadContent:
85 if (_decoder == _base64Decoder)
86 {
87 return ReadContentAsBinary(buffer, index, count);
88 }
89 break;
90 case State.InReadElementContent:
91 throw new InvalidOperationException(System.SR.Xml_MixingBinaryContentMethods);
92 default:
93 return 0;
94 }
95 InitBase64Decoder();
96 return ReadContentAsBinary(buffer, index, count);
97 }
98
99 internal int ReadContentAsBinHex(byte[] buffer, int index, int count)
100 {
101 if (buffer == null)
102 {
103 throw new ArgumentNullException("buffer");
104 }
105 if (count < 0)
106 {
107 throw new ArgumentOutOfRangeException("count");
108 }
109 if (index < 0)
110 {
111 throw new ArgumentOutOfRangeException("index");
112 }
113 if (buffer.Length - index < count)
114 {
115 throw new ArgumentOutOfRangeException("count");
116 }
117 switch (_state)
118 {
119 case State.None:
120 if (!_reader.CanReadContentAs())
121 {
122 throw _reader.CreateReadContentAsException("ReadContentAsBinHex");
123 }
124 if (!Init())
125 {
126 return 0;
127 }
128 break;
129 case State.InReadContent:
130 if (_decoder == _binHexDecoder)
131 {
132 return ReadContentAsBinary(buffer, index, count);
133 }
134 break;
135 case State.InReadElementContent:
136 throw new InvalidOperationException(System.SR.Xml_MixingBinaryContentMethods);
137 default:
138 return 0;
139 }
140 InitBinHexDecoder();
141 return ReadContentAsBinary(buffer, index, count);
142 }
143
144 internal int ReadElementContentAsBase64(byte[] buffer, int index, int count)
145 {
146 if (buffer == null)
147 {
148 throw new ArgumentNullException("buffer");
149 }
150 if (count < 0)
151 {
152 throw new ArgumentOutOfRangeException("count");
153 }
154 if (index < 0)
155 {
156 throw new ArgumentOutOfRangeException("index");
157 }
158 if (buffer.Length - index < count)
159 {
160 throw new ArgumentOutOfRangeException("count");
161 }
162 switch (_state)
163 {
164 case State.None:
165 if (_reader.NodeType != XmlNodeType.Element)
166 {
167 throw _reader.CreateReadElementContentAsException("ReadElementContentAsBase64");
168 }
169 if (!InitOnElement())
170 {
171 return 0;
172 }
173 break;
174 case State.InReadContent:
175 throw new InvalidOperationException(System.SR.Xml_MixingBinaryContentMethods);
176 case State.InReadElementContent:
177 if (_decoder == _base64Decoder)
178 {
179 return ReadElementContentAsBinary(buffer, index, count);
180 }
181 break;
182 default:
183 return 0;
184 }
185 InitBase64Decoder();
186 return ReadElementContentAsBinary(buffer, index, count);
187 }
188
189 internal int ReadElementContentAsBinHex(byte[] buffer, int index, int count)
190 {
191 if (buffer == null)
192 {
193 throw new ArgumentNullException("buffer");
194 }
195 if (count < 0)
196 {
197 throw new ArgumentOutOfRangeException("count");
198 }
199 if (index < 0)
200 {
201 throw new ArgumentOutOfRangeException("index");
202 }
203 if (buffer.Length - index < count)
204 {
205 throw new ArgumentOutOfRangeException("count");
206 }
207 switch (_state)
208 {
209 case State.None:
210 if (_reader.NodeType != XmlNodeType.Element)
211 {
212 throw _reader.CreateReadElementContentAsException("ReadElementContentAsBinHex");
213 }
214 if (!InitOnElement())
215 {
216 return 0;
217 }
218 break;
219 case State.InReadContent:
220 throw new InvalidOperationException(System.SR.Xml_MixingBinaryContentMethods);
221 case State.InReadElementContent:
222 if (_decoder == _binHexDecoder)
223 {
224 return ReadElementContentAsBinary(buffer, index, count);
225 }
226 break;
227 default:
228 return 0;
229 }
230 InitBinHexDecoder();
231 return ReadElementContentAsBinary(buffer, index, count);
232 }
233
234 internal void Finish()
235 {
236 if (_state != 0)
237 {
238 while (MoveToNextContentNode(moveIfOnContentNode: true))
239 {
240 }
241 if (_state == State.InReadElementContent)
242 {
243 if (_reader.NodeType != XmlNodeType.EndElement)
244 {
245 throw new XmlException(System.SR.Xml_InvalidNodeType, _reader.NodeType.ToString(), _reader as IXmlLineInfo);
246 }
247 _reader.Read();
248 }
249 }
250 Reset();
251 }
252
253 internal void Reset()
254 {
255 _state = State.None;
256 _isEnd = false;
257 _valueOffset = 0;
258 }
259
260 private bool Init()
261 {
262 if (!MoveToNextContentNode(moveIfOnContentNode: false))
263 {
264 return false;
265 }
266 _state = State.InReadContent;
267 _isEnd = false;
268 return true;
269 }
270
271 private bool InitOnElement()
272 {
273 bool isEmptyElement = _reader.IsEmptyElement;
274 _reader.Read();
275 if (isEmptyElement)
276 {
277 return false;
278 }
279 if (!MoveToNextContentNode(moveIfOnContentNode: false))
280 {
281 if (_reader.NodeType != XmlNodeType.EndElement)
282 {
283 throw new XmlException(System.SR.Xml_InvalidNodeType, _reader.NodeType.ToString(), _reader as IXmlLineInfo);
284 }
285 _reader.Read();
286 return false;
287 }
288 _state = State.InReadElementContent;
289 _isEnd = false;
290 return true;
291 }
292
293 private void InitBase64Decoder()
294 {
295 if (_base64Decoder == null)
296 {
297 _base64Decoder = new Base64Decoder();
298 }
299 else
300 {
301 _base64Decoder.Reset();
302 }
303 _decoder = _base64Decoder;
304 }
305
306 private void InitBinHexDecoder()
307 {
308 if (_binHexDecoder == null)
309 {
310 _binHexDecoder = new BinHexDecoder();
311 }
312 else
313 {
314 _binHexDecoder.Reset();
315 }
316 _decoder = _binHexDecoder;
317 }
318
319 private int ReadContentAsBinary(byte[] buffer, int index, int count)
320 {
321 if (_isEnd)
322 {
323 Reset();
324 return 0;
325 }
326 _decoder.SetNextOutputBuffer(buffer, index, count);
327 do
328 {
329 if (_canReadValueChunk)
330 {
331 while (true)
332 {
333 if (_valueOffset < _valueChunkLength)
334 {
335 int num = _decoder.Decode(_valueChunk, _valueOffset, _valueChunkLength - _valueOffset);
336 _valueOffset += num;
337 }
338 if (_decoder.IsFull)
339 {
340 return _decoder.DecodedCount;
341 }
342 if ((_valueChunkLength = _reader.ReadValueChunk(_valueChunk, 0, 256)) == 0)
343 {
344 break;
345 }
346 _valueOffset = 0;
347 }
348 }
349 else
350 {
351 string value = _reader.Value;
352 int num2 = _decoder.Decode(value, _valueOffset, value.Length - _valueOffset);
353 _valueOffset += num2;
354 if (_decoder.IsFull)
355 {
356 return _decoder.DecodedCount;
357 }
358 }
359 _valueOffset = 0;
360 }
361 while (MoveToNextContentNode(moveIfOnContentNode: true));
362 _isEnd = true;
363 return _decoder.DecodedCount;
364 }
365
366 private int ReadElementContentAsBinary(byte[] buffer, int index, int count)
367 {
368 if (count == 0)
369 {
370 return 0;
371 }
372 int num = ReadContentAsBinary(buffer, index, count);
373 if (num > 0)
374 {
375 return num;
376 }
377 if (_reader.NodeType != XmlNodeType.EndElement)
378 {
379 throw new XmlException(System.SR.Xml_InvalidNodeType, _reader.NodeType.ToString(), _reader as IXmlLineInfo);
380 }
381 _reader.Read();
382 _state = State.None;
383 return 0;
384 }
385
386 private bool MoveToNextContentNode(bool moveIfOnContentNode)
387 {
388 do
389 {
390 switch (_reader.NodeType)
391 {
392 case XmlNodeType.Attribute:
393 return !moveIfOnContentNode;
394 case XmlNodeType.Text:
395 case XmlNodeType.CDATA:
396 case XmlNodeType.Whitespace:
397 case XmlNodeType.SignificantWhitespace:
398 if (!moveIfOnContentNode)
399 {
400 return true;
401 }
402 goto IL_0078;
403 case XmlNodeType.EntityReference:
404 if (!_reader.CanResolveEntity)
405 {
406 break;
407 }
408 _reader.ResolveEntity();
409 goto IL_0078;
410 case XmlNodeType.ProcessingInstruction:
411 case XmlNodeType.Comment:
412 case XmlNodeType.EndEntity:
413 goto IL_0078;
414 }
415 return false;
416 IL_0078:
417 moveIfOnContentNode = false;
418 }
419 while (_reader.Read());
420 return false;
421 }
422
423 internal async Task<int> ReadContentAsBase64Async(byte[] buffer, int index, int count)
424 {
425 if (buffer == null)
426 {
427 throw new ArgumentNullException("buffer");
428 }
429 if (count < 0)
430 {
431 throw new ArgumentOutOfRangeException("count");
432 }
433 if (index < 0)
434 {
435 throw new ArgumentOutOfRangeException("index");
436 }
437 if (buffer.Length - index < count)
438 {
439 throw new ArgumentOutOfRangeException("count");
440 }
441 switch (_state)
442 {
443 case State.None:
444 if (!_reader.CanReadContentAs())
445 {
446 throw _reader.CreateReadContentAsException("ReadContentAsBase64");
447 }
448 if (!(await InitAsync().ConfigureAwait(continueOnCapturedContext: false)))
449 {
450 return 0;
451 }
452 break;
453 case State.InReadContent:
454 if (_decoder == _base64Decoder)
455 {
456 return await ReadContentAsBinaryAsync(buffer, index, count).ConfigureAwait(continueOnCapturedContext: false);
457 }
458 break;
459 case State.InReadElementContent:
460 throw new InvalidOperationException(System.SR.Xml_MixingBinaryContentMethods);
461 default:
462 return 0;
463 }
464 InitBase64Decoder();
465 return await ReadContentAsBinaryAsync(buffer, index, count).ConfigureAwait(continueOnCapturedContext: false);
466 }
467
468 internal async Task<int> ReadContentAsBinHexAsync(byte[] buffer, int index, int count)
469 {
470 if (buffer == null)
471 {
472 throw new ArgumentNullException("buffer");
473 }
474 if (count < 0)
475 {
476 throw new ArgumentOutOfRangeException("count");
477 }
478 if (index < 0)
479 {
480 throw new ArgumentOutOfRangeException("index");
481 }
482 if (buffer.Length - index < count)
483 {
484 throw new ArgumentOutOfRangeException("count");
485 }
486 switch (_state)
487 {
488 case State.None:
489 if (!_reader.CanReadContentAs())
490 {
491 throw _reader.CreateReadContentAsException("ReadContentAsBinHex");
492 }
493 if (!(await InitAsync().ConfigureAwait(continueOnCapturedContext: false)))
494 {
495 return 0;
496 }
497 break;
498 case State.InReadContent:
499 if (_decoder == _binHexDecoder)
500 {
501 return await ReadContentAsBinaryAsync(buffer, index, count).ConfigureAwait(continueOnCapturedContext: false);
502 }
503 break;
504 case State.InReadElementContent:
505 throw new InvalidOperationException(System.SR.Xml_MixingBinaryContentMethods);
506 default:
507 return 0;
508 }
509 InitBinHexDecoder();
510 return await ReadContentAsBinaryAsync(buffer, index, count).ConfigureAwait(continueOnCapturedContext: false);
511 }
512
513 internal async Task<int> ReadElementContentAsBase64Async(byte[] buffer, int index, int count)
514 {
515 if (buffer == null)
516 {
517 throw new ArgumentNullException("buffer");
518 }
519 if (count < 0)
520 {
521 throw new ArgumentOutOfRangeException("count");
522 }
523 if (index < 0)
524 {
525 throw new ArgumentOutOfRangeException("index");
526 }
527 if (buffer.Length - index < count)
528 {
529 throw new ArgumentOutOfRangeException("count");
530 }
531 switch (_state)
532 {
533 case State.None:
534 if (_reader.NodeType != XmlNodeType.Element)
535 {
536 throw _reader.CreateReadElementContentAsException("ReadElementContentAsBase64");
537 }
538 if (!(await InitOnElementAsync().ConfigureAwait(continueOnCapturedContext: false)))
539 {
540 return 0;
541 }
542 break;
543 case State.InReadContent:
544 throw new InvalidOperationException(System.SR.Xml_MixingBinaryContentMethods);
545 case State.InReadElementContent:
546 if (_decoder == _base64Decoder)
547 {
548 return await ReadElementContentAsBinaryAsync(buffer, index, count).ConfigureAwait(continueOnCapturedContext: false);
549 }
550 break;
551 default:
552 return 0;
553 }
554 InitBase64Decoder();
555 return await ReadElementContentAsBinaryAsync(buffer, index, count).ConfigureAwait(continueOnCapturedContext: false);
556 }
557
558 internal async Task<int> ReadElementContentAsBinHexAsync(byte[] buffer, int index, int count)
559 {
560 if (buffer == null)
561 {
562 throw new ArgumentNullException("buffer");
563 }
564 if (count < 0)
565 {
566 throw new ArgumentOutOfRangeException("count");
567 }
568 if (index < 0)
569 {
570 throw new ArgumentOutOfRangeException("index");
571 }
572 if (buffer.Length - index < count)
573 {
574 throw new ArgumentOutOfRangeException("count");
575 }
576 switch (_state)
577 {
578 case State.None:
579 if (_reader.NodeType != XmlNodeType.Element)
580 {
581 throw _reader.CreateReadElementContentAsException("ReadElementContentAsBinHex");
582 }
583 if (!(await InitOnElementAsync().ConfigureAwait(continueOnCapturedContext: false)))
584 {
585 return 0;
586 }
587 break;
588 case State.InReadContent:
589 throw new InvalidOperationException(System.SR.Xml_MixingBinaryContentMethods);
590 case State.InReadElementContent:
591 if (_decoder == _binHexDecoder)
592 {
593 return await ReadElementContentAsBinaryAsync(buffer, index, count).ConfigureAwait(continueOnCapturedContext: false);
594 }
595 break;
596 default:
597 return 0;
598 }
599 InitBinHexDecoder();
600 return await ReadElementContentAsBinaryAsync(buffer, index, count).ConfigureAwait(continueOnCapturedContext: false);
601 }
602
603 internal async Task FinishAsync()
604 {
605 if (_state != 0)
606 {
607 while (await MoveToNextContentNodeAsync(moveIfOnContentNode: true).ConfigureAwait(continueOnCapturedContext: false))
608 {
609 }
610 if (_state == State.InReadElementContent)
611 {
612 if (_reader.NodeType != XmlNodeType.EndElement)
613 {
614 throw new XmlException(System.SR.Xml_InvalidNodeType, _reader.NodeType.ToString(), _reader as IXmlLineInfo);
615 }
616 await _reader.ReadAsync().ConfigureAwait(continueOnCapturedContext: false);
617 }
618 }
619 Reset();
620 }
621
622 private async Task<bool> InitAsync()
623 {
624 if (!(await MoveToNextContentNodeAsync(moveIfOnContentNode: false).ConfigureAwait(continueOnCapturedContext: false)))
625 {
626 return false;
627 }
628 _state = State.InReadContent;
629 _isEnd = false;
630 return true;
631 }
632
633 private async Task<bool> InitOnElementAsync()
634 {
635 bool isEmpty = _reader.IsEmptyElement;
636 await _reader.ReadAsync().ConfigureAwait(continueOnCapturedContext: false);
637 if (isEmpty)
638 {
639 return false;
640 }
641 if (!(await MoveToNextContentNodeAsync(moveIfOnContentNode: false).ConfigureAwait(continueOnCapturedContext: false)))
642 {
643 if (_reader.NodeType != XmlNodeType.EndElement)
644 {
645 throw new XmlException(System.SR.Xml_InvalidNodeType, _reader.NodeType.ToString(), _reader as IXmlLineInfo);
646 }
647 await _reader.ReadAsync().ConfigureAwait(continueOnCapturedContext: false);
648 return false;
649 }
650 _state = State.InReadElementContent;
651 _isEnd = false;
652 return true;
653 }
654
655 private async Task<int> ReadContentAsBinaryAsync(byte[] buffer, int index, int count)
656 {
657 if (_isEnd)
658 {
659 Reset();
660 return 0;
661 }
662 _decoder.SetNextOutputBuffer(buffer, index, count);
663 do
664 {
665 if (_canReadValueChunk)
666 {
667 while (true)
668 {
669 if (_valueOffset < _valueChunkLength)
670 {
671 int num = _decoder.Decode(_valueChunk, _valueOffset, _valueChunkLength - _valueOffset);
672 _valueOffset += num;
673 }
674 if (_decoder.IsFull)
675 {
676 return _decoder.DecodedCount;
677 }
678 if ((_valueChunkLength = await _reader.ReadValueChunkAsync(_valueChunk, 0, 256).ConfigureAwait(continueOnCapturedContext: false)) == 0)
679 {
680 break;
681 }
682 _valueOffset = 0;
683 }
684 }
685 else
686 {
687 string text = await _reader.GetValueAsync().ConfigureAwait(continueOnCapturedContext: false);
688 int num2 = _decoder.Decode(text, _valueOffset, text.Length - _valueOffset);
689 _valueOffset += num2;
690 if (_decoder.IsFull)
691 {
692 return _decoder.DecodedCount;
693 }
694 }
695 _valueOffset = 0;
696 }
697 while (await MoveToNextContentNodeAsync(moveIfOnContentNode: true).ConfigureAwait(continueOnCapturedContext: false));
698 _isEnd = true;
699 return _decoder.DecodedCount;
700 }
701
702 private async Task<int> ReadElementContentAsBinaryAsync(byte[] buffer, int index, int count)
703 {
704 if (count == 0)
705 {
706 return 0;
707 }
708 int num = await ReadContentAsBinaryAsync(buffer, index, count).ConfigureAwait(continueOnCapturedContext: false);
709 if (num > 0)
710 {
711 return num;
712 }
713 if (_reader.NodeType != XmlNodeType.EndElement)
714 {
715 throw new XmlException(System.SR.Xml_InvalidNodeType, _reader.NodeType.ToString(), _reader as IXmlLineInfo);
716 }
717 await _reader.ReadAsync().ConfigureAwait(continueOnCapturedContext: false);
718 _state = State.None;
719 return 0;
720 }
721
722 private async Task<bool> MoveToNextContentNodeAsync(bool moveIfOnContentNode)
723 {
724 do
725 {
726 switch (_reader.NodeType)
727 {
728 case XmlNodeType.Attribute:
729 return !moveIfOnContentNode;
730 case XmlNodeType.Text:
731 case XmlNodeType.CDATA:
732 case XmlNodeType.Whitespace:
733 case XmlNodeType.SignificantWhitespace:
734 if (!moveIfOnContentNode)
735 {
736 return true;
737 }
738 goto IL_00a5;
739 case XmlNodeType.EntityReference:
740 if (!_reader.CanResolveEntity)
741 {
742 break;
743 }
744 _reader.ResolveEntity();
745 goto IL_00a5;
746 case XmlNodeType.ProcessingInstruction:
747 case XmlNodeType.Comment:
748 case XmlNodeType.EndEntity:
749 goto IL_00a5;
750 }
751 return false;
752 IL_00a5:
753 moveIfOnContentNode = false;
754 }
755 while (await _reader.ReadAsync().ConfigureAwait(continueOnCapturedContext: false));
756 return false;
757 }
758}
System.SR.Xml_InvalidNodeType
static string Xml_InvalidNodeType
Definition SR.cs:88
System.SR.Xml_MixingBinaryContentMethods
static string Xml_MixingBinaryContentMethods
Definition SR.cs:184
System.SR
Definition SR.cs:7
System.Threading.Tasks.Task.ConfigureAwait
new ConfiguredTaskAwaitable< TResult > ConfigureAwait(bool continueOnCapturedContext)
Definition Task.cs:226
System.Xml.IncrementalReadDecoder.Decode
int Decode(char[] chars, int startPos, int len)
System.Xml.IncrementalReadDecoder.SetNextOutputBuffer
void SetNextOutputBuffer(Array array, int offset, int len)
System.Xml.ReadContentAsBinaryHelper.ReadElementContentAsBase64Async
async Task< int > ReadElementContentAsBase64Async(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:513
System.Xml.ReadContentAsBinaryHelper.ReadElementContentAsBinary
int ReadElementContentAsBinary(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:366
System.Xml.ReadContentAsBinaryHelper.CreateOrReset
static ReadContentAsBinaryHelper CreateOrReset(ReadContentAsBinaryHelper helper, XmlReader reader)
Definition ReadContentAsBinaryHelper.cs:44
System.Xml.ReadContentAsBinaryHelper.ReadContentAsBinaryAsync
async Task< int > ReadContentAsBinaryAsync(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:655
System.Xml.ReadContentAsBinaryHelper.ReadContentAsBinary
int ReadContentAsBinary(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:319
System.Xml.ReadContentAsBinaryHelper.ReadContentAsBase64Async
async Task< int > ReadContentAsBase64Async(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:423
System.Xml.ReadContentAsBinaryHelper.MoveToNextContentNode
bool MoveToNextContentNode(bool moveIfOnContentNode)
Definition ReadContentAsBinaryHelper.cs:386
System.Xml.ReadContentAsBinaryHelper.ReadContentAsBase64
int ReadContentAsBase64(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:54
System.Xml.ReadContentAsBinaryHelper.MoveToNextContentNodeAsync
async Task< bool > MoveToNextContentNodeAsync(bool moveIfOnContentNode)
Definition ReadContentAsBinaryHelper.cs:722
System.Xml.ReadContentAsBinaryHelper.ReadContentAsBinHex
int ReadContentAsBinHex(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:99
System.Xml.ReadContentAsBinaryHelper.ReadElementContentAsBinHex
int ReadElementContentAsBinHex(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:189
System.Xml.ReadContentAsBinaryHelper.ReadElementContentAsBase64
int ReadElementContentAsBase64(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:144
System.Xml.ReadContentAsBinaryHelper.ReadElementContentAsBinaryAsync
async Task< int > ReadElementContentAsBinaryAsync(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:702
System.Xml.ReadContentAsBinaryHelper.ReadElementContentAsBinHexAsync
async Task< int > ReadElementContentAsBinHexAsync(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:558
System.Xml.ReadContentAsBinaryHelper.ReadContentAsBinHexAsync
async Task< int > ReadContentAsBinHexAsync(byte[] buffer, int index, int count)
Definition ReadContentAsBinaryHelper.cs:468
System.Xml.XmlReader.CreateReadElementContentAsException
Exception CreateReadElementContentAsException(string methodName)
Definition XmlReader.cs:1189
System.Xml.XmlReader.CanResolveEntity
virtual bool CanResolveEntity
Definition XmlReader.cs:118
System.Xml.XmlReader.CreateReadContentAsException
Exception CreateReadContentAsException(string methodName)
Definition XmlReader.cs:1184
System.Xml.XmlReader.ReadValueChunk
virtual int ReadValueChunk(char[] buffer, int index, int count)
Definition XmlReader.cs:564
System.Xml.XmlReader.ReadValueChunkAsync
virtual Task< int > ReadValueChunkAsync(char[] buffer, int index, int count)
Definition XmlReader.cs:1610
System.Xml.XmlReader.ReadAsync
virtual Task< bool > ReadAsync()
Definition XmlReader.cs:1576
System.Xml.XmlReader.NodeType
XmlNodeType NodeType
Definition XmlReader.cs:62
System.Xml.XmlReader.CanReadContentAs
static bool CanReadContentAs(XmlNodeType nodeType)
Definition XmlReader.cs:1136
System.Xml.XmlReader.GetValueAsync
virtual Task< string > GetValueAsync()
Definition XmlReader.cs:1495
System.Xml.XmlReader.CanReadValueChunk
virtual bool CanReadValueChunk
Definition XmlReader.cs:122