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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
//------------------------------------------------------------------------------
// <copyright file="DataRowExtenstions.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="false">spather</owner>
//------------------------------------------------------------------------------
using System;
using System.Data.DataSetExtensions;
namespace System.Data {
/// <summary>
/// This static class defines the DataRow extension methods.
/// </summary>
public static class DataRowExtensions {
/// <summary>
/// This method provides access to the values in each of the columns in a given row.
/// This method makes casts unnecessary when accessing columns.
/// Additionally, Field supports nullable types and maps automatically between DBNull and
/// Nullable when the generic type is nullable.
/// </summary>
/// <param name="row">
/// The input DataRow
/// </param>
/// <param name="columnName">
/// The input column name specificy which row value to retrieve.
/// </param>
/// <returns>
/// The DataRow value for the column specified.
/// </returns>
public static T Field<T>(this DataRow row, string columnName) {
DataSetUtil.CheckArgumentNull(row, "row");
return UnboxT<T>.Unbox(row[columnName]);
}
/// <summary>
/// This method provides access to the values in each of the columns in a given row.
/// This method makes casts unnecessary when accessing columns.
/// Additionally, Field supports nullable types and maps automatically between DBNull and
/// Nullable when the generic type is nullable.
/// </summary>
/// <param name="row">
/// The input DataRow
/// </param>
/// <param name="column">
/// The input DataColumn specificy which row value to retrieve.
/// </param>
/// <returns>
/// The DataRow value for the column specified.
/// </returns>
public static T Field<T>(this DataRow row, DataColumn column) {
DataSetUtil.CheckArgumentNull(row, "row");
return UnboxT<T>.Unbox(row[column]);
}
/// <summary>
/// This method provides access to the values in each of the columns in a given row.
/// This method makes casts unnecessary when accessing columns.
/// Additionally, Field supports nullable types and maps automatically between DBNull and
/// Nullable when the generic type is nullable.
/// </summary>
/// <param name="row">
/// The input DataRow
/// </param>
/// <param name="columnIndex">
/// The input ordinal specificy which row value to retrieve.
/// </param>
/// <returns>
/// The DataRow value for the column specified.
/// </returns>
public static T Field<T>(this DataRow row, int columnIndex) {
DataSetUtil.CheckArgumentNull(row, "row");
return UnboxT<T>.Unbox(row[columnIndex]);
}
/// <summary>
/// This method provides access to the values in each of the columns in a given row.
/// This method makes casts unnecessary when accessing columns.
/// Additionally, Field supports nullable types and maps automatically between DBNull and
/// Nullable when the generic type is nullable.
/// </summary>
/// <param name="row">
/// The input DataRow
/// </param>
/// <param name="columnIndex">
/// The input ordinal specificy which row value to retrieve.
/// </param>
/// <param name="version">
/// The DataRow version for which row value to retrieve.
/// </param>
/// <returns>
/// The DataRow value for the column specified.
/// </returns>
public static T Field<T>(this DataRow row, int columnIndex, DataRowVersion version) {
DataSetUtil.CheckArgumentNull(row, "row");
return UnboxT<T>.Unbox(row[columnIndex, version]);
}
/// <summary>
/// This method provides access to the values in each of the columns in a given row.
/// This method makes casts unnecessary when accessing columns.
/// Additionally, Field supports nullable types and maps automatically between DBNull and
/// Nullable when the generic type is nullable.
/// </summary>
/// <param name="row">
/// The input DataRow
/// </param>
/// <param name="columnName">
/// The input column name specificy which row value to retrieve.
/// </param>
/// <param name="version">
/// The DataRow version for which row value to retrieve.
/// </param>
/// <returns>
/// The DataRow value for the column specified.
/// </returns>
public static T Field<T>(this DataRow row, string columnName, DataRowVersion version) {
DataSetUtil.CheckArgumentNull(row, "row");
return UnboxT<T>.Unbox(row[columnName, version]);
}
/// <summary>
/// This method provides access to the values in each of the columns in a given row.
/// This method makes casts unnecessary when accessing columns.
/// Additionally, Field supports nullable types and maps automatically between DBNull and
/// Nullable when the generic type is nullable.
/// </summary>
/// <param name="row">
/// The input DataRow
/// </param>
/// <param name="column">
/// The input DataColumn specificy which row value to retrieve.
/// </param>
/// <param name="version">
/// The DataRow version for which row value to retrieve.
/// </param>
/// <returns>
/// The DataRow value for the column specified.
/// </returns>
public static T Field<T>(this DataRow row, DataColumn column, DataRowVersion version) {
DataSetUtil.CheckArgumentNull(row, "row");
return UnboxT<T>.Unbox(row[column, version]);
}
/// <summary>
/// This method sets a new value for the specified column for the DataRow its called on.
/// </summary>
/// <param name="row">
/// The input DataRow.
/// </param>
/// <param name="columnIndex">
/// The input ordinal specifying which row value to set.
/// </param>
/// <param name="value">
/// The new row value for the specified column.
/// </param>
public static void SetField<T>(this DataRow row, int columnIndex, T value) {
DataSetUtil.CheckArgumentNull(row, "row");
row[columnIndex] = (object)value ?? DBNull.Value;
}
/// <summary>
/// This method sets a new value for the specified column for the DataRow its called on.
/// </summary>
/// <param name="row">
/// The input DataRow.
/// </param>
/// <param name="columnName">
/// The input column name specificy which row value to retrieve.
/// </param>
/// <param name="value">
/// The new row value for the specified column.
/// </param>
public static void SetField<T>(this DataRow row, string columnName, T value) {
DataSetUtil.CheckArgumentNull(row, "row");
row[columnName] = (object)value ?? DBNull.Value;
}
/// <summary>
/// This method sets a new value for the specified column for the DataRow its called on.
/// </summary>
/// <param name="row">
/// The input DataRow.
/// </param>
/// <param name="column">
/// The input DataColumn specificy which row value to retrieve.
/// </param>
/// <param name="value">
/// The new row value for the specified column.
/// </param>
public static void SetField<T>(this DataRow row, DataColumn column, T value) {
DataSetUtil.CheckArgumentNull(row, "row");
row[column] = (object)value ?? DBNull.Value;
}
private static class UnboxT<T>
{
internal static readonly Converter<object, T> Unbox = Create(typeof(T));
private static Converter<object, T> Create(Type type)
{
if (type.IsValueType)
{
if (type.IsGenericType && !type.IsGenericTypeDefinition && (typeof(Nullable<>) == type.GetGenericTypeDefinition()))
{
return (Converter<object, T>)Delegate.CreateDelegate(
typeof(Converter<object, T>),
typeof(UnboxT<T>)
.GetMethod("NullableField", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic)
.MakeGenericMethod(type.GetGenericArguments()[0]));
}
return ValueField;
}
return ReferenceField;
}
private static T ReferenceField(object value)
{
return ((DBNull.Value == value) ? default(T) : (T)value);
}
private static T ValueField(object value)
{
if (DBNull.Value == value)
{
throw DataSetUtil.InvalidCast(Strings.DataSetLinq_NonNullableCast(typeof(T).ToString()));
}
return (T)value;
}
private static Nullable<TElem> NullableField<TElem>(object value) where TElem : struct
{
if (DBNull.Value == value)
{
return default(Nullable<TElem>);
}
return new Nullable<TElem>((TElem)value);
}
}
}
}
|
