Question

I seem to have a memory leak within the usage of AutoMapper and StructureMap which are used within my WCF REST service.

Under load test I can see the memory usage continually going up and when I examined it more closely using a memory profiler I can see that there are many instances of an object used by the MappingEngine building up (approx 9x amount of any other instance)

Class Name=Live Instances
Object=498,847
Int32[]=69,373
Object[]=68,116
ConcurrentDictionary<TKey, TValue>+Node<TypePair, IObjectMapper>=37,624
string=35,240
IObjectMapper[]=30,782
EventHandler<TypeMapCreatedEventArgs>=30,782
MappingEngine=30,781
ConcurrentDictionary<TypePair, IObjectMapper>=30,781
ConcurrentDictionary<TKey, TValue>+Node<TypePair, LambdaExpression>[]=30,781
ConcurrentDictionary<TKey, TValue>+Node<TypePair, IObjectMapper>[]=30,781
ConcurrentDictionary<TypePair, LambdaExpression>=30,781

and here is the a typical instance retention graph…

bootstrapper._configuration
 -> AutoMapper.ConfigurationStore (TypeMapCreated)
 -> System.EventHandler<TypeMapCreatedEventArgs> (multicast delegate)
 -> System.Object[]
 -> System.EventHandler<TypeMapCreatedEventArgs>
 -> AutoMapper.MappingEngine (_objectMapperCache)
 -> System.Collections.Concurrent.ConcurrentDictionary<Internal.typePair, IObjectMapper> (m_locks)
 -> System.Object[]
 -> System.Object

(sorry for rubbish formatting but SO wouldn’t let me post the images)

Problem is that I’m not sure whether it is a problem with my code, StructureMap or AutoMapper.

Code samples…

Bootstrapper (called from Application_Start in global.asax) for automap…

    public class BootStrapper
    {
        private static readonly IConfiguration _configuration = ObjectFactory.GetInstance<IConfiguration>();

        public static void Initialize()
        {
                _configuration.AddProfile<AutoMapperProfile>();
        }

        public class AutoMapperProfile : Profile
        {
            protected override void Configure()
            {
                    BootstrapAutoMapper();
            }   
        }

        public static void BootstrapAutoMapper()
        {
            _configuration.CreateMap<In.Account, Out.Accounts.Account>()
               .ForMember(m => m.AccountNumber, o => o.MapFrom(s => s.AcctId))
               .ForMember(m => m.Balances, o => o.Ignore())
               .ForMember(m => m.AccountTypeDescription, o => o.MapFrom(s => s.TypeName))
               .ForMember(m => m.AccountType, o => o.MapFrom(s => s.Type))
               .ForMember(m => m.IsNoticeAccount, o => o.ResolveUsing(s => IsNoticeAccountMapper.Map(s.Type, ObjectFactory.GetInstance<IAccountTypeHelper>())));

             // many other mappings excluded for brevity
    }        
}   

which is configured within StructureMap with…

    private void AutoMapperRegistration()
    {
        For<ConfigurationStore>().Singleton().Use<ConfigurationStore>().Ctor<IEnumerable<IObjectMapper>>().Is(AutoMapper.Mappers.MapperRegistry.AllMappers());
        For<IConfigurationProvider>().Use(ctx => ctx.GetInstance<ConfigurationStore>());
        For<IConfiguration>().Use(ctx => ctx.GetInstance<ConfigurationStore>());
        For<ITypeMapFactory>().Use<TypeMapFactory>();
        For<IMappingEngine>().Use<MappingEngine>();

        Scan(scan =>
             {
                 scan.AssemblyContainingType<AppRegistry>();
                 scan.AddAllTypesOf<Profile>();
             });
}

Typical WCF Rest service usage…

public class AccountService : IAccountService
{
        private readonly IMappingEngine _mappingEngine;
        private readonly IAccountFacade _accountFacade;

        public AccountService(IMappingEngine mappingEngine, IAccountFacade accountFacade)
        {
            _mappingEngine = mappingEngine;
        _accountFacade = accountFacade;
        }

        public IEnumerable<Account> GetAccounts()
        {
            var ret = new List<Account>();
            var entities = _accountFacade.GetAccounts().ToList();   
            foreach (var account in entities.Select(entity => _mappingEngine.Map<In.Account, Out.Account>(entity)))
            {
                ret.Add(account);
            }
            return ret;     
        }
}

Answer 1

It seems the problem was caused by the configuration of the MappingEngine – it needed to be set as a singleton otherwise instances were not cleared because it is IDisposable.

So config changed to..

For<IMappingEngine>().Singleton().Use<MappingEngine>();