Ignore in an Inherited Object

[Kaiwinta]

When a child mapping uses .Inherits<TSource, TDestination>(), ignored fields defined in the parent config cannot be re-mapped in the child config.

Parent mapping:

config.NewConfig<Base, BaseDTO>()
    .Ignore(dest => dest.LastModified);

Child mapping:

config.NewConfig<Advanced, AdvancedDTO>()
    .Inherits<Base, BaseDTO>()
    .Map(dest => dest.LastModified, src => src.LastModified);

Expected: AdvancedDTO.LastModified is mapped from Advanced.LastModified.

Actual: AdvancedDTO.LastModified is ignored, inherited behavior overrides the child .Map() call.

Proposed fix: Add an .Unignore(dest => dest.LastModified) method, or ensure that an explicit .Map() on the child config takes precedence over a parent .Ignore().

---

[DocSvartz]

This needs some thought🤔, some non-obvious problems may arise, but for now you can use IgnoreIf()

config.NewConfig<Based953, BasedDto953>()
.IgnoreIf((src, dest) => src.GetType() == typeof(Based953), dest => dest.LastModified);

[Kaiwinta]

Thanks that's what I used in the end but this solution isn't effective when multiple subclasses and the parent class doesn't want to map a property and only one subclass want the property to be mapped.

With a situation simmilar to my previous we get:

Parent mapping:

config.NewConfig<Base, BaseDTO>()
    .Ignore(dest => dest.LastModified);

Child 1 mapping:

config.NewConfig<Child1, Child1DTO>()
    .Inherits<Base, BaseDTO>()

config.NewConfig<Child2, Child2DTO>()
    .Inherits<Base, BaseDTO>()
    .Map(dest => dest.LastModified, src => src.LastModified);

Here the solution are:

.IgnoreIf((src, dest) => src.GetType() != typeof(Child2), dest => dest.LastModified);

This solution is problematic because the base mapping explicitly references a specific subclass, breaking encapsulation and creating tight coupling with its children.

---

.IgnoreIf(
    (src, dest) => new HashSet<Type> { typeof(Base), typeof(Child1) }
        .Contains(src.GetType()),
    dest => dest.LastModified
);

This solution is problematic because the base mapping explicitly references a specific subclass, breaking encapsulation and creating tight coupling with its children.

[DocSvartz]

@Kaiwinta

This solution is problematic because the base mapping explicitly references a specific subclass, breaking encapsulation and creating tight coupling with its children.

I wouldn't say there's any violation of encapsulation here.
This is property locking based on a public contract.🤔

From my point of view, your problem is caused by the fact that you clearly want to violate the polymorphic behavior and inheritance of types (both in terms of configuration and in terms of mapping results) 😉

[Kaiwinta]

Yes sorry I tried to find another reason to implement something like .Unignore.

I know my example isn't the best one and will avoid to end in situation where I need to use something like this

.IgnoreIf(
    (src, dest) => new HashSet<Type> { typeof(Base), typeof(Child1) }
        .Contains(src.GetType()),
    dest => dest.LastModified
);

Thanks for your feedback

[DocSvartz]

Example:

  public class Config
  {
      public IgnoreMember Ignore1 {  get;} 
  }


  public class DerivedConfig : Config
  {
      public IgnoreMemeber Ignore2 { get;}
  }

// DerivedConfig  have Ignore1 and Ignore2

Ignore isn't virtual; even if it were, you could only override it, not delete it.

In our case, IgnoreIf() is the very same virtual ignore.

@Kaiwinta I understand you've already seen that I added

RemoveIgnore()

Warning

RemoveIgnore() won't work if you specifyIgnore usingForDestinationType()`;

[Kaiwinta]

Thanks for the clarification and the implementation! This lib is truly great, and seeing it evolve is really cool especially with the fall of AutoMapper.

I took a look at the codebase and really liked what I saw. Looking forward to more!