mcs/class/referencesource/System.Xml/System/Xml/Core/XmlAsyncCheckReader.cs

   1
   2 using System.Collections.Generic;
   3 using System.Diagnostics;
   4 using System.Threading.Tasks;
   5 using System.Xml.Schema;
   6
   7 namespace System.Xml {
   8
   9     internal class XmlAsyncCheckReader : XmlReader {
  10
  11         private readonly XmlReader coreReader = null;
  12         private Task lastTask = AsyncHelper.DoneTask;
  13
  14         internal XmlReader CoreReader {
  15             get {
  16                 return coreReader;
  17             }
  18         }
  19
  20         public static XmlAsyncCheckReader CreateAsyncCheckWrapper(XmlReader reader)
  21         {
  22             if (reader is IXmlLineInfo) {
  23                 if (reader is IXmlNamespaceResolver) {
  24 #if !FEATURE_NETCORE
  25                     if (reader is IXmlSchemaInfo) {
  26                         return new XmlAsyncCheckReaderWithLineInfoNSSchema(reader);
  27                     }
  28 #endif // !FEATURE_NETCORE
  29                     return new XmlAsyncCheckReaderWithLineInfoNS(reader);
  30                 }
  31 #if !FEATURE_NETCORE
  32                 Debug.Assert(!(reader is IXmlSchemaInfo));
  33 #endif // !FEATURE_NETCORE
  34                 return new XmlAsyncCheckReaderWithLineInfo(reader);
  35             }
  36             else if (reader is IXmlNamespaceResolver) {
  37 #if !FEATURE_NETCORE
  38                 Debug.Assert(!(reader is IXmlSchemaInfo));
  39 #endif // !FEATURE_NETCORE
  40                 return new XmlAsyncCheckReaderWithNS(reader);
  41             }
  42 #if !FEATURE_NETCORE
  43             Debug.Assert(!(reader is IXmlSchemaInfo));
  44 #endif // !FEATURE_NETCORE
  45             return new XmlAsyncCheckReader(reader);
  46         }
  47
  48         public XmlAsyncCheckReader(XmlReader reader) {
  49             coreReader = reader;
  50         }
  51
  52         private void CheckAsync() {
  53             if (!lastTask.IsCompleted) {
  54                 throw new InvalidOperationException(Res.GetString(Res.Xml_AsyncIsRunningException));
  55             }
  56         }
  57
  58         #region Sync Methods, Properties Check
  59
  60         public override XmlReaderSettings Settings {
  61             get {
  62                 XmlReaderSettings settings = coreReader.Settings;
  63                 if (null != settings) {
  64                     settings = settings.Clone();
  65                 }
  66                 else {
  67                     settings = new XmlReaderSettings();
  68                 }
  69                 settings.Async = true;
  70                 settings.ReadOnly = true;
  71                 return settings;
  72             }
  73         }
  74
  75         public override XmlNodeType NodeType {
  76             get {
  77                 CheckAsync();
  78                 return coreReader.NodeType;
  79             }
  80         }
  81
  82         public override string Name {
  83             get {
  84                 CheckAsync();
  85                 return coreReader.Name;
  86             }
  87         }
  88
  89         public override string LocalName {
  90             get {
  91                 CheckAsync();
  92                 return coreReader.LocalName;
  93             }
  94         }
  95
  96         public override string NamespaceURI {
  97             get {
  98                 CheckAsync();
  99                 return coreReader.NamespaceURI;
 100             }
 101         }
 102
 103         public override string Prefix {
 104             get {
 105                 CheckAsync();
 106                 return coreReader.Prefix;
 107             }
 108         }
 109
 110         public override bool HasValue {
 111             get {
 112                 CheckAsync();
 113                 return coreReader.HasValue;
 114             }
 115         }
 116
 117         public override string Value {
 118             get {
 119                 CheckAsync();
 120                 return coreReader.Value;
 121             }
 122         }
 123
 124         public override int Depth {
 125             get {
 126                 CheckAsync();
 127                 return coreReader.Depth;
 128             }
 129         }
 130
 131         public override string BaseURI {
 132             get {
 133                 CheckAsync();
 134                 return coreReader.BaseURI;
 135             }
 136         }
 137
 138         public override bool IsEmptyElement {
 139             get {
 140                 CheckAsync();
 141                 return coreReader.IsEmptyElement;
 142             }
 143         }
 144
 145         public override bool IsDefault {
 146             get {
 147                 CheckAsync();
 148                 return coreReader.IsDefault;
 149             }
 150         }
 151
 152 #if !SILVERLIGHT
 153         public override char QuoteChar {
 154             get {
 155                 CheckAsync();
 156                 return coreReader.QuoteChar;
 157             }
 158         }
 159 #endif // !SILVERLIGHT
 160
 161         public override XmlSpace XmlSpace {
 162             get {
 163                 CheckAsync();
 164                 return coreReader.XmlSpace;
 165             }
 166         }
 167
 168         public override string XmlLang {
 169             get {
 170                 CheckAsync();
 171                 return coreReader.XmlLang;
 172             }
 173         }
 174
 175 #if !FEATURE_NETCORE
 176         public override IXmlSchemaInfo SchemaInfo {
 177             get {
 178                 CheckAsync();
 179                 return coreReader.SchemaInfo;
 180             }
 181         }
 182 #endif // !FEATURE_NETCORE
 183
 184         public override System.Type ValueType {
 185             get {
 186                 CheckAsync();
 187                 return coreReader.ValueType;
 188             }
 189         }
 190
 191         public override object ReadContentAsObject() {
 192             CheckAsync();
 193             return coreReader.ReadContentAsObject();
 194         }
 195
 196         public override bool ReadContentAsBoolean() {
 197             CheckAsync();
 198             return coreReader.ReadContentAsBoolean();
 199         }
 200
 201         public override DateTime ReadContentAsDateTime() {
 202             CheckAsync();
 203             return coreReader.ReadContentAsDateTime();
 204         }
 205
 206         public override double ReadContentAsDouble() {
 207             CheckAsync();
 208             return coreReader.ReadContentAsDouble();
 209         }
 210
 211         public override float ReadContentAsFloat() {
 212             CheckAsync();
 213             return coreReader.ReadContentAsFloat();
 214         }
 215
 216         public override decimal ReadContentAsDecimal() {
 217             CheckAsync();
 218             return coreReader.ReadContentAsDecimal();
 219         }
 220
 221         public override int ReadContentAsInt() {
 222             CheckAsync();
 223             return coreReader.ReadContentAsInt();
 224         }
 225
 226         public override long ReadContentAsLong() {
 227             CheckAsync();
 228             return coreReader.ReadContentAsLong();
 229         }
 230
 231         public override string ReadContentAsString() {
 232             CheckAsync();
 233             return coreReader.ReadContentAsString();
 234         }
 235
 236         public override object ReadContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver) {
 237             CheckAsync();
 238             return coreReader.ReadContentAs(returnType, namespaceResolver);
 239         }
 240
 241         public override object ReadElementContentAsObject() {
 242             CheckAsync();
 243             return coreReader.ReadElementContentAsObject();
 244         }
 245
 246         public override object ReadElementContentAsObject(string localName, string namespaceURI) {
 247             CheckAsync();
 248             return coreReader.ReadElementContentAsObject(localName, namespaceURI);
 249         }
 250
 251         public override bool ReadElementContentAsBoolean() {
 252             CheckAsync();
 253             return coreReader.ReadElementContentAsBoolean();
 254         }
 255
 256         public override bool ReadElementContentAsBoolean(string localName, string namespaceURI) {
 257             CheckAsync();
 258             return coreReader.ReadElementContentAsBoolean(localName, namespaceURI);
 259         }
 260
 261         public override DateTime ReadElementContentAsDateTime() {
 262             CheckAsync();
 263             return coreReader.ReadElementContentAsDateTime();
 264         }
 265
 266         public override DateTime ReadElementContentAsDateTime(string localName, string namespaceURI) {
 267             CheckAsync();
 268             return coreReader.ReadElementContentAsDateTime(localName, namespaceURI);
 269         }
 270
 271         public override DateTimeOffset ReadContentAsDateTimeOffset() {
 272             CheckAsync();
 273             return coreReader.ReadContentAsDateTimeOffset();
 274         }
 275
 276         public override double ReadElementContentAsDouble() {
 277             CheckAsync();
 278             return coreReader.ReadElementContentAsDouble();
 279         }
 280
 281         public override double ReadElementContentAsDouble(string localName, string namespaceURI) {
 282             CheckAsync();
 283             return coreReader.ReadElementContentAsDouble(localName, namespaceURI);
 284         }
 285
 286         public override float ReadElementContentAsFloat() {
 287             CheckAsync();
 288             return coreReader.ReadElementContentAsFloat();
 289         }
 290
 291         public override float ReadElementContentAsFloat(string localName, string namespaceURI) {
 292             CheckAsync();
 293             return coreReader.ReadElementContentAsFloat(localName, namespaceURI);
 294         }
 295
 296         public override decimal ReadElementContentAsDecimal() {
 297             CheckAsync();
 298             return coreReader.ReadElementContentAsDecimal();
 299         }
 300
 301         public override decimal ReadElementContentAsDecimal(string localName, string namespaceURI) {
 302             CheckAsync();
 303             return coreReader.ReadElementContentAsDecimal(localName, namespaceURI);
 304         }
 305
 306         public override int ReadElementContentAsInt() {
 307             CheckAsync();
 308             return coreReader.ReadElementContentAsInt();
 309         }
 310
 311         public override int ReadElementContentAsInt(string localName, string namespaceURI) {
 312             CheckAsync();
 313             return coreReader.ReadElementContentAsInt(localName, namespaceURI);
 314         }
 315
 316         public override long ReadElementContentAsLong() {
 317             CheckAsync();
 318             return coreReader.ReadElementContentAsLong();
 319         }
 320
 321         public override long ReadElementContentAsLong(string localName, string namespaceURI) {
 322             CheckAsync();
 323             return coreReader.ReadElementContentAsLong(localName, namespaceURI);
 324         }
 325
 326         public override string ReadElementContentAsString() {
 327             CheckAsync();
 328             return coreReader.ReadElementContentAsString();
 329         }
 330
 331         public override string ReadElementContentAsString(string localName, string namespaceURI) {
 332             CheckAsync();
 333             return coreReader.ReadElementContentAsString(localName, namespaceURI);
 334         }
 335
 336         public override object ReadElementContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver) {
 337             CheckAsync();
 338             return coreReader.ReadElementContentAs(returnType, namespaceResolver);
 339         }
 340
 341         public override object ReadElementContentAs(Type returnType, IXmlNamespaceResolver namespaceResolver, string localName, string namespaceURI) {
 342             CheckAsync();
 343             return coreReader.ReadElementContentAs(returnType, namespaceResolver, localName, namespaceURI);
 344         }
 345
 346         public override int AttributeCount {
 347             get {
 348                 CheckAsync();
 349                 return coreReader.AttributeCount;
 350             }
 351         }
 352
 353         public override string GetAttribute(string name) {
 354             CheckAsync();
 355             return coreReader.GetAttribute(name);
 356         }
 357
 358         public override string GetAttribute(string name, string namespaceURI) {
 359             CheckAsync();
 360             return coreReader.GetAttribute(name, namespaceURI);
 361         }
 362
 363         public override string GetAttribute(int i) {
 364             CheckAsync();
 365             return coreReader.GetAttribute(i);
 366         }
 367
 368         public override string this[int i] {
 369             get {
 370                 CheckAsync();
 371                 return coreReader[i];
 372             }
 373         }
 374
 375         public override string this[string name] {
 376             get {
 377                 CheckAsync();
 378                 return coreReader[name];
 379             }
 380         }
 381
 382         public override string this[string name, string namespaceURI] {
 383             get {
 384                 CheckAsync();
 385                 return coreReader[name, namespaceURI];
 386             }
 387         }
 388
 389         public override bool MoveToAttribute(string name) {
 390             CheckAsync();
 391             return coreReader.MoveToAttribute(name);
 392         }
 393
 394         public override bool MoveToAttribute(string name, string ns) {
 395             CheckAsync();
 396             return coreReader.MoveToAttribute(name, ns);
 397         }
 398
 399         public override void MoveToAttribute(int i) {
 400             CheckAsync();
 401             coreReader.MoveToAttribute(i);
 402         }
 403
 404         public override bool MoveToFirstAttribute() {
 405             CheckAsync();
 406             return coreReader.MoveToFirstAttribute();
 407         }
 408
 409         public override bool MoveToNextAttribute() {
 410             CheckAsync();
 411             return coreReader.MoveToNextAttribute();
 412         }
 413
 414         public override bool MoveToElement() {
 415             CheckAsync();
 416             return coreReader.MoveToElement();
 417         }
 418
 419         public override bool ReadAttributeValue() {
 420             CheckAsync();
 421             return coreReader.ReadAttributeValue();
 422         }
 423
 424         public override bool Read() {
 425             CheckAsync();
 426             return coreReader.Read();
 427         }
 428
 429         public override bool EOF {
 430             get {
 431                 CheckAsync();
 432                 return coreReader.EOF;
 433             }
 434         }
 435
 436         public override void Close() {
 437             CheckAsync();
 438             coreReader.Close();
 439         }
 440
 441         public override ReadState ReadState {
 442             get {
 443                 CheckAsync();
 444                 return coreReader.ReadState;
 445             }
 446         }
 447
 448         public override void Skip() {
 449             CheckAsync();
 450             coreReader.Skip();
 451         }
 452
 453         public override XmlNameTable NameTable {
 454             get {
 455                 CheckAsync();
 456                 return coreReader.NameTable;
 457             }
 458         }
 459
 460         public override string LookupNamespace(string prefix) {
 461             CheckAsync();
 462             return coreReader.LookupNamespace(prefix);
 463         }
 464
 465         public override bool CanResolveEntity {
 466             get {
 467                 CheckAsync();
 468                 return coreReader.CanResolveEntity;
 469             }
 470         }
 471
 472         public override void ResolveEntity() {
 473             CheckAsync();
 474             coreReader.ResolveEntity();
 475         }
 476
 477         public override bool CanReadBinaryContent {
 478             get {
 479                 CheckAsync();
 480                 return coreReader.CanReadBinaryContent;
 481             }
 482         }
 483
 484         public override int ReadContentAsBase64(byte[] buffer, int index, int count) {
 485             CheckAsync();
 486             return coreReader.ReadContentAsBase64(buffer, index, count);
 487         }
 488
 489         public override int ReadElementContentAsBase64(byte[] buffer, int index, int count) {
 490             CheckAsync();
 491             return coreReader.ReadElementContentAsBase64(buffer, index, count);
 492         }
 493
 494         public override int ReadContentAsBinHex(byte[] buffer, int index, int count) {
 495             CheckAsync();
 496             return coreReader.ReadContentAsBinHex(buffer, index, count);
 497         }
 498
 499         public override int ReadElementContentAsBinHex(byte[] buffer, int index, int count) {
 500             CheckAsync();
 501             return coreReader.ReadElementContentAsBinHex(buffer, index, count);
 502         }
 503
 504         public override bool CanReadValueChunk {
 505             get {
 506                 CheckAsync();
 507                 return coreReader.CanReadValueChunk;
 508             }
 509         }
 510
 511         public override int ReadValueChunk(char[] buffer, int index, int count) {
 512             CheckAsync();
 513             return coreReader.ReadValueChunk(buffer, index, count);
 514         }
 515
 516 #if !SILVERLIGHT
 517         public override string ReadString() {
 518             CheckAsync();
 519             return coreReader.ReadString();
 520         }
 521 #endif // !SILVERLIGHT
 522
 523         public override XmlNodeType MoveToContent() {
 524             CheckAsync();
 525             return coreReader.MoveToContent();
 526         }
 527
 528         public override void ReadStartElement() {
 529             CheckAsync();
 530             coreReader.ReadStartElement();
 531         }
 532
 533         public override void ReadStartElement(string name) {
 534             CheckAsync();
 535             coreReader.ReadStartElement(name);
 536         }
 537
 538         public override void ReadStartElement(string localname, string ns) {
 539             CheckAsync();
 540             coreReader.ReadStartElement(localname, ns);
 541         }
 542
 543 #if !SILVERLIGHT
 544         public override string ReadElementString() {
 545             CheckAsync();
 546             return coreReader.ReadElementString();
 547         }
 548
 549         public override string ReadElementString(string name) {
 550             CheckAsync();
 551             return coreReader.ReadElementString(name);
 552         }
 553
 554         public override string ReadElementString(string localname, string ns) {
 555             CheckAsync();
 556             return coreReader.ReadElementString(localname, ns);
 557         }
 558 #endif // !SILVERLIGHT
 559
 560         public override void ReadEndElement() {
 561             CheckAsync();
 562             coreReader.ReadEndElement();
 563         }
 564
 565         public override bool IsStartElement() {
 566             CheckAsync();
 567             return coreReader.IsStartElement();
 568         }
 569
 570         public override bool IsStartElement(string name) {
 571             CheckAsync();
 572             return coreReader.IsStartElement(name);
 573         }
 574
 575         public override bool IsStartElement(string localname, string ns) {
 576             CheckAsync();
 577             return coreReader.IsStartElement(localname, ns);
 578         }
 579
 580         public override bool ReadToFollowing(string name) {
 581             CheckAsync();
 582             return coreReader.ReadToFollowing(name);
 583         }
 584
 585         public override bool ReadToFollowing(string localName, string namespaceURI) {
 586             CheckAsync();
 587             return coreReader.ReadToFollowing(localName, namespaceURI);
 588         }
 589
 590         public override bool ReadToDescendant(string name) {
 591             CheckAsync();
 592             return coreReader.ReadToDescendant(name);
 593         }
 594
 595         public override bool ReadToDescendant(string localName, string namespaceURI) {
 596             CheckAsync();
 597             return coreReader.ReadToDescendant(localName, namespaceURI);
 598         }
 599
 600         public override bool ReadToNextSibling(string name) {
 601             CheckAsync();
 602             return coreReader.ReadToNextSibling(name);
 603         }
 604
 605         public override bool ReadToNextSibling(string localName, string namespaceURI) {
 606             CheckAsync();
 607             return coreReader.ReadToNextSibling(localName, namespaceURI);
 608         }
 609
 610         public override string ReadInnerXml() {
 611             CheckAsync();
 612             return coreReader.ReadInnerXml();
 613         }
 614
 615         public override string ReadOuterXml() {
 616             CheckAsync();
 617             return coreReader.ReadOuterXml();
 618         }
 619
 620         public override XmlReader ReadSubtree() {
 621             CheckAsync();
 622             XmlReader subtreeReader = coreReader.ReadSubtree();
 623             return CreateAsyncCheckWrapper(subtreeReader);
 624         }
 625
 626         public override bool HasAttributes {
 627             get {
 628                 CheckAsync();
 629                 return coreReader.HasAttributes;
 630             }
 631         }
 632
 633         protected override void Dispose(bool disposing) {
 634             CheckAsync();
 635             //since it is protected method, we can't call coreReader.Dispose(disposing).
 636             //Internal, it is always called to Dipose(true). So call coreReader.Dispose() is OK.
 637             coreReader.Dispose();
 638         }
 639
 640 #if !SILVERLIGHT
 641         internal override XmlNamespaceManager NamespaceManager {
 642             get {
 643                 CheckAsync();
 644                 return coreReader.NamespaceManager;
 645             }
 646         }
 647
 648         internal override IDtdInfo DtdInfo {
 649             get {
 650                 CheckAsync();
 651                 return coreReader.DtdInfo;
 652             }
 653         }
 654 #endif
 655
 656         #endregion
 657
 658         #region Async Methods
 659
 660         public override Task<string> GetValueAsync() {
 661             CheckAsync();
 662             var task = coreReader.GetValueAsync();
 663             lastTask = task;
 664             return task;
 665         }
 666
 667         public override Task<object> ReadContentAsObjectAsync() {
 668             CheckAsync();
 669             var task = coreReader.ReadContentAsObjectAsync();
 670             lastTask = task;
 671             return task;
 672         }
 673
 674         public override Task<string> ReadContentAsStringAsync() {
 675             CheckAsync();
 676             var task = coreReader.ReadContentAsStringAsync();
 677             lastTask = task;
 678             return task;
 679         }
 680
 681         public override Task<object> ReadContentAsAsync(Type returnType, IXmlNamespaceResolver namespaceResolver) {
 682             CheckAsync();
 683             var task = coreReader.ReadContentAsAsync(returnType, namespaceResolver);
 684             lastTask = task;
 685             return task;
 686         }
 687
 688         public override Task<object> ReadElementContentAsObjectAsync() {
 689             CheckAsync();
 690             var task = coreReader.ReadElementContentAsObjectAsync();
 691             lastTask = task;
 692             return task;
 693         }
 694
 695         public override Task<string> ReadElementContentAsStringAsync() {
 696             CheckAsync();
 697             var task = coreReader.ReadElementContentAsStringAsync();
 698             lastTask = task;
 699             return task;
 700         }
 701
 702         public override Task<object> ReadElementContentAsAsync(Type returnType, IXmlNamespaceResolver namespaceResolver) {
 703             CheckAsync();
 704             var task = coreReader.ReadElementContentAsAsync(returnType, namespaceResolver);
 705             lastTask = task;
 706             return task;
 707         }
 708
 709         public override Task<bool> ReadAsync() {
 710             CheckAsync();
 711             var task = coreReader.ReadAsync();
 712             lastTask = task;
 713             return task;
 714         }
 715
 716         public override Task SkipAsync() {
 717             CheckAsync();
 718             var task = coreReader.SkipAsync();
 719             lastTask = task;
 720             return task;
 721         }
 722
 723         public override Task<int> ReadContentAsBase64Async(byte[] buffer, int index, int count) {
 724             CheckAsync();
 725             var task = coreReader.ReadContentAsBase64Async(buffer, index, count);
 726             lastTask = task;
 727             return task;
 728         }
 729
 730         public override Task<int> ReadElementContentAsBase64Async(byte[] buffer, int index, int count) {
 731             CheckAsync();
 732             var task = coreReader.ReadElementContentAsBase64Async(buffer, index, count);
 733             lastTask = task;
 734             return task;
 735         }
 736
 737         public override Task<int> ReadContentAsBinHexAsync(byte[] buffer, int index, int count) {
 738             CheckAsync();
 739             var task = coreReader.ReadContentAsBinHexAsync(buffer, index, count);
 740             lastTask = task;
 741             return task;
 742         }
 743
 744         public override Task<int> ReadElementContentAsBinHexAsync(byte[] buffer, int index, int count) {
 745             CheckAsync();
 746             var task = coreReader.ReadElementContentAsBinHexAsync(buffer, index, count);
 747             lastTask = task;
 748             return task;
 749         }
 750
 751         public override Task<int> ReadValueChunkAsync(char[] buffer, int index, int count) {
 752             CheckAsync();
 753             var task = coreReader.ReadValueChunkAsync(buffer, index, count);
 754             lastTask = task;
 755             return task;
 756         }
 757
 758         public override Task<XmlNodeType> MoveToContentAsync() {
 759             CheckAsync();
 760             var task = coreReader.MoveToContentAsync();
 761             lastTask = task;
 762             return task;
 763         }
 764
 765         public override Task<string> ReadInnerXmlAsync() {
 766             CheckAsync();
 767             var task = coreReader.ReadInnerXmlAsync();
 768             lastTask = task;
 769             return task;
 770         }
 771
 772         public override Task<string> ReadOuterXmlAsync() {
 773             CheckAsync();
 774             var task = coreReader.ReadOuterXmlAsync();
 775             lastTask = task;
 776             return task;
 777         }
 778
 779         #endregion
 780
 781     }
 782
 783     internal class XmlAsyncCheckReaderWithNS : XmlAsyncCheckReader, IXmlNamespaceResolver {
 784         private readonly IXmlNamespaceResolver readerAsIXmlNamespaceResolver;
 785
 786         public XmlAsyncCheckReaderWithNS(XmlReader reader)
 787             : base(reader) {
 788
 789             readerAsIXmlNamespaceResolver = (IXmlNamespaceResolver)reader;
 790         }
 791
 792         #region IXmlNamespaceResolver members
 793         IDictionary<string, string> IXmlNamespaceResolver.GetNamespacesInScope(XmlNamespaceScope scope)
 794         {
 795             return readerAsIXmlNamespaceResolver.GetNamespacesInScope(scope);
 796         }
 797
 798         string IXmlNamespaceResolver.LookupNamespace(string prefix)
 799         {
 800             return readerAsIXmlNamespaceResolver.LookupNamespace(prefix);
 801         }
 802
 803         string IXmlNamespaceResolver.LookupPrefix(string namespaceName)
 804         {
 805             return readerAsIXmlNamespaceResolver.LookupPrefix(namespaceName);
 806         }
 807         #endregion
 808     }
 809
 810     internal class XmlAsyncCheckReaderWithLineInfo : XmlAsyncCheckReader, IXmlLineInfo {
 811
 812         private readonly IXmlLineInfo readerAsIXmlLineInfo;
 813
 814         public XmlAsyncCheckReaderWithLineInfo(XmlReader reader)
 815             : base(reader) {
 816
 817             readerAsIXmlLineInfo = (IXmlLineInfo)reader;
 818         }
 819
 820         #region IXmlLineInfo members
 821         public virtual bool HasLineInfo() {
 822             return readerAsIXmlLineInfo.HasLineInfo();
 823         }
 824
 825         public virtual int LineNumber {
 826             get {
 827                 return readerAsIXmlLineInfo.LineNumber;
 828             }
 829         }
 830
 831         public virtual int LinePosition {
 832             get {
 833                 return readerAsIXmlLineInfo.LinePosition;
 834             }
 835         }
 836         #endregion
 837     }
 838
 839     internal class XmlAsyncCheckReaderWithLineInfoNS : XmlAsyncCheckReaderWithLineInfo, IXmlNamespaceResolver {
 840
 841         private readonly IXmlNamespaceResolver readerAsIXmlNamespaceResolver;
 842
 843         public XmlAsyncCheckReaderWithLineInfoNS(XmlReader reader)
 844             : base(reader) {
 845
 846             readerAsIXmlNamespaceResolver = (IXmlNamespaceResolver)reader;
 847         }
 848
 849         #region IXmlNamespaceResolver members
 850         IDictionary<string, string> IXmlNamespaceResolver.GetNamespacesInScope(XmlNamespaceScope scope) {
 851             return readerAsIXmlNamespaceResolver.GetNamespacesInScope(scope);
 852         }
 853
 854         string IXmlNamespaceResolver.LookupNamespace(string prefix) {
 855             return readerAsIXmlNamespaceResolver.LookupNamespace(prefix);
 856         }
 857
 858         string IXmlNamespaceResolver.LookupPrefix(string namespaceName) {
 859             return readerAsIXmlNamespaceResolver.LookupPrefix(namespaceName);
 860         }
 861         #endregion
 862     }
 863
 864 #if !FEATURE_NETCORE
 865     internal class XmlAsyncCheckReaderWithLineInfoNSSchema : XmlAsyncCheckReaderWithLineInfoNS, IXmlSchemaInfo {
 866
 867         private readonly IXmlSchemaInfo readerAsIXmlSchemaInfo;
 868
 869         public XmlAsyncCheckReaderWithLineInfoNSSchema(XmlReader reader)
 870             : base(reader) {
 871
 872             readerAsIXmlSchemaInfo = (IXmlSchemaInfo)reader;
 873         }
 874
 875
 876         #region IXmlSchemaInfo members
 877
 878         XmlSchemaValidity IXmlSchemaInfo.Validity {
 879             get {
 880                 return readerAsIXmlSchemaInfo.Validity;
 881             }
 882         }
 883
 884         bool IXmlSchemaInfo.IsDefault {
 885             get {
 886                 return readerAsIXmlSchemaInfo.IsDefault;
 887             }
 888         }
 889
 890         bool IXmlSchemaInfo.IsNil {
 891             get {
 892                 return readerAsIXmlSchemaInfo.IsNil;
 893             }
 894         }
 895
 896         XmlSchemaSimpleType IXmlSchemaInfo.MemberType {
 897             get {
 898                 return readerAsIXmlSchemaInfo.MemberType;
 899             }
 900         }
 901
 902         XmlSchemaType IXmlSchemaInfo.SchemaType {
 903             get {
 904                 return readerAsIXmlSchemaInfo.SchemaType;
 905             }
 906         }
 907
 908         XmlSchemaElement IXmlSchemaInfo.SchemaElement {
 909             get {
 910                 return readerAsIXmlSchemaInfo.SchemaElement;
 911             }
 912         }
 913
 914         XmlSchemaAttribute IXmlSchemaInfo.SchemaAttribute {
 915             get {
 916                 return readerAsIXmlSchemaInfo.SchemaAttribute;
 917             }
 918         }
 919         #endregion
 920     }
 921 #endif // !FEATURE_NETCORE
 922 }