企业库 5.0 是否缓存数据读取器和访问器方法的自定义类之间的映射

Question

想知道 Enterprise Library 5.0 的 Accessor 方法是否缓存 datareader 的字段以及自定义类以提高性能，以便它不会使用反射在自定义类上查找字段名称，并且在将 datareader 映射到时不会在 datareader 上查找字段名称物体？因为将每个访问/代码块的自定义类字段映射到数据读取器字段是一项相当昂贵的操作

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        Database db = EnterpriseLibraryContainer.Current.GetInstance<Database>();
        var r = db.ExecuteSqlStringAccessor<Region>("SELECT * FROM Region");
    }

}

public class Region
{
    public string RegionnId { get; set; }
    public string Name { get; set; }
}

Answer 1

从代码来看，该方法经过：

public static IEnumerable<TResult> ExecuteSqlStringAccessor<TResult>(this Database database, string sqlString)
    where TResult : new()
{
    return CreateSqlStringAccessor<TResult>(database, sqlString).Execute();   
}

then 到

IRowMapper<TResult> defaultRowMapper = MapBuilder<TResult>.BuildAllProperties();

which经过

return MapAllProperties().Build();

which是：

    public static IMapBuilderContext<TResult> MapAllProperties()
    {
        IMapBuilderContext<TResult> context = new MapBuilderContext();

        var properties =
            from property in typeof(TResult).GetProperties(BindingFlags.Instance | BindingFlags.Public)
            where IsAutoMappableProperty(property)
            select property;

        foreach (var property in properties)
        {
            context = context.MapByName(property);
        }
        return context;
    }

所以不；我没有看到任何缓存的证据。您可以添加一些，或者您可以使用已经实现物化器和参数化缓存的 domething (*咳嗽* dapper-dot-net *咳嗽*)

Answer 2

这是 entlib 支持团队建议的一个简单而不错的技巧（您可以在 http://entlib 查看完整线程.codeplex.com/discussions/281833）：

randylevy 周一晚上 11:39 不，没有任何缓存
行映射器。我所知道的唯一用于数据访问的缓存
Application Block是存储过程参数缓存。

如果您使用默认映射器，那么您可以缓存结果
自己并传递到 ExecuteSqlStringAccessor 方法，因为它
支持 IRowMapper 和 IResultSetMapper 重载。

例如：

public class RowMapperCache
{
    private Dictionary<Type, object> cache = new Dictionary<Type, object>();
    private object locker = new object();

    public IRowMapper<T> GetCachedMapper<T>() where T : new()
    {
        Type type = typeof(T);

        lock (locker)
        {
            if (!Contains(type))
            {
                cache[type] = MapBuilder<T>.BuildAllProperties();
            }
        }

        return cache[type] as IRowMapper<T>;
    }

    private bool Contains(T type)
    {
        return cache.ContainsKey(type);
    }
}


 // retrieve default mapper and cache it
 IRowMapper<Region> regionMapper = rowMapperCache.GetCachedMapper<Region>();

 var db = EnterpriseLibraryContainer.Current.GetInstance<Database>();
 var r = db.ExecuteSqlStringAccessor<Region>("SELECT * FROM Region", regionMapper);

再次从 EntLib 更新（更好的解决方案）：

谢谢。或许，它可以被放到 Enterprise Library 6 的桌面上
因为这看起来是个好主意？

只是为了好玩，我对示例进行了一些改进以存储 RowMapperCache
作为 EnterpriseLibraryContainer 内部的单例，以便它可以
与其他企业库对象类似地检索。虽然
不是企业库“本机”类，而是使用 RowMapperCache
仅适用于企业库，因此将其存储在中并不是一个巨大的飞跃
容器（特别是如果您没有使用完整的 Unity IoC）。

using System;
using System.Collections.Generic;
using System.Linq;

using Microsoft.Practices.EnterpriseLibrary.Common.Configuration;
using Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel;
using Microsoft.Practices.EnterpriseLibrary.Common.Configuration.ContainerModel.Unity;
using Microsoft.Practices.EnterpriseLibrary.Data;
using Microsoft.Practices.ServiceLocation;
using Microsoft.Practices.Unity;

namespace RowMapperConsole 
{
    public class Region {}

    public class RowMapperCache
    { 
        private Dictionary<Type, object> cache = new Dictionary<Type, object>();
        private object locker = new object();

        public IRowMapper<T> GetCachedMapper<T>() where T : new()
        {
            Type type = typeof(T);

        lock (locker)
            {
                if (!Contains(type))
                {
                    cache[type] = MapBuilder<T>.BuildAllProperties();
                }
            }

            return cache[type] as IRowMapper<T>;
        }

        private bool Contains(T type)
        {
            return cache.ContainsKey(type);
        } 
    }

    class Program
    {
        static void Main(string[] args)
        {
            ApplicationInitialize();

            // ...

            IEnumerable<Region> regions = GetRegions();
        }

        public static void ApplicationInitialize()
        {
            ConfigureContainer(container =>
            {
                // Register as Singleton
                container.RegisterType<RowMapperCache>(new ContainerControlledLifetimeManager());
            });
        }

        public static void ConfigureContainer(Action<IUnityContainer> action)
        {
            IUnityContainer container = new UnityContainer();

            if (action != null)
                action(container);

            IContainerConfigurator configurator = new UnityContainerConfigurator(container);
            EnterpriseLibraryContainer.ConfigureContainer(configurator, ConfigurationSourceFactory.Create());
            IServiceLocator locator = new UnityServiceLocator(container);
            EnterpriseLibraryContainer.Current = locator;
        }

        public static IEnumerable<Region> GetRegions()
        {
            IRowMapper<Region> regionMapper = EnterpriseLibraryContainer.Current.GetInstance<RowMapperCache>()
                                                  .GetCachedMapper<Region>();
            var db = EnterpriseLibraryContainer.Current.GetInstance<Database>();

            return db.ExecuteSqlStringAccessor<Region>("SELECT * FROM Region", regionMapper).ToList();
        }
    }
}