C# structuremap自动映射内存泄漏？

我的WCF REST服务中使用的AutoMapper和StructureMap似乎存在内存泄漏

在负载测试下，我可以看到内存使用量不断增加，当我使用内存探查器更仔细地检查它时，我可以看到MappingEngine构建使用的对象有很多实例（大约是任何其他实例的9倍）

Class Name=活动实例
对象=498847
Int32[]=69373
对象[]=68116
ConcurrentDictionary+节点=37624
字符串=35240
IObjectMapper[]=30782
EventHandler=30782
MappingEngine=30781
ConcurrentDictionary=30781
ConcurrentDictionary+节点[]=30781
ConcurrentDictionary+节点[]=30781
ConcurrentDictionary=30781

下面是一个典型的实例保留图

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

bootstrapper.\u配置
->AutoMapper.ConfigurationStore（TypeMapCreated）
->System.EventHandler（多播委托）
->系统对象[]
->System.EventHandler
->AutoMapper.MappingEngine（_objectMapperCache）
->System.Collections.Concurrent.ConcurrentDictionary（m_锁）
->系统对象[]
->系统对象

（很抱歉设置了垃圾格式，但不允许我发布图片）

问题是，我不确定这是我的代码、StructureMap还是AutoMaper的问题

代码示例

引导程序（从global.asax中的应用程序_Start调用）用于自动映射

    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
    }        
}   

公共类引导程序
{
私有静态只读IConfiguration_configuration=ObjectFactory.GetInstance（）；
公共静态void Initialize（）
{
_configuration.AddProfile（）；
}
公共类自动映射配置文件：配置文件
{
受保护的覆盖无效配置（）
{
BootstrapAutoMapper（）；
}   
}
公共静态void BootstrapAutoMapper（）
{
_configuration.CreateMap（）
.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（）））；
//为简洁起见，排除了许多其他映射
}        
}   

它在StructureMap中配置为

    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>();
             });
}

private void automapper注册（）
{
For（）.Singleton（）.Use（）.Ctor（）.Is（AutoMapper.Mappers.MapperRegistry.AllMappers（））；
For（）.Use（ctx=>ctx.GetInstance（））；
For（）.Use（ctx=>ctx.GetInstance（））；
For（）.Use（）；
For（）.Use（）；
扫描（扫描=>
{
scan.AssemblyContainingType（）；
scan.AddAllTypesOf（）；
});
}

典型的WCF Rest服务使用

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;     
        }
}

公共类AccountService:IAccountService
{
私有只读IMappingEngine\u映射引擎；
私有只读IAccountFacade\u accountFacade；
公共帐户服务（IMappingEngine映射引擎、IAccountFacade accountFacade）
{
_mappingEngine=mappingEngine；
_accountFacade=accountFacade；
}
公共IEnumerable GetAccounts（）
{
var ret=新列表（）；
var entities=_accountFacade.GetAccounts（）.ToList（）；
foreach（实体中的var帐户。选择（实体=>\u mappingEngine.Map（实体）））
{
ret.Add（账户）；
}
返回ret；
}
}

问题似乎是由MappingEngine的配置引起的-需要将其设置为单例，否则实例不会被清除，因为它是IDisposable的

因此，配置更改为

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

For（）.Singleton（）.Use（）；

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