/// <summary> /// Auto maps the given map using constructor parameters. /// </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 AutoMapConstructorParameters(CsvClassMap map, AutoMapOptions options, LinkedList <Type> mapParents, int indexStart = 0) { var type = map.GetGenericType(); var constructor = options.GetConstructor(map.ClassType); var parameters = constructor.GetParameters(); foreach (var parameter in parameters) { var typeConverterType = TypeConverterFactory.Current.GetConverter(parameter.ParameterType).GetType(); var parameterMap = new CsvParameterMap(parameter); var memberTypeInfo = parameter.ParameterType.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) { throw new InvalidOperationException($"Configuration '{nameof( options.IgnoreReferences )}' can't be true " + "when using types without a default constructor. Constructor parameters " + "are used and all properties including references must be used."); } if (CheckForCircularReference(parameter.ParameterType, mapParents)) { throw new InvalidOperationException($"A circular reference was detected in constructor paramter '{parameter.Name}'." + "Since all parameters must be supplied for a constructor, this parameter can't be skipped."); } mapParents.AddLast(type); var refMapType = typeof(DefaultCsvClassMap <>).MakeGenericType(parameter.ParameterType); var refMap = (CsvClassMap)ReflectionHelper.CreateInstance(refMapType); var refOptions = options.Copy(); refOptions.IgnoreReferences = false; AutoMapProperties(refMap, options, mapParents, Math.Max(map.GetMaxIndex() + 1, indexStart)); mapParents.Drop(mapParents.Find(type)); var referenceMap = new CsvParameterReferenceMap(parameter, refMap); if (options.PrefixReferenceHeaders) { referenceMap.Prefix(); } parameterMap.ReferenceMap = referenceMap; } else if (options.ShouldUseConstructorParameters(parameter.ParameterType)) { mapParents.AddLast(type); var constructorMapType = typeof(DefaultCsvClassMap <>).MakeGenericType(parameter.ParameterType); var constructorMap = (CsvClassMap)ReflectionHelper.CreateInstance(constructorMapType); var constructorOptions = options.Copy(); constructorOptions.IgnoreReferences = false; // Need to use Max here for nested types. AutoMapConstructorParameters(constructorMap, constructorOptions, mapParents, Math.Max(map.GetMaxIndex() + 1, indexStart)); mapParents.Drop(mapParents.Find(type)); parameterMap.ConstructorTypeMap = constructorMap; } else { parameterMap.Data.TypeConverterOptions = TypeConverterOptions.Merge(new TypeConverterOptions(), options.TypeConverterOptionsFactory.GetOptions(parameter.ParameterType), parameterMap.Data.TypeConverterOptions); parameterMap.Data.Index = map.GetMaxIndex() + 1; } map.ParameterMaps.Add(parameterMap); } 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); }