mcs/class/referencesource/System.Data/System/Data/Common/dbenumerator.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="dbenumerator.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 // <owner current="true" primary="true">Microsoft</owner>
   6 // <owner current="true" primary="false">Microsoft</owner>
   7 //------------------------------------------------------------------------------
   8
   9 namespace System.Data.Common {
  10
  11     using System;
  12     using System.Collections;
  13     using System.Data;
  14     using System.Data.ProviderBase;
  15     using System.Diagnostics;
  16     using System.ComponentModel;
  17
  18     public class DbEnumerator : IEnumerator {
  19
  20         internal IDataReader _reader;
  21         internal DbDataRecord _current;
  22         internal SchemaInfo[] _schemaInfo; // shared schema info among all the data records
  23         internal PropertyDescriptorCollection _descriptors; // cached property descriptors
  24         private FieldNameLookup _fieldNameLookup; // MDAC 69015
  25         private bool closeReader;
  26
  27         // users must get enumerators off of the datareader interfaces
  28         public DbEnumerator(IDataReader reader) {
  29             if (null == reader) {
  30                 throw ADP.ArgumentNull("reader");
  31             }
  32             _reader = reader;
  33         }
  34
  35         public DbEnumerator(IDataReader reader, bool closeReader) { // MDAC 68670
  36             if (null == reader) {
  37                 throw ADP.ArgumentNull("reader");
  38             }
  39             _reader = reader;
  40             this.closeReader = closeReader;
  41         }
  42
  43         public DbEnumerator(DbDataReader reader)
  44             : this((IDataReader)reader) {
  45         }
  46
  47         public DbEnumerator(DbDataReader reader, bool closeReader)
  48             : this((IDataReader)reader, closeReader) {
  49         }
  50
  51         public object Current {
  52             get {
  53                 return _current;
  54             }
  55         }
  56
  57         public bool MoveNext() {
  58
  59             if (null == _schemaInfo) {
  60                   BuildSchemaInfo();
  61             }
  62
  63             Debug.Assert(null != _schemaInfo && null != _descriptors, "unable to build schema information!");
  64             _current = null;
  65
  66             if (_reader.Read()) {
  67                 // setup our current record
  68                 object[] values = new object[_schemaInfo.Length];
  69                 _reader.GetValues(values); // this.GetValues()
  70                 _current = new DataRecordInternal(_schemaInfo, values, _descriptors, _fieldNameLookup); // this.NewRecord()
  71                 return true;
  72             }
  73             if (closeReader) {
  74                 _reader.Close();
  75             }
  76             return false;
  77         }
  78
  79         [ EditorBrowsableAttribute(EditorBrowsableState.Never) ] // MDAC 69508
  80         public void Reset() {
  81             throw ADP.NotSupported();
  82         }
  83
  84         private void BuildSchemaInfo() {
  85             int count = _reader.FieldCount;
  86             string[] fieldnames = new string[count];
  87             for (int i = 0; i < count; ++i) {
  88                 fieldnames[i] = _reader.GetName(i);
  89             }
  90             ADP.BuildSchemaTableInfoTableNames(fieldnames); // MDAC 71401
  91
  92             SchemaInfo[] si = new SchemaInfo[count];
  93             PropertyDescriptor[] props = new PropertyDescriptor[_reader.FieldCount];
  94             for (int i = 0; i < si.Length; i++) {
  95                 SchemaInfo s = new SchemaInfo();
  96                 s.name = _reader.GetName(i);
  97                 s.type = _reader.GetFieldType(i);
  98                 s.typeName = _reader.GetDataTypeName(i);
  99                 props[i] = new DbColumnDescriptor(i, fieldnames[i], s.type);
 100                 si[i] = s;
 101             }
 102
 103             _schemaInfo = si;
 104             _fieldNameLookup = new FieldNameLookup(_reader, -1); // MDAC 71470
 105             _descriptors = new PropertyDescriptorCollection(props);
 106         }
 107
 108         sealed private class DbColumnDescriptor : PropertyDescriptor {
 109             int _ordinal;
 110             Type _type;
 111
 112             internal DbColumnDescriptor(int ordinal, string name, Type type)
 113                 : base(name, null) {
 114                 _ordinal = ordinal;
 115                 _type = type;
 116             }
 117
 118             public override Type ComponentType {
 119                 get {
 120                     return typeof(IDataRecord);
 121                 }
 122             }
 123
 124             public override bool IsReadOnly {
 125                 get {
 126                     return true;
 127                 }
 128             }
 129
 130             public override Type PropertyType {
 131                 get {
 132                     return _type;
 133                 }
 134             }
 135
 136             public override bool CanResetValue(object component) {
 137                 return false;
 138             }
 139
 140             public override object GetValue(object component) {
 141                 return ((IDataRecord)component)[_ordinal];
 142             }
 143
 144             public override void ResetValue(object component) {
 145                 throw ADP.NotSupported();
 146             }
 147
 148             public override void SetValue(object component, object value) {
 149                 throw ADP.NotSupported();
 150             }
 151
 152             public override bool ShouldSerializeValue(object component) {
 153                 return false;
 154             }
 155         }
 156     }
 157 }