internal static T CreateObject <T>(this SqlDataReader dr, Func <SqlDataReader, T> autoMappingFunc, string key)
{
if (autoMappingFunc == null)
{
autoMappingFunc = CreateAutoMappingFunc <T>(dr);
MappingManager.AddAutoCreateObjectFunc(key, autoMappingFunc);
}
return(autoMappingFunc(dr));
}
public static IEnumerable <T> ReadAsEnumerable <T>(this SqlDataReader dr, bool getNextResult = true)
{
if (typeof(T).IsSimpleType())
{
return(dr.ReadToEnumerableOfValues <T>(getNextResult));
}
var key = GetAutoCreateObjectFuncKey <T>(dr);
var autoMappingFunc = MappingManager.GetAutoCreateObjectFunc <T>(key);
return(dr.ReadToEnumerableOfObjects <T>(autoMappingFunc, getNextResult));
}
private static DataTable GetObjectDataTable <T>(IEnumerable <T> list, string tableName, string[] columnNameArray)
{
Func <DataTable> createDataTableFunc;
Func <T, object[]> createDataRowFunc;
string key = GetAutoCreateDataFuncsKey <T>(tableName, columnNameArray);
if (!MappingManager.GetAutoCreateDataFuncs(key, out createDataTableFunc, out createDataRowFunc))
{
CreateAutoMappingFunc <T>(tableName, columnNameArray, out createDataTableFunc, out createDataRowFunc);
MappingManager.AddAutoCreateDataFuncs(key, createDataTableFunc, createDataRowFunc);
}
return(list.ToDataTable(createDataTableFunc, createDataRowFunc));
}
public static async Task <T> ReadAsAsync <T>(this SqlCommand cmd)
{
if (typeof(T).IsSimpleType())
{
return(await cmd.ReadToValueAsync <T>());
}
var key = SqlDataReaderExtensions.GetAutoCreateObjectFuncKey <T>(cmd.CommandText);
var autoMappingFunc = MappingManager.GetAutoCreateObjectFunc <T>(key);
var readerFlags = await GetReaderFlagsAndOpenConnectionAsync(cmd, CommandBehavior.SingleRow);
using (var dr = await cmd.ExecuteReaderAsync(readerFlags).ConfigureAwait(false))
{
return(dr.Read() ? dr.CreateObject(autoMappingFunc, key) : default(T));
}
}
public static T ReadAs <T>(this SqlCommand cmd)
{
if (typeof(T).IsSimpleType())
{
return(cmd.ReadToValue <T>());
}
var key = SqlDataReaderExtensions.GetAutoCreateObjectFuncKey <T>(cmd.CommandText);
var autoMappingFunc = MappingManager.GetAutoCreateObjectFunc <T>(key);
var readerFlags = GetReaderFlagsAndOpenConnection(cmd, CommandBehavior.SingleRow);
using (var dr = cmd.ExecuteReader(readerFlags))
{
return(dr.Read() ? dr.CreateObject(autoMappingFunc, key) : default(T));
}
}
public static async Task <IList <T> > ReadAsListAsync <T>(this SqlCommand cmd, IList <T> list)
{
if (typeof(T).IsSimpleType())
{
return(await cmd.ReadToListOfValuesAsync <T>(list));
}
var key = SqlDataReaderExtensions.GetAutoCreateObjectFuncKey <T>(cmd.CommandText);
var autoMappingFunc = MappingManager.GetAutoCreateObjectFunc <T>(key);
var readerFlags = await GetReaderFlagsAndOpenConnectionAsync(cmd, CommandBehavior.SingleResult);
using (var dr = await cmd.ExecuteReaderAsync(readerFlags).ConfigureAwait(false))
{
list = dr.ReadAsList(list, autoMappingFunc, key);
}
return(list);
}
public static IList <T> ReadAsList <T>(this SqlDataReader dr, IList <T> list, bool getNextResult = true)
{
if (typeof(T).IsSimpleType())
{
return(dr.ReadToListOfValues <T>(list, getNextResult));
}
var key = GetAutoCreateObjectFuncKey <T>(dr);
var autoMappingFunc = MappingManager.GetAutoCreateObjectFunc <T>(key);
list = dr.ReadAsList(list, autoMappingFunc, key);
if (getNextResult)
{
dr.NextResult();
}
return(list);
}
public static DataTable ToDataTable <T>(this IEnumerable <T> list)
{
Func <DataTable> createDataTableFunc;
Func <T, object[]> createDataRowFunc;
if (!MappingManager.GetCreateDataFuncs(out createDataTableFunc, out createDataRowFunc))
{
throw new KeyNotFoundException($"No mapping function found to create DataTable and DataRow for type {typeof(T).FullName}");
}
var dataTable = createDataTableFunc();
foreach (var entity in list.Where(entity => entity != null))
{
dataTable.Rows.Add(createDataRowFunc(entity));
}
return(dataTable);
}
private static IEnumerable <T> ReadAsEnumerableObjects <T>(this SqlCommand cmd)
{
var readerFlags = GetReaderFlagsAndOpenConnection(cmd, CommandBehavior.SingleResult);
using (var dr = cmd.ExecuteReader(readerFlags))
{
var key = SqlDataReaderExtensions.GetAutoCreateObjectFuncKey <T>(dr);
var autoMappingFunc = MappingManager.GetAutoCreateObjectFunc <T>(key);
if (autoMappingFunc == null)
{
autoMappingFunc = SqlDataReaderExtensions.CreateAutoMappingFunc <T>(dr);
MappingManager.AddAutoCreateObjectFunc(key, autoMappingFunc);
}
while (dr.Read())
{
yield return(autoMappingFunc(dr));
}
}
}
public static Dictionary <TKey, TValue> ReadToDictionary <TKey, TValue>(this SqlDataReader dr, bool getNextResult = true)
{
Dictionary <TKey, TValue> dictionary;
var underlyingType = typeof(TValue).GetUnderlyingType();
if (underlyingType.IsSimpleType())
{
dictionary = ReadToDictionaryOfValues <TKey, TValue>(dr, underlyingType);
}
else
{
dictionary = ReadToDictionaryOfObjects <TKey, TValue>(dr, MappingManager.GetCreateObjectFunc <TValue>());
}
if (getNextResult)
{
dr.NextResult();
}
return(dictionary);
}
public static void AddParams(this SqlCommand cmd, Dictionary <string, object> paramDictionary)
{
var collectionKey = cmd.CommandText;
var sqlParameters = MappingManager.GetSqlParameters(collectionKey);
if (sqlParameters == null)
{
var isConnectionClosed = true;
try
{
isConnectionClosed = cmd.Connection.State == ConnectionState.Closed;
if (isConnectionClosed)
{
cmd.Connection.Open();
}
SqlCommandBuilder.DeriveParameters(cmd);
}
finally
{
if (isConnectionClosed)
{
cmd.Connection.Close();
}
}
cmd.Parameters.Remove(cmd.Parameters["@RETURN_VALUE"]);
sqlParameters = new SqlParameter[cmd.Parameters.Count];
cmd.Parameters.CopyTo(sqlParameters, 0);
MappingManager.AddSqlParameters(collectionKey, sqlParameters);
}
else
{
foreach (var sqlParameter in sqlParameters)
{
var newSqlParameter = new SqlParameter(sqlParameter.ParameterName, sqlParameter.SqlDbType)
{
Size = sqlParameter.Size,
Direction = sqlParameter.Direction,
Precision = sqlParameter.Precision,
Scale = sqlParameter.Scale
};
cmd.Parameters.Add(newSqlParameter);
}
}
foreach (SqlParameter sqlParameter in cmd.Parameters)
{
var key = paramDictionary.Keys.FirstOrDefault(k =>
string.Equals(k, sqlParameter.ParameterName.Replace("@", ""), StringComparison.InvariantCultureIgnoreCase)
);
if (key != null)
{
sqlParameter.Value = paramDictionary[key] ?? DBNull.Value;
}
}
}
public static ObjectRows ReadToObjectRows <T>(this SqlDataReader dr, bool getNextResult = true)
{
return(dr.ReadToObjectRows(MappingManager.GetCreateObjectRowFunc <T>(), getNextResult));
}
public static async Task <IList <T> > ReadToTreeListAsync <T>(this SqlCommand cmd, bool hierarchicallySorted = false) where T : class, INode <T>
{
return((await cmd.ReadToListOfObjectsAsync <T>(MappingManager.GetCreateObjectFunc <T>(), null)).ToTreeList(hierarchicallySorted));
}
public static IList <T> ReadToTreeList <T>(this SqlDataReader dr, bool getNextResult = true, bool hierarchicallySorted = false) where T : class, INode <T>
{
return(dr.ReadToEnumerableOfObjects <T>(MappingManager.GetCreateObjectFunc <T>(), getNextResult).ToTreeList(hierarchicallySorted));
}
public static IList <T> ReadToTreeList <T>(this SqlCommand cmd, bool hierarchicallySorted = false) where T : class, INode <T>
{
return(cmd.ReadToEnumerableObjects <T>(MappingManager.GetCreateObjectFunc <T>()).ToTreeList(hierarchicallySorted));
}
public static T ReadToTree <T>(this SqlCommand cmd, IList <T> list, bool hierarchicallySorted = false) where T : class, INode <T>
{
return(cmd.ReadToListOfObjects <T>(MappingManager.GetCreateObjectFunc <T>(), list).ToTree(hierarchicallySorted));
}
