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