/// <summary> /// Maps a property to another class map. /// </summary> /// <typeparam name="TClassMap">The type of the class map.</typeparam> /// <param name="expression">The expression.</param> /// <param name="constructorArgs">Constructor arguments used to create the reference map.</param> /// <returns>The reference mapping for the property.</returns> public virtual CsvPropertyReferenceMap References <TClassMap>(Expression <Func <T, object> > expression, params object[] constructorArgs) where TClassMap : CsvClassMap { var property = ReflectionHelper.GetProperty(expression); var existingMap = ReferenceMaps.SingleOrDefault(m => m.Data.Property == property || m.Data.Property.Name == property.Name && (m.Data.Property.DeclaringType.IsAssignableFrom(property.DeclaringType) || property.DeclaringType.IsAssignableFrom(m.Data.Property.DeclaringType))); if (existingMap != null) { return(existingMap); } var map = ReflectionHelper.CreateInstance <TClassMap>(constructorArgs); map.CreateMap(); map.ReIndex(GetMaxIndex() + 1); var reference = new CsvPropertyReferenceMap(property, map); ReferenceMaps.Add(reference); return(reference); }
/// <summary> /// Maps a property to another class map. /// </summary> /// <param name="type">The type.</param> /// <param name="expression">The expression.</param> /// <returns>The reference mapping for the property</returns> protected virtual CsvPropertyReferenceMap References(Type type, Expression <Func <T, object> > expression) { var property = ReflectionHelper.GetProperty(expression); var reference = new CsvPropertyReferenceMap(type, property); ReferenceMaps.Add(reference); return(reference); }
/// <summary> /// Maps a property to another class map. /// </summary> /// <typeparam name="TClassMap">The type of the class map.</typeparam> /// <param name="expression">The expression.</param> /// <returns>The reference mapping for the property.</returns> protected virtual CsvPropertyReferenceMap <TClassMap> References <TClassMap>(Expression <Func <T, object> > expression) where TClassMap : CsvClassMap { var property = ReflectionHelper.GetProperty(expression); var reference = new CsvPropertyReferenceMap <TClassMap>(property); ReferenceMaps.Add(reference); return(reference); }
/// <summary> /// Maps a property to another class map. /// </summary> /// <param name="map">Instance map</param> /// <param name="expression">The expression.</param> /// <returns>The reference mapping for the property</returns> protected virtual CsvPropertyReferenceMap References(CsvClassMap map, Expression <Func <T, object> > expression) { var property = ReflectionHelper.GetProperty(expression); map.CreateMap(); map.ReIndex(GetMaxIndex() + 1); var reference = new CsvPropertyReferenceMap(property, map); ReferenceMaps.Add(reference); return(reference); }
/// <summary> /// Maps a property to another class map. /// </summary> /// <param name="type">The type.</param> /// <param name="expression">The expression.</param> /// <returns>The reference mapping for the property</returns> protected virtual CsvPropertyReferenceMap References(Type type, Expression <Func <T, object> > expression) { var property = ReflectionHelper.GetProperty(expression); var map = (CsvClassMap)ReflectionHelper.CreateInstance(type); map.IndexStart = GetMaxIndex() + 1; map.CreateMap(); var reference = new CsvPropertyReferenceMap(property, map); ReferenceMaps.Add(reference); return(reference); }
/// <summary> /// Maps a property to another class map. /// </summary> /// <param name="type">The type.</param> /// <param name="expression">The expression.</param> /// <param name="constructorArgs">Constructor arguments used to create the reference map.</param> /// <returns>The reference mapping for the property</returns> protected virtual CsvPropertyReferenceMap References(Type type, Expression <Func <T, object> > expression, params object[] constructorArgs) { var property = ReflectionHelper.GetProperty(expression); var map = (CsvClassMap)ReflectionHelper.CreateInstance(type, constructorArgs); map.CreateMap(); map.ReIndex(GetMaxIndex() + 1); var reference = new CsvPropertyReferenceMap(property, map); ReferenceMaps.Add(reference); return(reference); }
/// <summary> /// Auto maps the given map and checks for circular references as it goes. /// </summary> /// <param name="map">The map to auto map.</param> /// <param name="ignoreReferences"> /// A value indicating if references should be ignored when auto mapping. /// True to ignore references, otherwise false. /// </param> /// <param name="prefixReferenceHeaders"> /// A value indicating if headers of reference properties should /// get prefixed by the parent property name. /// True to prefix, otherwise false. /// </param> /// <param name="mapParents">The list of parents for the map.</param> internal static void AutoMapInternal(CsvClassMap map, bool ignoreReferences, bool prefixReferenceHeaders, LinkedList <Type> mapParents, int indexStart = 0) { var genericArguments = map.GetType().GetTypeInfo().BaseType.GetGenericArguments()[0]; if (typeof(IEnumerable).IsAssignableFrom(genericArguments)) { throw new CsvConfigurationException( "Types that inherit IEnumerable cannot be auto mapped. Did you accidentally call GetRecord or WriteRecord which acts on a single record instead of calling GetRecords or WriteRecords which acts on a list of records?"); } var properties = genericArguments.GetProperties(BindingFlags.Instance | BindingFlags.Public); for (int i = 0; i < properties.Length; i++) { var propertyInfo = properties[i]; var type = TypeConverterFactory.GetConverter(propertyInfo.PropertyType).GetType(); if (type != typeof(EnumerableConverter)) { bool flag = type == typeof(DefaultTypeConverter); if (!(flag & (propertyInfo.PropertyType.GetConstructor(new Type[0]) != null))) { var csvPropertyMap = new CsvPropertyMap(propertyInfo); csvPropertyMap.Data.Index = map.GetMaxIndex() + 1; if (csvPropertyMap.Data.TypeConverter.CanConvertFrom(typeof(string)) || csvPropertyMap.Data.TypeConverter.CanConvertTo(typeof(string)) && !flag) { map.PropertyMaps.Add(csvPropertyMap); } } else if (!ignoreReferences && !CheckForCircularReference(propertyInfo.PropertyType, mapParents)) { mapParents.AddLast(genericArguments); var csvClassMap = (CsvClassMap) ReflectionHelper.CreateInstance( typeof(DefaultCsvClassMap <>).MakeGenericType(propertyInfo.PropertyType)); AutoMapInternal(csvClassMap, false, prefixReferenceHeaders, mapParents, map.GetMaxIndex() + 1); if (csvClassMap.PropertyMaps.Count > 0 || csvClassMap.ReferenceMaps.Count > 0) { var csvPropertyReferenceMap = new CsvPropertyReferenceMap(propertyInfo, csvClassMap); if (prefixReferenceHeaders) { csvPropertyReferenceMap.Prefix(null); } map.ReferenceMaps.Add(csvPropertyReferenceMap); } } } } map.ReIndex(indexStart); }
/// <summary> /// Maps a property/field to another class map. /// </summary> /// <param name="classMapType">The type of the class map.</param> /// <param name="member">The property/field.</param> /// <param name="constructorArgs">Constructor arguments used to create the reference map.</param> /// <returns>The reference mapping for the property/field.</returns> public virtual CsvPropertyReferenceMap References(Type classMapType, MemberInfo member, params object[] constructorArgs) { if (!typeof(CsvClassMap).IsAssignableFrom(classMapType)) { throw new InvalidOperationException($"Argument {nameof( classMapType )} is not a CsvClassMap."); } var existingMap = ReferenceMaps.Find(member); if (existingMap != null) { return(existingMap); } var map = (CsvClassMap)ReflectionHelper.CreateInstance(classMapType, constructorArgs); map.ReIndex(GetMaxIndex() + 1); var reference = new CsvPropertyReferenceMap(member, map); ReferenceMaps.Add(reference); return(reference); }
/// <summary> /// Auto maps the given map and checks for circular references as it goes. /// </summary> /// <param name="map">The map to auto map.</param> /// <param name="options">Options for auto mapping.</param> /// <param name="mapParents">The list of parents for the map.</param> /// <param name="indexStart">The index starting point.</param> internal static void AutoMapInternal(CsvClassMap map, AutoMapOptions options, LinkedList <Type> mapParents, int indexStart = 0) { var type = map.GetType().GetTypeInfo().BaseType.GetGenericArguments()[0]; if (typeof(IEnumerable).IsAssignableFrom(type)) { throw new CsvConfigurationException("Types that inherit IEnumerable cannot be auto mapped. " + "Did you accidentally call GetRecord or WriteRecord which " + "acts on a single record instead of calling GetRecords or " + "WriteRecords which acts on a list of records?"); } var flags = BindingFlags.Instance | BindingFlags.Public; if (options.IncludePrivateProperties) { flags = flags | BindingFlags.NonPublic; } var members = new List <MemberInfo>(); if ((options.MemberTypes & MemberTypes.Properties) == MemberTypes.Properties) { var properties = type.GetProperties(flags); members.AddRange(properties); } if ((options.MemberTypes & MemberTypes.Fields) == MemberTypes.Fields) { var fields = new List <MemberInfo>(); foreach (var field in type.GetFields(flags)) { if (!field.GetCustomAttributes(typeof(CompilerGeneratedAttribute), false).Any()) { fields.Add(field); } } members.AddRange(fields); } foreach (var member in members) { var typeConverterType = TypeConverterFactory.GetConverter(member.MemberType()).GetType(); if (typeConverterType == typeof(EnumerableConverter)) { // The IEnumerable converter just throws an exception so skip it. continue; } var isDefaultConverter = typeConverterType == typeof(DefaultTypeConverter); var hasDefaultConstructor = member.MemberType().GetConstructor(new Type[0]) != null; if (isDefaultConverter && hasDefaultConstructor) { if (options.IgnoreReferences) { continue; } // If the type is not one covered by our type converters // and it has a parameterless constructor, create a // reference map for it. if (CheckForCircularReference(member.MemberType(), mapParents)) { continue; } mapParents.AddLast(type); var refMapType = typeof(DefaultCsvClassMap <>).MakeGenericType(member.MemberType()); var refMap = (CsvClassMap)ReflectionHelper.CreateInstance(refMapType); var refOptions = options.Copy(); refOptions.IgnoreReferences = false; AutoMapInternal(refMap, options, mapParents, map.GetMaxIndex() + 1); if (refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0) { var referenceMap = new CsvPropertyReferenceMap(member, refMap); if (options.PrefixReferenceHeaders) { referenceMap.Prefix(); } map.ReferenceMaps.Add(referenceMap); } } else { var propertyMap = new CsvPropertyMap(member); // Use global values as the starting point. propertyMap.Data.TypeConverterOptions = TypeConverterOptions.Merge(options.TypeConverterOptionsFactory.GetOptions(member.MemberType())); propertyMap.Data.Index = map.GetMaxIndex() + 1; if (!isDefaultConverter) { // Only add the property/field map if it can be converted later on. // If the property/field will use the default converter, don't add it because // we don't want the .ToString() value to be used when auto mapping. map.PropertyMaps.Add(propertyMap); } } } map.ReIndex(indexStart); }
/// <summary> /// Auto maps the given map and checks for circular references as it goes. /// </summary> /// <param name="map">The map to auto map.</param> /// <param name="ignoreReferences">A value indicating if references should be ignored when auto mapping. /// True to ignore references, otherwise false.</param> /// <param name="prefixReferenceHeaders">A value indicating if headers of reference properties should /// get prefixed by the parent property name. /// True to prefix, otherwise false.</param> /// <param name="mapParents">The list of parents for the map.</param> /// <param name="indexStart">The index starting point.</param> internal static void AutoMapInternal(CsvClassMap map, bool ignoreReferences, bool prefixReferenceHeaders, LinkedList <Type> mapParents, int indexStart = 0) { var type = map.GetType().GetTypeInfo().BaseType.GetGenericArguments()[0]; if (typeof(IEnumerable).IsAssignableFrom(type)) { throw new CsvConfigurationException("Types that inherit IEnumerable cannot be auto mapped. " + "Did you accidentally call GetRecord or WriteRecord which " + "acts on a single record instead of calling GetRecords or " + "WriteRecords which acts on a list of records?"); } var properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public); foreach (var property in properties) { var typeConverterType = TypeConverterFactory.GetConverter(property.PropertyType).GetType(); if (typeConverterType == typeof(EnumerableConverter)) { // The IEnumerable converter just throws an exception so skip it. continue; } var isDefaultConverter = typeConverterType == typeof(DefaultTypeConverter); var hasDefaultConstructor = property.PropertyType.GetConstructor(new Type[0]) != null; if (isDefaultConverter && hasDefaultConstructor) { if (ignoreReferences) { continue; } // If the type is not one covered by our type converters // and it has a parameterless constructor, create a // reference map for it. if (CheckForCircularReference(property.PropertyType, mapParents)) { continue; } mapParents.AddLast(type); var refMapType = typeof(DefaultCsvClassMap <>).MakeGenericType(property.PropertyType); var refMap = (CsvClassMap)ReflectionHelper.CreateInstance(refMapType); AutoMapInternal(refMap, false, prefixReferenceHeaders, mapParents, map.GetMaxIndex() + 1); if (refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0) { var referenceMap = new CsvPropertyReferenceMap(property, refMap); if (prefixReferenceHeaders) { referenceMap.Prefix(); } map.ReferenceMaps.Add(referenceMap); } } else { var propertyMap = new CsvPropertyMap(property); propertyMap.Data.Index = map.GetMaxIndex() + 1; if (!isDefaultConverter) { // Only add the property map if it can be converted later on. // If the property will use the default converter, don't add it because // we don't want the .ToString() value to be used when auto mapping. map.PropertyMaps.Add(propertyMap); } } } map.ReIndex(indexStart); }
/// <summary> /// Auto maps the given map and checks for circular references as it goes. /// </summary> /// <param name="map">The map to auto map.</param> /// <param name="options">Options for auto mapping.</param> /// <param name="mapParents">The list of parents for the map.</param> /// <param name="indexStart">The index starting point.</param> protected virtual void AutoMapProperties(CsvClassMap map, AutoMapOptions options, LinkedList <Type> mapParents, int indexStart = 0) { var type = map.GetGenericType(); var flags = BindingFlags.Instance | BindingFlags.Public; if (options.IncludePrivateProperties) { flags = flags | BindingFlags.NonPublic; } var members = new List <MemberInfo>(); if (options.MemberTypes.HasFlag(MemberTypes.Properties)) { // We need to go up the declaration tree and find the actual type the property // exists on and use that PropertyInfo instead. This is so we can get the private // set method for the property. var properties = new List <PropertyInfo>(); foreach (var property in type.GetProperties(flags)) { properties.Add(ReflectionHelper.GetDeclaringProperty(type, property, flags)); } members.AddRange(properties); } if (options.MemberTypes.HasFlag(MemberTypes.Fields)) { var fields = new List <MemberInfo>(); foreach (var field in type.GetFields(flags)) { if (!field.GetCustomAttributes(typeof(CompilerGeneratedAttribute), false).Any()) { fields.Add(field); } } members.AddRange(fields); } foreach (var member in members) { var typeConverterType = TypeConverterFactory.Current.GetConverter(member.MemberType()).GetType(); if (options.HasHeaderRecord && enumerableConverters.Contains(typeConverterType)) { // Enumerable converters can't write the header properly, so skip it. continue; } var memberTypeInfo = member.MemberType().GetTypeInfo(); var isDefaultConverter = typeConverterType == typeof(DefaultTypeConverter); if (isDefaultConverter && (memberTypeInfo.HasParameterlessConstructor() || memberTypeInfo.IsUserDefinedStruct())) { // If the type is not one covered by our type converters // and it has a parameterless constructor, create a // reference map for it. if (options.IgnoreReferences) { continue; } if (CheckForCircularReference(member.MemberType(), mapParents)) { continue; } mapParents.AddLast(type); var refMapType = typeof(DefaultCsvClassMap <>).MakeGenericType(member.MemberType()); var refMap = (CsvClassMap)ReflectionHelper.CreateInstance(refMapType); var refOptions = options.Copy(); refOptions.IgnoreReferences = false; // Need to use Max here for nested types. AutoMapProperties(refMap, options, mapParents, Math.Max(map.GetMaxIndex() + 1, indexStart)); mapParents.Drop(mapParents.Find(type)); if (refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0) { var referenceMap = new CsvPropertyReferenceMap(member, refMap); if (options.PrefixReferenceHeaders) { referenceMap.Prefix(); } map.ReferenceMaps.Add(referenceMap); } } else { var propertyMap = CsvPropertyMap.CreateGeneric(map.ClassType, member); // Use global values as the starting point. propertyMap.Data.TypeConverterOptions = TypeConverterOptions.Merge(new TypeConverterOptions(), options.TypeConverterOptionsFactory.GetOptions(member.MemberType()), propertyMap.Data.TypeConverterOptions); propertyMap.Data.Index = map.GetMaxIndex() + 1; if (!isDefaultConverter) { // Only add the property/field map if it can be converted later on. // If the property/field will use the default converter, don't add it because // we don't want the .ToString() value to be used when auto mapping. map.PropertyMaps.Add(propertyMap); } } } map.ReIndex(indexStart); }
/// <summary> /// Auto maps the given map and checks for circular references as it goes. /// </summary> /// <param name="map">The map to auto map.</param> /// <param name="options">Options for auto mapping.</param> /// <param name="mapParents">The list of parents for the map.</param> /// <param name="indexStart">The index starting point.</param> internal static void AutoMapInternal( CsvClassMap map, AutoMapOptions options, LinkedList<Type> mapParents, int indexStart = 0 ) { var type = map.GetType().GetTypeInfo().BaseType.GetGenericArguments()[0]; if( typeof( IEnumerable ).IsAssignableFrom( type ) ) { throw new CsvConfigurationException( "Types that inherit IEnumerable cannot be auto mapped. " + "Did you accidentally call GetRecord or WriteRecord which " + "acts on a single record instead of calling GetRecords or " + "WriteRecords which acts on a list of records?" ); } var flags = BindingFlags.Instance | BindingFlags.Public; if( options.IncludePrivateProperties ) { flags = flags | BindingFlags.NonPublic; } var members = new List<MemberInfo>(); if( ( options.MemberTypes & MemberTypes.Properties ) == MemberTypes.Properties ) { var properties = type.GetProperties( flags ); members.AddRange( properties ); } if( ( options.MemberTypes & MemberTypes.Fields ) == MemberTypes.Fields ) { var fields = new List<MemberInfo>(); foreach( var field in type.GetFields( flags ) ) { if( !field.GetCustomAttributes( typeof( CompilerGeneratedAttribute ), false ).Any() ) { fields.Add( field ); } } members.AddRange( fields ); } foreach( var member in members ) { var typeConverterType = TypeConverterFactory.GetConverter( member.MemberType() ).GetType(); if( typeConverterType == typeof( EnumerableConverter ) ) { // The IEnumerable converter just throws an exception so skip it. continue; } var isDefaultConverter = typeConverterType == typeof( DefaultTypeConverter ); var hasDefaultConstructor = member.MemberType().GetConstructor( new Type[0] ) != null; if( isDefaultConverter && hasDefaultConstructor ) { if( options.IgnoreReferences ) { continue; } // If the type is not one covered by our type converters // and it has a parameterless constructor, create a // reference map for it. if( CheckForCircularReference( member.MemberType(), mapParents ) ) { continue; } mapParents.AddLast( type ); var refMapType = typeof( DefaultCsvClassMap<> ).MakeGenericType( member.MemberType() ); var refMap = (CsvClassMap)ReflectionHelper.CreateInstance( refMapType ); var refOptions = options.Copy(); refOptions.IgnoreReferences = false; AutoMapInternal( refMap, options, mapParents, map.GetMaxIndex() + 1 ); if( refMap.PropertyMaps.Count > 0 || refMap.ReferenceMaps.Count > 0 ) { var referenceMap = new CsvPropertyReferenceMap( member, refMap ); if( options.PrefixReferenceHeaders ) { referenceMap.Prefix(); } map.ReferenceMaps.Add( referenceMap ); } } else { var propertyMap = new CsvPropertyMap( member ); // Use global values as the starting point. propertyMap.Data.TypeConverterOptions = TypeConverterOptions.Merge( options.TypeConverterOptionsFactory.GetOptions( member.MemberType() ) ); propertyMap.Data.Index = map.GetMaxIndex() + 1; if( !isDefaultConverter ) { // Only add the property/field map if it can be converted later on. // If the property/field will use the default converter, don't add it because // we don't want the .ToString() value to be used when auto mapping. map.PropertyMaps.Add( propertyMap ); } } } map.ReIndex( indexStart ); }
/// <summary> /// Maps a property/field to another class map. /// </summary> /// <param name="classMapType">The type of the class map.</param> /// <param name="member">The property/field.</param> /// <param name="constructorArgs">Constructor arguments used to create the reference map.</param> /// <returns>The reference mapping for the property/field.</returns> public virtual CsvPropertyReferenceMap References( Type classMapType, MemberInfo member, params object[] constructorArgs ) { if( !typeof( CsvClassMap ).IsAssignableFrom( classMapType ) ) { throw new InvalidOperationException( $"Argument {nameof( classMapType )} is not a CsvClassMap." ); } var existingMap = ReferenceMaps.Find( member ); if( existingMap != null ) { return existingMap; } var map = (CsvClassMap)ReflectionHelper.CreateInstance( classMapType, constructorArgs ); map.ReIndex( GetMaxIndex() + 1 ); var reference = new CsvPropertyReferenceMap( member, map ); ReferenceMaps.Add( reference ); return reference; }