public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
MappingSession mapping = context.StartMappingObject(mapper);
foreach (PropertyMap propertyMap in mapping.PropertiesNeedingToBeMapped)
{
MapPropertyValue(context, mapper, mapping.MappedObject, propertyMap);
}
context.EndMapping(mapping);
return mapping.MappedObject;
}

inside StartMappingObject, u could have something like:

return TypeMap.GetMappedObject(this, DefaultMapper);

inside GetMappedObject:

if ( CustomMapper != null )
{
BeforeMap(context.SourceValue, null);
mappedObject = CustomMapper(context);
}
else
{
var mappedInfo = defaultMapper(mapper,context);
mappedObject = mappedInfo.MappedObject;
if( ! mappedInfo.IsCached )
{
BeforeMap(context.SourceValue,mappedObject);
}
}
return mappedObject;

That was just a quick approach, but I really dunno what that code is supposed to be doing. I don’t get why BeforeMap is called before at one time and after at the other, if u could always call it after, u might want to move that into context instead. If not u could still move the BeforeMap outside the if, and u only get a simple if/else. Also in that case, u can refactor the above to avoid passing in the DefaultMapper, by just calling one or the other right from context (which seems hard know because of the placing of the BeforeMap).

I hope that helps and that I didn’t say a bunch of senseless stuff for the scenario

My guess is that we could have a long discussion on what exactly is rework and refactoring. I think that’s probably suited for another discussion. I’d rather concentrate on the solution here and improving the process so it doesn’t peek it’s ugly head again because I have written my share of code smells too!

One thing to keep in mind is that code changes over time, and it’s not always feasible to design it “right” the first time. The first time around, I only had one scenario. Tests would have shown me design issues, but only by looking at multiple tests, and the different responsibilities tested.

This specific code has grown quite gradually over time, so I don’t really feel too bad about it getting “bad”. That’s the whole point of code smells, to recognize when things need to change at the point in time it needs to change, but not before.

None the less, for me and I’m sure everyone else, I am grateful that you did it this way so we can all learn how to code much better!

Thanks!