首页 新闻 搜索 专区 学院

DbContext 请求性能问题

0
悬赏园豆:20 [已关闭问题] 关闭于 2016-04-22 17:23

1.项目中创建类似基类

public class BaseRepository<TEntity> : IRepository<TEntity> where TEntity : class
{
protected readonly DbContext Context;

public BaseRepository(DbContext context)
{
Context = context;
}

public TEntity Single(Expression<Func<TEntity, bool>> expression)
{
return GetList().FirstOrDefault(expression);
}

......

}

2. 页面中进行操作时new 相应的对象,然后进行数据操作。

IRepository<MultipleContactEntity> mcresp = new BaseRepository<MultipleContactEntity>(new DynaMineContext());

mcresp.Filter...

3. 现在测试发现每次new 都需要500ms左右,如果一个请求中有多个相关的对象要使用的话,请求时间就有些不可观了。

问题:怎么才能降低时间耗费。

注:在Application_Start中参考 http://www.cnblogs.com/dudu/p/entity-framework-warm-up.html ,添加代码问题依旧。

waiter的主页 waiter | 小虾三级 | 园豆:1000
提问于:2016-04-20 14:47
< >
分享
所有回答(2)
0

如果对于同一个库的查询new一次就行了吧。之前有一个项目中是这样做的,如果是多个BLL层的类可以用同一个dbcontext类的实例进行操作,那么可以做一个工厂类,工厂类在构造函数中实例化一个dbcontext实体就好了。请求结束销毁dbcontext的时候也是用工厂类销毁。

是不是测试了dbcontext类的实例化,第二次请求时还是这么长时间吗?

于为源 | 园豆:956 (小虾三级) | 2016-04-20 15:11

同一个dbcontext有并发问题..

支持(0) 反对(0) waiter | 园豆:1000 (小虾三级) | 2016-04-20 15:53

@waiter: 不是全局都用同一个,是每次请求的Controller中初始化同一个,请求结束销毁

支持(0) 反对(0) 于为源 | 园豆:956 (小虾三级) | 2016-04-20 17:19

@于为源: 问题就是在congtroller里面初始化,现在存在性能问题

支持(0) 反对(0) waiter | 园豆:1000 (小虾三级) | 2016-04-21 12:38

@waiter: :)。待高手解决。

支持(0) 反对(0) 于为源 | 园豆:956 (小虾三级) | 2016-04-21 13:09
0
 public abstract class UnitOfWorkData<TData> : IDisposable where TData : new()
    {
        protected UnitOfWorkData(string key)
        {
            this.HTTPCONTEXTKEY = key;
        }



        private string HTTPCONTEXTKEY = "";
        private readonly Hashtable _threads = new Hashtable();
        /// <summary>
        /// 获得当前数据
        /// </summary>
        public TData Current
        {
            get
            {
                TData tData = GetData();

                if (tData == null)
                {
                    tData = CreateData();
                    SaveData(tData);
                }

                return tData;
            }
        }
        /// <summary>
        /// 创建数据
        /// </summary>
        /// <returns></returns>
        protected abstract TData CreateData();
        /// <summary>
        /// 获得数据
        /// </summary>
        /// <returns></returns>
        private TData GetData()
        {
            if (HttpContext.Current != null)
            {
                if (HttpContext.Current.Items.Contains(HTTPCONTEXTKEY))
                {
                    return (TData)HttpContext.Current.Items[HTTPCONTEXTKEY];
                }

                return default(TData);
            }
            else
            {
                Thread thread = Thread.CurrentThread;
                if (string.IsNullOrEmpty(thread.Name))
                {
                    thread.Name = Guid.NewGuid().ToString();
                    return default(TData);
                }
                else
                {
                    lock (_threads.SyncRoot)
                    {
                        return (TData)_threads[Thread.CurrentThread.Name];
                    }
                }
            }
        }
        /// <summary>
        /// 保存数据
        /// </summary>
        /// <param name="tData"></param>
        private void SaveData(TData tData)
        {
            if (HttpContext.Current != null)
            {
                HttpContext.Current.Items[HTTPCONTEXTKEY] = tData;
                //HttpContext.Current.DisposeOnPipelineCompleted(container);
            }
            else
            {
                lock (_threads.SyncRoot)
                {
                    _threads[Thread.CurrentThread.Name] = tData;
                }
            }
        }

        public void Dispose()
        {
            if (HttpContext.Current != null)
            {
                HttpContext.Current.Items[HTTPCONTEXTKEY] = null;
            }
            else
            {
                lock (_threads.SyncRoot)
                {
                    _threads[Thread.CurrentThread.Name] = null;
                }
            }
        }
    }

一个请求一个工作单元

public class UnitOfWorkStorFastShop : UnitOfWorkData<UnitOfWorkStorFastShopData>
    {
        public static UnitOfWorkStorFastShop Instant = new UnitOfWorkStorFastShop(typeof(UnitOfWorkStorFastShopData).ToString());
        public static UnitOfWorkStorFastShop SearchInstant = new UnitOfWorkStorFastShop(typeof(UnitOfWorkStorFastShopData).ToString());

        private UnitOfWorkStorFastShop(string key)
            : base(key)
        {
        }

        protected override UnitOfWorkStorFastShopData CreateData()
        {
            return new UnitOfWorkStorFastShopData();
        }
    }

做一个请求单例 全局调用

小眼睛老鼠 | 园豆:2774 (老鸟四级) | 2016-04-21 15:18

亲,并发问题怎么考虑!

支持(0) 反对(0) waiter | 园豆:1000 (小虾三级) | 2016-04-21 15:20

@waiter: 什么并发问题 这个是 线程 和 请求单例 不同线程 不同的请求 相互不影响

支持(0) 反对(0) 小眼睛老鼠 | 园豆:2774 (老鸟四级) | 2016-04-21 17:14

@waiter: 而且并发可以用ef的悲观锁 解决并发问题 不过这个就不是context级别的事情了

支持(0) 反对(0) 小眼睛老鼠 | 园豆:2774 (老鸟四级) | 2016-04-21 17:15

@小眼睛老鼠: 额。。 这个并发不一定是指记录是否锁定方面,而是指在调用过程中。。

支持(0) 反对(0) waiter | 园豆:1000 (小虾三级) | 2016-04-22 13:05

@waiter: 场景是什么

支持(0) 反对(0) 小眼睛老鼠 | 园豆:2774 (老鸟四级) | 2016-04-22 13:16
清除回答草稿
   您需要登录以后才能回答,未注册用户请先注册