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); }