internal static Tuple <IEnumerable <T>, IEnumerable <U>, IEnumerable <V>, IEnumerable <W>, IEnumerable <X> > ToMultipleTypes <T, U, V, W, X>(DbDataReader dr, bool forAnonymousTypes = false)
{
// Dataset #0 for type T
var dataset0 = ToPrimitiveOrTypeOrDynamic <T>(dr);
var hasNextResult0 = dr.NextResult();
// Dataset #1 for type U
var dataset1 = hasNextResult0 ? ToPrimitiveOrTypeOrDynamic <U>(dr) : null;
var hasNextResult1 = hasNextResult0 ? dr.NextResult() : false;
// Dataset #2 for type V
var dataset2 = hasNextResult1 ? ToPrimitiveOrTypeOrDynamic <V>(dr) : null;
var hasNextResult2 = hasNextResult1 ? dr.NextResult() : false;
// Dataset #3 for type W
var dataset3 = hasNextResult2 ? ToPrimitiveOrTypeOrDynamic <W>(dr) : null;
var hasNextResult3 = hasNextResult2 ? dr.NextResult() : false;
// Dataset #4 for type X
var dataset4 = hasNextResult3 ? ToPrimitiveOrTypeOrDynamic <X>(dr) : null;
var hasNextResult4 = hasNextResult3 ? dr.NextResult() : false;
// Return
return(new Tuple <IEnumerable <T>, IEnumerable <U>, IEnumerable <V>, IEnumerable <W>, IEnumerable <X> >
(
dataset0,
dataset1,
dataset2,
dataset3,
dataset4
));
// Depending of type of T, gets the Primitive, Dynamic or Typed data.
IEnumerable <MyType> ToPrimitiveOrTypeOrDynamic <MyType>(DbDataReader datareader)
{
// Primitive type: Executable<string>()
if (TypeExtension.IsPrimitive(typeof(MyType)))
{
return(DataReaderConvertor.ToPrimitives <MyType>(datareader));
}
// Dynamic type: Executable<dynamic>()
else if (DynamicConvertor.IsDynamic(typeof(MyType)))
{
return(DataReaderConvertor.ToDynamic <MyType>(datareader));
}
// Anonymous type: Executable(new { Name = "" })
else if (forAnonymousTypes == true)
{
return(DataReaderConvertor.ToAnonymous <MyType>(datareader));
}
// Object type: Executable<Employee>()
else
{
return(DataReaderConvertor.ToType <MyType>(datareader).Rows);
}
}
}
/// <summary />
internal static T ToType <T>(this Schema.DataRow row)
{
var rowType = typeof(T);
// *** Primitive type
if (TypeExtension.IsPrimitive(rowType))
{
return((T)Convert.ChangeType(row[0], typeof(T)));
}
// *** Class
else
{
var properties = rowType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
var newItem = Activator.CreateInstance <T>();
foreach (var column in row.Table.Columns)
{
var name = column.ColumnName;
var property = properties.GetFirstOrDefaultWithAttributeOrName(name);
if (property != null)
{
var value = row[name];
property.SetValue(newItem, value == DBNull.Value ? null : value, null);
}
}
return((T)Convert.ChangeType(newItem, typeof(T)));
}
}
private static DataTable ToDataTable(IEnumerable <object> rows)
{
var table = new DataTable();
var firstRow = rows.FirstOrDefault();
var rowType = firstRow?.GetType();
// No row, so Empty table
if (firstRow == null)
{
return(table);
}
// *** Primitive type
if (TypeExtension.IsPrimitive(rowType))
{
table.Columns = new[]
{
new DataColumn(0, "Column", null, rowType, TypeExtension.IsNullable(rowType))
};
table.Rows = rows.Select(i => new DataRow(table, new object[] { i })).ToArray();
}
// *** Class
else
{
// Class Properties
var properties = rowType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
// Columns
table.Columns = Enumerable.Range(0, properties.Count())
.Select(i =>
{
var prop = properties.ElementAt(i);
return(new DataColumn
(
ordinal: i,
columnName: prop.Name,
dataType: prop.PropertyType,
sqlType: null,
isNullable: TypeExtension.IsNullable(prop.PropertyType)
));
})
.ToArray();
// Rows
table.Rows = rows.Select(row =>
{
var values = properties.Select(prop => prop.GetValue(row, null)).ToArray();
return(new DataRow(table, values));
})
.ToArray();
}
return(table);
}