/// <summary> /// Auto maps all members for the given type. If a member /// is mapped again it will override the existing map. /// </summary> /// <param name="options">Options for auto mapping.</param> public virtual void AutoMap(AutoMapOptions options) { var type = GetGenericType(); if (typeof(IEnumerable).IsAssignableFrom(type)) { throw new ConfigurationException("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 mapParents = new LinkedList <Type>(); if (options.ShouldUseConstructorParameters(type)) { // This type doesn't have a parameterless constructor so we can't create an // instance and set it's member. Constructor parameters need to be created // instead. Writing only uses getters, so members will also be mapped // for writing purposes. AutoMapConstructorParameters(this, options, mapParents); } AutoMapMembers(this, options, mapParents); }
/// <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(ClassMap 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 ParameterMap(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 members 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(DefaultClassMap <>).MakeGenericType(parameter.ParameterType); var refMap = (ClassMap)ReflectionHelper.CreateInstance(refMapType); var refOptions = options.Copy(); refOptions.IgnoreReferences = false; AutoMapMembers(refMap, options, mapParents, Math.Max(map.GetMaxIndex() + 1, indexStart)); mapParents.Drop(mapParents.Find(type)); var referenceMap = new ParameterReferenceMap(parameter, refMap); if (options.PrefixReferenceHeaders) { referenceMap.Prefix(); } parameterMap.ReferenceMap = referenceMap; } else if (options.ShouldUseConstructorParameters(parameter.ParameterType)) { mapParents.AddLast(type); var constructorMapType = typeof(DefaultClassMap <>).MakeGenericType(parameter.ParameterType); var constructorMap = (ClassMap)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); }