static void Main(string[] args) { MyDataTable t1 = new MyDataTable(); t1.Columns.Add(new DataColumn("Name", typeof(string))); t1.Columns.Add(new DataColumn("DateOfBirth", typeof(DateTime))); MyDataRow r1 = t1.NewRow() as MyDataRow; r1["Name"] = "Bob"; r1["DateOfBirth"] = new DateTime(1970, 5, 12); t1.Rows.Add(r1); }
/// <summary> /// This is currently designed to only work for primitive types as I am only using it for /// generic export. It can be made better. /// </summary> /// <typeparam name="T">This may be a type generated at runtime</typeparam> /// <param name="items"></param> /// <param name="validColumns">NB: No need to put S/No column. It's added automatically</param> /// <param name="generatedType">If null, it defaults to typeof(T). If <paramref name="T"/> is a generated type, supply the type here to aid in the resolution, because it will read as Object.</param> /// <returns></returns> public static MyDataTable ToDataTable <T>(this IList <T> items, IList <MyDataColumn> validColumns, Type generatedType = null) { if (generatedType == null) { generatedType = typeof(T); } var dt = new MyDataTable(generatedType.Name); dt.Columns.Add("No", new MyDataColumn("No", typeof(int))); foreach (var item in validColumns) { dt.Columns.Add(item.ColumnName, item); } string propName; for (int i = 0; i < items.Count; i++) { var row = dt.NewRow(); row["No"] = i + 1; foreach (var col in dt.Columns) { if (col.Key == "No") { continue; } propName = col.Value.PropertyName; object theVal = null; try { theVal = generatedType.GetProperty(propName).GetValue(items[i], null); } catch (TargetException) { theVal = null; } catch (RuntimeBinderException) { theVal = null; } row[col.Key] = theVal; } dt.Rows.Add(row); } return(dt); }
private static void BuildNewRow(MyDataTable dt, PropertyInfo[] props, object item, long savedBy) { var row = dt.NewRow(); for (int j = 0; j < props.Length; j++) { var prop = props[j]; if (!dt.Columns.ContainsKey(prop.GetPropertyName())) { if (prop.PropertyType.IsClass && prop.PropertyType != typeof(string)) { var innerProps = prop.PropertyType.GetProperties(); if (innerProps.Any(x => x.Name == "Id")) // Handle properties mapped as Reference { string columnName = string.Format("{0}Id", prop.Name.StartsWith("The") ? prop.Name.Remove(0, 3) : prop.Name); if (!dt.Columns.ContainsKey(columnName)) { continue; } object theRefValue; try { dynamic propValue = prop.GetValue(item, null); theRefValue = propValue.Id; } catch (TargetException) { theRefValue = null; } catch (RuntimeBinderException) { theRefValue = null; } catch (Exception) { throw; } if (theRefValue == null) { row[columnName] = System.DBNull.Value; continue; } row[columnName] = theRefValue; } else //Handling Compositely mapped Class properties { var modifyFieldNameAttr = prop.GetCustomAttribute <CompositeMappingModifyFieldNamesAttribute>(); for (int k = 0; k < innerProps.Length; k++) { var innerProp = innerProps[k]; string innerPropName = null; if (modifyFieldNameAttr.UseAllPPropertiesWithTHeirDefaultNames) { if (!dt.Columns.ContainsKey(innerProp.GetPropertyName())) { continue; } innerPropName = innerProp.GetPropertyName(); } else { if (!modifyFieldNameAttr.FieldAndPropNames.ContainsKey(innerProp.GetPropertyName())) { continue; } innerPropName = modifyFieldNameAttr.FieldAndPropNames[innerProp.GetPropertyName()]; if (!dt.Columns.ContainsKey(innerPropName)) { continue; } } object theInnerValue; try { theInnerValue = innerProp.GetValue(prop.GetValue(item, null), null); if (theInnerValue == null && innerProp.IsTypeNullable()) { theInnerValue = Nullable.GetUnderlyingType(innerProp.PropertyType).GetDefaultValue(); //innerProp.PropertyType.GenericTypeArguments[0].GetDefaultValue(); } } catch (TargetException) { theInnerValue = null; } catch (Exception) { throw; } if (string.IsNullOrWhiteSpace(innerPropName)) { innerPropName = modifyFieldNameAttr.FieldAndPropNames[innerProp.GetPropertyName()]; } if (theInnerValue == null) { row[innerPropName] = DBNull.Value; continue; } if (innerProp.PropertyType == typeof(DateTime) && theInnerValue != null && Convert.ToDateTime(theInnerValue) < new DateTime(1900, 1, 1)) { theInnerValue = new DateTime(1900, 1, 1); } if (innerProp.PropertyType.IsEnum && theInnerValue != null) { //DO NOT use Enum.Parse(innerProp.PropertyType, theInnerValue.ToString()); since we store enums as integers conventionally theInnerValue = (int)theInnerValue; } row[innerPropName] = theInnerValue; } } continue; } continue; } object theValue; try { if (prop.Name == "DateMigrated") { theValue = DateTime.Now.GetLocalTime(); } else if (prop.Name == "SavedBy") { theValue = savedBy; } else { theValue = prop.GetValue(item, null); } if (theValue == null) { if (prop.Name == "DateCreated") { theValue = new DateTime(1900, 1, 1); } else if (prop.Name == "IsDisabled" || prop.Name == "IsDeleted") { theValue = false; } else if (prop.IsTypeNullable()) { var mainType = Nullable.GetUnderlyingType(prop.PropertyType); if (mainType == typeof(DateTime)) { theValue = new DateTime(1900, 1, 1); } else { theValue = mainType.GetDefaultValue(); } } } } catch (TargetException) { theValue = null; } catch (Exception) { throw; } if (theValue == null) { row[prop.GetPropertyName()] = DBNull.Value; continue; } if (prop.PropertyType == typeof(DateTime) && theValue != null && Convert.ToDateTime(theValue) < new DateTime(1900, 1, 1)) { theValue = new DateTime(1900, 1, 1); } if (prop.PropertyType.IsEnum && theValue != null) { //DO NOT use Enum.Parse(prop.PropertyType, theValue.ToString()); since we store enums as integers conventionally theValue = (int)theValue; } row[prop.GetPropertyName()] = theValue; } dt.Rows.Add(row); }
static void Main(string[] args) { MyDataTable t = new MyDataTable(); t.Rows.Add(t.NewRow()); // <-- Exception here, wrong type (base doesn't count). }