/// <summary> /// Gets property mappings for a specified type from a DataTable. /// </summary> /// <typeparam name="T">The type of object to map.</typeparam> /// <param name="dataTable">The DataTable to map from.</param> /// <param name="settings">The settings to use while mapping.</param> /// <returns>A list of the mappings.</returns> public ExtendedPropertyInfo[] GetPropertyMappings <T>(DataTable dataTable, DataTableParserSettings settings) { Guard.ArgumentNotNull(dataTable); Guard.ArgumentNotNull(settings); var mappedProperties = new List <ExtendedPropertyInfo>(); var typeProperties = GetPropertiesForType <T>(settings.InheritMappings); // For non-overwriting mappings the execution order is important. switch (settings.MappingMatchOrder) { case MappingMatchOrder.PropertyNameFirst: PropertyResolver.GenerateMappingsFromProperties(mappedProperties, dataTable, settings, typeProperties); AttributeResolver.GenerateMappingsFromAttributes(mappedProperties, dataTable, settings, typeProperties); break; case MappingMatchOrder.AttributeValueFirst: AttributeResolver.GenerateMappingsFromAttributes(mappedProperties, dataTable, settings, typeProperties); PropertyResolver.GenerateMappingsFromProperties(mappedProperties, dataTable, settings, typeProperties); break; case MappingMatchOrder.IgnorePropertyNames: AttributeResolver.GenerateMappingsFromAttributes(mappedProperties, dataTable, settings, typeProperties); break; case MappingMatchOrder.IgnoreAttributes: PropertyResolver.GenerateMappingsFromProperties(mappedProperties, dataTable, settings, typeProperties); break; } CheckForErrors <T>(settings, mappedProperties, typeProperties); return(mappedProperties.ToArray()); }
public virtual IList <T> ToObjects <T>(DataRow[] dataRows, IDataTypeConverter dataTypeConverter, ExtendedPropertyInfo[] mappings, DataTableParserSettings settings) { Guard.ArgumentNotNull(dataRows); Guard.ArgumentNotNull(dataTypeConverter); Guard.ArgumentNotNull(mappings); Guard.ArgumentNotNull(settings); var dbNullConverter = GetDbNullConverter(settings); var objectList = new T[dataRows.Length]; for (int rowIndex = 0; rowIndex < dataRows.Length; rowIndex++) { var returnObject = ObjectInstantiator <T> .CreateNew(); foreach (var mapping in mappings) { object value = dataTypeConverter.FieldToObject(dataRows[rowIndex][mapping.ColumnIndex], mapping.PropertyInfo.PropertyType, settings, dbNullConverter); mapping.PropertyInfo.SetValue(returnObject, value); } objectList[rowIndex] = returnObject; } return(objectList); }
private ConversionManager GetConverter(DataTableParserSettings dataTableParserSettings) { return(new ConversionManager(dataTableParserSettings, mappingResolver, GetResolver(), dataTypeConverter)); }
public virtual void GenerateMappingsFromProperties(IList <ExtendedPropertyInfo> mappedProperties, DataTable dataTable, DataTableParserSettings settings, PropertyInfo[] properties) { bool isFirstMapper = mappedProperties.Count == 0; foreach (PropertyInfo property in properties) { // If we must avoid overwrites we do so here. if (!isFirstMapper && !settings.SubsequentMappingsShouldOverwrite) { if (mappedProperties.Count(p => p.PropertyInfo.Name == property.Name) > 0) { continue; } } bool mappingFound = false; if (dataTable.Columns.Contains(property.Name)) { mappedProperties.Add(new ExtendedPropertyInfo(fieldName: property.Name, propertyInfo: property, columnIndex: dataTable.Columns.IndexOf(property.Name))); mappingFound = true; } // Special case handling for Id columns/properties. if (!mappingFound && property.Name.ToLowerInvariant().Contains(Id)) { GenerateIdSpecificPropertyMappings(mappedProperties, dataTable, property); } } }
public object FieldToObject(object field, Type type, DataTableParserSettings settings, DbNullConverter dbNullConverter) { if (type.IsValueType) { return(Activator.CreateInstance(type)); } return(null); }
public static DataTableConverter Create(DataTableParserSettings settings) { var parser = new DataTableConverter { DataTableParserSettings = settings }; return(parser); }
protected virtual object ValueTypeFieldToObject(object field, Type type, DataTableParserSettings settings) { try { if (type == typeof(int)) { return(FieldToInt(field)); } else if (type == typeof(Guid)) { return(FieldToGuid(field)); } else if (type == typeof(DateTime)) { return(FieldToDateTime(field)); } else if (type == typeof(bool)) { return(FieldToBool(field)); } else if (type == typeof(char)) { return(FieldToChar(field)); } else if (type == typeof(decimal)) { return(FieldToDecimal(field)); } else if (type == typeof(float)) { return(FieldToFloat(field)); } else if (type == typeof(uint)) { int value = (int)FieldToInt(field); if (value < 0) { value = value * -1; } return(value); } else if (type == typeof(double)) { return(FieldToDouble(field)); } else if (type == typeof(long)) { return(FieldToLong(field)); } throw new NotImplementedException(string.Format("No conversion for field with value: {0} to type: {1}", field.ToString(), type.Name)); } catch (InvalidCastException ex) { throw new NotImplementedException(string.Format("No conversion for field with value: {0} to type: {1}", field.ToString(), type.Name), ex); } }
public void GetPropertyMappings_TwoPropertiesOneMatching_ThrowsMissingMappingException() { DataTable dt = DataTableFactory.GenerateEmptyDataTableWithStringColumns("PropertyOne"); DataTableParserSettings dtps = new DataTableParserSettings { MissingMappingHandling = MissingMappingHandling.Error }; Assert.Throws(typeof(MissingMappingException <SimpleNoIdNoAttributes>), () => defaultMappingResolver.GetPropertyMappings <SimpleNoIdNoAttributes>(dt, dtps)); }
public ConversionManager(DataTableParserSettings dataTableParserSettings, IMappingResolver mappingResolver, IDataTableResolver dataTableResolver, IDataTypeConverter dataTypeConverter) { this.dataTableParserSettings = dataTableParserSettings; this.mappingResolver = mappingResolver; this.dataTableResolver = dataTableResolver; this.dataTypeConverter = dataTypeConverter; }
public void GetPropertyMappings_TwoPropertiesOneMatching_MissingMappingHandlingIgnores() { DataTable dt = DataTableFactory.GenerateEmptyDataTableWithStringColumns("PropertyOne"); DataTableParserSettings dtps = new DataTableParserSettings { MissingMappingHandling = MissingMappingHandling.Ignore }; var results = defaultMappingResolver.GetPropertyMappings <SimpleNoIdNoAttributes>(dt, dtps); Assert.True(results.Length == 1); }
public void GetPropertyMappings_TwoAttributesWithOneMatchingColumnErrorOnMissingMapping_ThrowsMissingMappingException() { DataTable dt = DataTableFactory.GenerateEmptyDataTableWithStringColumns("prop1", "PropertyTwo"); DataTableParserSettings dtps = new DataTableParserSettings { MissingMappingHandling = MissingMappingHandling.Error, MappingMatchOrder = MappingMatchOrder.IgnorePropertyNames }; Assert.Throws(typeof(MissingMappingException <SimpleClassWithAttributes>), () => defaultMappingResolver.GetPropertyMappings <SimpleClassWithAttributes>(dt, dtps)); }
public void GetPropertyMappings_ClassWithInheritedProperties_OnlyReturnsImmediateProperties() { string[] columns = { "ParentIntProperty", "ParentStringProperty", "ChildIntProperty", "ChildStringProperty" }; DataTable dt = DataTableFactory.GenerateEmptyDataTableWithStringColumns(columns); DataTableParserSettings dtps = new DataTableParserSettings { InheritMappings = false }; var results = defaultMappingResolver.GetPropertyMappings <ChildNoAttributes>(dt, dtps); Assert.True(results.Length == 2); }
public void GetPropertyMappings_ClassWithTwoLevelsOfInheritance_ReturnsAllResults() { string[] columns = { "ParentIntProperty", "ParentStringProperty", "ChildIntProperty", "ChildStringProperty", "LeafIntProperty" }; DataTable dt = DataTableFactory.GenerateEmptyDataTableWithStringColumns(columns); DataTableParserSettings dtps = new DataTableParserSettings { InheritMappings = true }; var results = defaultMappingResolver.GetPropertyMappings <LeafClassNoAttributes>(dt, dtps); Assert.True(results.Length == 5); }
public void GetPropertyMappings_TwoAttributesWithOneMatchingColumnAndPropertyMatch_ReturnsResults() { DataTable dt = DataTableFactory.GenerateEmptyDataTableWithStringColumns("prop1", "PropertyTwo"); DataTableParserSettings dtps = new DataTableParserSettings { MissingMappingHandling = MissingMappingHandling.Error, MappingMatchOrder = MappingMatchOrder.PropertyNameFirst }; var results = defaultMappingResolver.GetPropertyMappings <SimpleClassWithAttributes>(dt, dtps); Assert.True(results.Length == 2); }
private static void CheckForErrors <T>(DataTableParserSettings settings, List <ExtendedPropertyInfo> mappedProperties, PropertyInfo[] typeProperties) { // Error in mapping handling, checks for missing mappings. if (settings.MissingMappingHandling == MissingMappingHandling.Error && mappedProperties.Count < typeProperties.Length) { throw new MissingMappingException <T>(); } // Checks for duplicate mappings in the list. if (!settings.AllowDuplicateMappings && mappedProperties.Select(p => p.ColumnIndex).Distinct().Count() != mappedProperties.Count) { throw new DuplicateMappingException <T>(); } }
public virtual object FieldToObject(object field, Type type, DataTableParserSettings settings, DbNullConverter dbNullConverter) { if (field == DBNull.Value || field == null) { return(dbNullConverter.DbNullToObject(type)); } if (type == stringType) { return(field.ToString()); } if (!type.IsValueType && type != stringType) { throw new NotImplementedException("No Conversion exists for class of type: " + type.Name); } return(ValueTypeFieldToObject(field, type, settings)); }
public virtual void GenerateMappingsFromAttributes(List <ExtendedPropertyInfo> mappedProperties, DataTable dataTable, DataTableParserSettings settings, PropertyInfo[] properties) { bool isFirstMapper = mappedProperties.Count == 0; foreach (PropertyInfo property in properties) { // If we must avoid overwrites we do so here. if (!isFirstMapper && !settings.SubsequentMappingsShouldOverwrite && mappedProperties.Count(p => p.PropertyInfo.Name == property.Name) > 0) { continue; } // Use the static method in order to inspect inherited properties. Attribute[] attributes = Attribute.GetCustomAttributes(property, typeof(ColumnMapping), settings.InheritMappings); if (attributes.Length == 0) { continue; } // Find the matching attribute if it exists, null if not. ColumnMapping matchedAttribute = FindMappedAttribute(attributes, dataTable.Columns); if (matchedAttribute != null) { mappedProperties.Add(new ExtendedPropertyInfo( fieldName: matchedAttribute.Name, propertyInfo: property, columnIndex: dataTable.Columns.IndexOf(matchedAttribute.Name))); } } }
public ExtendedPropertyInfo[] GetPropertyMappings <T>(DataTable dataTable, DataTableParserSettings settings) { return(new ExtendedPropertyInfo[] { }); }
public DbNullConverter(DataTableParserSettings settings) { this.settings = settings; }
public IList <T> ToObjects <T>(DataRow[] dataRows, IDataTypeConverter dataTypeConverter, ExtendedPropertyInfo[] mappings, DataTableParserSettings settings) { Guard.ArgumentNotNull(dataRows); Guard.ArgumentNotNull(dataTypeConverter); Guard.ArgumentNotNull(mappings); Guard.ArgumentNotNull(settings); List <T> objectList = new List <T>(capacity: dataRows.Length); var dbNullConverter = new DbNullConverter(settings); IEnumerable <DelegateColumnMapping <T> > delegates = GetDelegatesForType <T>(mappings); for (int rowIndex = 0; rowIndex < dataRows.Length; rowIndex++) { T returnObject = ObjectInstantiator <T> .CreateNew(); foreach (var setterDelegate in delegates) { object value = dataTypeConverter.FieldToObject(dataRows[rowIndex][setterDelegate.ExtendedPropertyInfo.ColumnIndex], setterDelegate.ExtendedPropertyInfo.PropertyInfo.PropertyType, settings, dbNullConverter); setterDelegate.SetterDelegate(returnObject, value); } objectList.Add(returnObject); } return(objectList); }
protected virtual DbNullConverter GetDbNullConverter(DataTableParserSettings settings) { return(new DbNullConverter(settings)); }
public IList <T> ToObjects <T>(DataRow[] dataRows, IDataTypeConverter dataTypeConverter, ExtendedPropertyInfo[] mappings, DataTableParserSettings settings) { return(new List <T>()); }
public virtual IList <T> ConvertToObjectList <T>(DataTable table, DataTableParserSettings dataTableParserSettings) { return(ToObjectsInternal <T>(table, dataTableParserSettings)); }
public static IList <T> Convert <T>(DataTable table, DataTableParserSettings settings) { return(new DataTableConverter().ConvertToObjectList <T>(table, settings)); }
private ConversionManager GetConversionManagerWithCustomSettings(DataTableParserSettings settings) { return(new ConversionManager(settings, defaultMappingResolver, defaultDataTableResolver, defaultDataTypeConverter)); }
public IList <T> ToObjects <T>(DataRow[] dataRows, IDataTypeConverter dataTypeConverter, ExtendedPropertyInfo[] mappings, DataTableParserSettings settings) { Guard.ArgumentNotNull(dataRows); Guard.ArgumentNotNull(dataTypeConverter); Guard.ArgumentNotNull(mappings); Guard.ArgumentNotNull(settings); ConcurrentBag <T> objectList = new ConcurrentBag <T>(); var dbNullConverter = new DbNullConverter(settings); Parallel.For(0, dataRows.Length, (rowIndex) => { T returnObject = ObjectInstantiator <T> .CreateNew(); foreach (var mapping in mappings) { object value = dataTypeConverter.FieldToObject(dataRows[rowIndex][mapping.ColumnIndex], mapping.PropertyInfo.PropertyType, settings, dbNullConverter); mapping.PropertyInfo.SetValue(returnObject, value); } objectList.Add(returnObject); }); return(objectList.ToList()); }
protected virtual IList <T> ToObjectsInternal <T>(DataTable table, DataTableParserSettings dataTableParserSettings) { return(GetConverter(dataTableParserSettings).ConvertToType <T>(table)); }