public void RecordSet_Constructor_DataTable() { PortableRecordset recordset = null; using (var dataset = TestDataProvider.GetDataSet()) { Assert.IsTrue(dataset.Tables.Count > 0); using (var table = dataset.Tables[0]) { recordset = new PortableRecordset(table); Assert.AreEqual(table.Columns.Count, recordset.Fields.Length); Assert.AreEqual(table.Rows.Count, recordset.Records.Length); for (var i = 0; i < table.Rows.Count; ++i) { for (var j = 0; j < table.Columns.Count; ++j) { if (table.Rows[i].IsNull(j)) { Assert.IsNull(recordset[i][j]); } else { Assert.AreEqual(table.Rows[i][j], recordset[i][j]); } } } } } }
public void RecordSet_Constructor_RowsOnly() { PortableRecordset recordset = null; using (var dataset = TestDataProvider.GetDataSet()) { Assert.IsTrue(dataset.Tables.Count > 0); using (var table = dataset.Tables[0]) { var rows = new object[table.Rows.Count][]; for (var i = 0; i < table.Rows.Count; ++i) { rows[i] = table.Rows[i].ItemArray; } recordset = new PortableRecordset(table.TableName, rows); Assert.AreEqual(table.Columns.Count, recordset.Fields.Length); Assert.AreEqual(table.Rows.Count, recordset.Records.Length); for (var i = 0; i < table.Rows.Count; ++i) { for (var j = 0; j < table.Columns.Count; ++j) { Assert.AreEqual(table.Rows[i][j], recordset[i][j]); } } } } }
/// <summary> /// for binary types /// </summary> /// <param name="recordset"></param> /// <returns></returns> public static object[] ToObjectArray(this PortableRecordset recordset) { var result = new object[recordset.Count]; for (var i = 0; i < recordset.Count; ++i) { result[i] = recordset[i, 0]; } return(result); }
public static T[] ToArrayParallel <T>(this PortableRecordset recordset) where T : class { var result = new T[recordset.Count]; Parallel.For(0, recordset.Count, i => { result[i] = recordset.ToObject <T>(i); }); return(result); }
public static T[] ToArray <T>(this PortableRecordset recordset) where T : class { var result = new T[recordset.Count]; for (var i = 0; i < recordset.Count; ++i) { result[i] = recordset.ToObject <T>(i); } return(result); }
public static Task <T[]> ToArrayAsync <T>(this PortableRecordset recordset) where T : class { return(Task.Run(() => { var result = new T[recordset.Count]; for (var i = 0; i < recordset.Count; ++i) { result[i] = recordset.ToObject <T>(i); } return result; })); }
/// <summary> /// for value/scalor types like string, datetime, and numeric types /// </summary> /// <typeparam name="T"></typeparam> /// <param name="recordset"></param> /// <returns></returns> public static T[] ToValueArray <T>(this PortableRecordset recordset) where T : struct { var result = new T[recordset.Count]; if (recordset.Count > 0) { var type = typeof(T); type = type.IsNullable() ? Nullable.GetUnderlyingType(type) : type; var doConvert = type != recordset[0, 0].GetType(); for (var i = 0; i < recordset.Count; ++i) { result[i] = (T)(doConvert ? Convert.ChangeType(recordset[i][0], type) : recordset[i][0]); } } return(result); }
public void RecordSet_JsonSerialization() { PortableRecordset recordset = null; using (var dataset = TestDataProvider.GetDataSet()) { Assert.IsTrue(dataset.Tables.Count > 0); using (var table = dataset.Tables[0]) { recordset = new PortableRecordset(table); Assert.AreEqual(table.Columns.Count, recordset.Fields.Length); Assert.AreEqual(table.Rows.Count, recordset.Records.Length); for (var i = 0; i < table.Rows.Count; ++i) { for (var j = 0; j < table.Columns.Count; ++j) { if (table.Rows[i].IsNull(j)) { Assert.IsNull(recordset[i][j]); } else { Assert.AreEqual(table.Rows[i][j], recordset[i][j]); } } } } } var json = JsonConvert.SerializeObject(recordset); var rc = JsonConvert.DeserializeObject <PortableRecordset>(json); // using to string to avoid the stupid int32 vs int64 casting issue for (var i = 0; i < recordset.Count; ++i) { for (var j = 0; j < recordset.FieldCount; ++j) { if (recordset[i][j] == null) { Assert.IsNull(rc[i][j]); } else { Assert.AreEqual(recordset[i][j].ToString(), rc[i][j].ToString()); } } } }
public void RecordSet_Append_Array() { var size = 2; var rows = new object[size][]; var c = 0; for (var i = 0; i < size; ++i) { rows[i] = new object[size]; for (var j = 0; j < size; ++j) { rows[i][j] = ++c; } } var recordset = new PortableRecordset("test", rows); Assert.AreEqual(size, recordset.Count); c = 0; for (var i = 0; i < size; ++i) { for (var j = 0; j < size; ++j) { Assert.AreEqual(++c, recordset[i][j]); } } recordset.Append(rows); Assert.AreEqual(size * 2, recordset.Count); for (var o = 0; o < 2; ++o) { c = 0; for (var i = 0; i < size; ++i) { for (var j = 0; j < size; ++j) { Assert.AreEqual(++c, recordset[i][j]); } } } }
public static T ToObject <T>(this PortableRecordset recordset, long recordIndex) where T : class { // allows activator to use non-public constructors var result = (T)Activator.CreateInstance( typeof(T), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance, null, null, null); for (var i = 0; i < TypeInfoCache <T> .ReadWriteProperties.Length; ++i) { var property = TypeInfoCache <T> .ReadWriteProperties[i]; var propertyName = TypeInfoCache <T> .ReadWritePropertyNames[i]; var value = recordset[recordIndex, propertyName]; if (value != null) { //todo: this can be optimized by passing in the table definition or a cache of row types from the ToArray methods //todo: this can be optimized by getting the underlying nullable types in TypeInfoCache var propertyType = property.PropertyType.IsNullable() ? Nullable.GetUnderlyingType(property.PropertyType) : property.PropertyType; value = propertyType == value.GetType() ? value : Convert.ChangeType(value, propertyType); property.SetValue(result, value); } } return(result); }
/// <summary> /// /// </summary> /// <typeparam name="TInterface"></typeparam> /// <typeparam name="TImplentation">The type to use to for the interface implementation. Must have public or protected constructor.</typeparam> /// <param name="recordset"></param> /// <returns></returns> public static TInterface[] ToArray <TInterface, TImplentation>(this PortableRecordset recordset) where TImplentation : class, TInterface { var interfaceType = typeof(TInterface); if (!interfaceType.IsInterface) { throw new OrmException($"Generic argument TInterface resolves to {interfaceType.FullName} which is not an interface."); } var instanceType = typeof(TImplentation); if (instanceType.GetInterface(interfaceType.Name) == null) { throw new OrmException($"Genertic argument TImplentation{instanceType.FullName} must implement interface {interfaceType.FullName}"); } var result = new TInterface[recordset.Count]; for (var i = 0; i < recordset.Count; ++i) { result[i] = recordset.ToObject <TImplentation>(i); } return(result); }