Check for empty context

[kakone]

Like indicated in the upgrade guide, ResolutionContext.Options was removed in version 12. But it also changes the behavior. I could call Options.Items.ContainsKey method to check if some options was set in the Map method. With the Items property, it raises an exception and it doesn't seem to have another maneer than catching the exception to check if an option is present or not in the resolution context.

I can create a PR to return an empty dictionary instead of raising an exception but it would introduce another breaking change.

[lbargaoanu]

If you need the context, you're supposed to call a Map overload with options. But yes, there is no way to call without options and then check without throwing. I suggest that you simply pay for the extra allocations and always call with options. Or use some other way to pass state, with IncludeMembers, in the source or destination object or through DI.
I'd rather not add a flag for the sole purpose of telling you there is no context.

[almightyju]

I've just ran into the same thing, I have a lot of code that does ContainsKey checking. In some instances if that key doesn't exist it does some expensive calculations to set it in a BeforeMap so that the various properties that use that expensive result can use a cached version.

I'm not sure of any way to do something similar to the following without changing all the calls to map, which is a bit frustrating:

CreateMap<Foo, Bar>()
.BeforeMap(foo, bar, context) =>{
    if(!context.Items.ContainsKey("ExpensiveResult"))
        context.Items.Add("ExpensiveResult", DoExpensiveThing(foo));
})
.ForMember(b => b.Thing, opt => opt.MapFrom((_,_,_, context) => context.Items["ExpensiveResult"]))
.ForMember(b => b.OtherThing, opt => opt.MapFrom((_,_,_, context) => context.Items["ExpensiveResult"] / 2))

Granted doing that expensive operation and passing it in when calling Map makes sense, but removing the ability to do this seems unnecessarily restrictive.

[lbargaoanu]

https://docs.automapper.org/en/latest/Flattening.html#includemembers

[almightyju]

But that would mean I need to either make a FooEx class which extends Foo or add a property into Foo with the expensive thing. The first option while better is a lot of stuff to refactor, the 2nd option avoids the refactor but then I have a bunch of logic in my database entities that I don't want. Unless I'm missing something?

public class FooEx
{
    public Foo Source { get; set; }
    public int ExpensiveThing { get; set; }
    public FooEx(Foo source) { ... ExpensiveThing = DoThing() }
}

public class Foo
{
    public int ExpensiveThing { get; } = DoThing(); //better yet use a Lazy<int>
    ....
}```

[lbargaoanu]

No, you can have any expression in IncludeMembers.

[almightyju]

Ok, that's pretty neat and has solved 90% of my hassles, thank you! 1 last question tho sorry

Given the code below the map call in Get_Data_Without_Fs_Info fails since it doesn't set FsInfo in the context, is the only way in this situation to pass opt.Items.Add("FsInfo", null) ? I'd love it if there was a way to put the data in FooExtraInfo but I haven't found a way to access that info when mapping to dto.FilesystemInfo

public class FooEntity
{
    public List<int> MyNumbers { get; set; }
}
public class FooDTO
{
    public int ExpensiveInfo { get; init; }
    public long? FilesystemInfo { get; init; }
}
public class FooExtraInfo
{
    public int CalculatedExtraInfo { get; }
    public FooExtraInfo(FooEntity entity)
    {
        CalculatedExtraInfo = entity.MyNumbers.Sum();
    }
}

public class MapProfile : Profile
{
    public MapProfile()
    {
        CreateMap<FooEntity, FooDTO>()
            .IncludeMembers(entity => new FooExtraInfo(entity))
            .ForMember(dto => dto.FilesystemInfo, opt => opt.MapFrom((entity, dto, _, context) =>
            {
                if (context.Items.TryGetValue("FsInfo", out object? oFsInfo))
                    return (long)oFsInfo;
                else
                    return (long?)null;
            }));

        CreateMap<FooExtraInfo, FooDTO>()
            .ForMember(dto => dto.ExpensiveInfo, opt => opt.MapFrom(info => info.CalculatedExtraInfo));
    }
}

public class Work
{
    public void Get_Data_With_Fs_Info()
    {
        IMapper mapper = GetMapper();
        List<FooEntity> items = QueryDb();
        List<FooDTO> mapped = items.Select(entity =>
        {
            long fsInfo = Some_Filesystem_Info();
            return mapper.Map<FooDTO>(entity, opt =>
            {
                opt.Items.Add("FsInfo", fsInfo);
            });
        });
    }

    public void Get_Data_Without_Fs_Info()
    {
        IMapper mapper = GetMapper();
        List<FooEntity> items = QueryDb();
        List<FooDTO> mapped = items.Select(mapper.Map<FooDTO>);
    }
}

[lbargaoanu]

You just need to call a Map overload with options.