mcs/class/referencesource/System.Data/System/Data/ProviderBase/DataReaderContainer.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="DataReaderContainer.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 // <owner current="true" primary="true">Microsoft</owner>
   6 //------------------------------------------------------------------------------
   7
   8 namespace System.Data.ProviderBase {
   9
  10     using System;
  11     using System.Data;
  12     using System.Data.Common;
  13     using System.Diagnostics;
  14
  15     internal abstract class DataReaderContainer {
  16
  17         protected readonly IDataReader _dataReader;
  18         protected int _fieldCount;
  19
  20         static internal DataReaderContainer Create(IDataReader dataReader, bool returnProviderSpecificTypes) {
  21             if (returnProviderSpecificTypes) {
  22                 DbDataReader providerSpecificDataReader = (dataReader as DbDataReader);
  23                 if (null != providerSpecificDataReader) {
  24                     return new ProviderSpecificDataReader(dataReader, providerSpecificDataReader);
  25                 }
  26             }
  27             return new CommonLanguageSubsetDataReader(dataReader);
  28         }
  29
  30         protected DataReaderContainer(IDataReader dataReader) {
  31             Debug.Assert(null != dataReader, "null dataReader");
  32             _dataReader = dataReader;
  33         }
  34
  35         internal int FieldCount {
  36             get {
  37                 return _fieldCount;
  38             }
  39         }
  40
  41         internal abstract bool ReturnProviderSpecificTypes { get; }
  42         protected abstract int VisibleFieldCount { get; }
  43
  44         internal abstract Type GetFieldType(int ordinal);
  45         internal abstract object GetValue(int ordinal);
  46         internal abstract int GetValues(object[] values);
  47
  48         internal string GetName(int ordinal) {
  49             string fieldName = _dataReader.GetName(ordinal);
  50             Debug.Assert(null != fieldName, "null GetName");
  51             return ((null != fieldName) ? fieldName : "");
  52         }
  53         internal DataTable GetSchemaTable() {
  54             return _dataReader.GetSchemaTable();
  55         }
  56         internal bool NextResult() {
  57             _fieldCount = 0;
  58             if (_dataReader.NextResult()) {
  59                 _fieldCount = VisibleFieldCount;
  60                 return true;
  61             }
  62             return false;
  63         }
  64         internal bool Read() {
  65             return _dataReader.Read();
  66         }
  67
  68         private sealed class ProviderSpecificDataReader : DataReaderContainer {
  69             private DbDataReader _providerSpecificDataReader;
  70
  71             internal ProviderSpecificDataReader(IDataReader dataReader, DbDataReader dbDataReader) : base(dataReader) {
  72                 Debug.Assert(null != dataReader, "null dbDataReader");
  73                 _providerSpecificDataReader = dbDataReader;
  74                 _fieldCount = VisibleFieldCount;
  75             }
  76
  77             internal override bool ReturnProviderSpecificTypes {
  78                 get {
  79                     return true;
  80                 }
  81             }
  82             protected override int VisibleFieldCount {
  83                 get {
  84                     int fieldCount = _providerSpecificDataReader.VisibleFieldCount;
  85                     Debug.Assert(0 <= fieldCount, "negative FieldCount");
  86                     return ((0 <= fieldCount) ? fieldCount : 0);
  87                 }
  88             }
  89
  90             internal override Type GetFieldType(int ordinal) {
  91                 Type fieldType = _providerSpecificDataReader.GetProviderSpecificFieldType(ordinal);
  92                 Debug.Assert(null != fieldType, "null FieldType");
  93                 return fieldType;
  94             }
  95             internal override object GetValue(int ordinal) {
  96                 return _providerSpecificDataReader.GetProviderSpecificValue(ordinal);
  97             }
  98             internal override int GetValues(object[] values) {
  99                 return _providerSpecificDataReader.GetProviderSpecificValues(values);
 100             }
 101         }
 102
 103         private sealed class CommonLanguageSubsetDataReader : DataReaderContainer {
 104
 105             internal CommonLanguageSubsetDataReader(IDataReader dataReader ) : base(dataReader) {
 106                 _fieldCount = VisibleFieldCount;
 107             }
 108
 109             internal override bool ReturnProviderSpecificTypes {
 110                 get {
 111                     return false;
 112                 }
 113             }
 114             protected override int VisibleFieldCount {
 115                 get {
 116                     int fieldCount = _dataReader.FieldCount;
 117                     Debug.Assert(0 <= fieldCount, "negative FieldCount");
 118                     return ((0 <= fieldCount) ? fieldCount : 0);
 119                 }
 120             }
 121
 122             internal override Type GetFieldType(int ordinal) {
 123                 return _dataReader.GetFieldType(ordinal);
 124             }
 125             internal override object GetValue(int ordinal) {
 126                 return _dataReader.GetValue(ordinal);
 127             }
 128             internal override int GetValues(object[] values) {
 129                 return _dataReader.GetValues(values);
 130             }
 131         }
 132     }
 133 }