關於IList、IQueryable、IEnumerable與Func、Expression的關係2-詳解

關於IList、IQueryable、IEnumerable與Func、Expression的關係2-詳解

Core Object
NHibernate：ISession -> CreateCriteria
VS.NET：System.Linq -> Queryable、Enumerable

HNibernate工廠類

using System;
using System.Collections.Generic;
using NHibernate;
using NHibernate.Cfg;
using System.Configuration;
using System.Configuration.Assemblies;
using System.Web;

namespace TestPro.DAO
{
    /// <summary>
    /// Data access base class
    /// </summary>
    public class NHibernateHelper
    {
        protected static ISessionFactory session;

        public static ISession GetSession()
        {
            if (session == null)
            {
                lock (typeof(NHibernateHelper))
                {
                    if (session == null)
                    {
                        //Configuration cfg = new Configuration();  
                        //cfg.AddAssembly("Domain");
                        string cfgpath = System.Web.HttpContext.Current.Server.MapPath("~/" + "hibernate.cfg.xml");//"~/hibernate.cfg.xml");"..\\hibernate.cfg.xml"
                        var cfg = new NHibernate.Cfg.Configuration().Configure(cfgpath);//C:\Program Files (x86)\IIS Express(我在這個目錄下放了這個文件hibernate.cfg.xml)           
                        session = cfg.BuildSessionFactory();
                    }
                }
            }
            return session.OpenSession();
            //return session.OpenSession(new SQLWatcher());
        }
    }

    public class SQLWatcher : EmptyInterceptor
    {
        public override NHibernate.SqlCommand.SqlString OnPrepareStatement(NHibernate.SqlCommand.SqlString sql)
        {
            System.Diagnostics.Debug.WriteLine("sql語句:" + sql);
            return base.OnPrepareStatement(sql);
        }
    }
}

NHibernateDAL

using System;
using System.Collections.Generic;
using System.Linq;
using golSysLin=System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using NHibernate;
using Domain;


namespace TestPro.DAO
{
    public class TabUserDAO
    {

        #region Constructor
        /// <summary>
        /// Construtor
        /// </summary>
        public TabUserDAO() : base()
        {
        }
        #endregion


        #region Methods

        /// <summary>
        /// Method responsible to insert TabUser objects into the database
        /// </summary>
        /// <param name="tabUser"></param>
        /// <returns></returns>
        public TabUser Insert(TabUser tabUser)
        {

            ISession session = NHibernateHelper.GetSession();
            session.Save(tabUser);
            session.Flush();
            session.Close();
            return session.Get<TabUser>(tabUser.ID);

        }

        /// <summary>
        /// Method responsible to edit TabUser objects from a database
        /// </summary>
        /// <param name="tabUser"></param>
        /// <returns></returns>
        public TabUser Edit(TabUser tabUser)
        {

            ISession session = NHibernateHelper.GetSession();
            session.Update(tabUser);
            session.Flush();
            session.Close();
            return session.Get<TabUser>(tabUser.ID);

        }

        /// <summary>
        /// Method responsible to delete TabUser objects from a database
        /// </summary>
        /// <param name="tabUser"></param>
        /// <returns></returns>
        public void Delete(TabUser tabUser)
        {

            ISession session = NHibernateHelper.GetSession();
            session.Delete(tabUser);
            session.Flush();
            session.Close();


        }

        /// <summary>
        /// Method responsible to list TabUser objects from a database
        /// </summary>
        /// <param name="tabUser"></param>
        /// <returns></returns>
        public IList<TabUser> List()
        {
            ISession session = NHibernateHelper.GetSession();
            return session.CreateCriteria(typeof(TabUser)).List<TabUser>();//return session.CreateCriteria<TabUser>().List<TabUser>();             
            //return session.CreateCriteria(typeof(TabUser)).List<TabUser>().Where(i=>i.ID<10).ToList<TabUser>();
        }
        public IList<TabUser> List(Func<TabUser, bool> where)
        {
            return Listable(where).ToList<TabUser>();
        }

        public IList<TabUser> List(Expression<Func<TabUser, bool>> where)
        {
            return Listable(where).ToList<TabUser>();
        }
        /// <summary>
        /// Method responsible to list TabUser objects for IQueryable of Func from a database 
        /// </summary>
        public IList<TabUser> ListByQueryable(Func<TabUser, bool> where)
        {
            return Queryable(where).ToList<TabUser>();
        }
        /// <summary>
        /// Method responsible to list TabUser objects for IQueryable of Expression from a database 
        /// </summary>
        public IList<TabUser> ListByQueryable(Expression<Func<TabUser, bool>> where)    
        {
            return Queryable(where).ToList<TabUser>();
        }

        public IList<TabUser> ListByEnumerable(Func<TabUser, bool> where)               
        {
            return Enumerable(where).ToList<TabUser>();
        }

        public IList<TabUser> ListByEnumerable(Expression<Func<TabUser, bool>> where)
        {
            return Enumerable(where).ToList<TabUser>();
        }

        public IQueryable<TabUser> ListOfQueryable(Func<TabUser, bool> where)
        {
            return Queryable(where);
        }

        public IQueryable<TabUser> ListOfQueryable(Expression<Func<TabUser, bool>> where)   
        {
            return Queryable(where);
        }

        public IEnumerable<TabUser> ListOfEnumerable(Func<TabUser, bool> where)             
        {
            return Enumerable(where);
        }

        public IEnumerable<TabUser> ListOfEnumerable(Expression<Func<TabUser, bool>> where)
        {
            return Enumerable(where);
        }
        //(IEnumerable<TabUser>)//如果性能不行可以把以下函數的返回值都修改爲IEnumerable類型，該數據類型是泛型，是安全的。
        private IList<TabUser> Listable(Func<TabUser, bool> where)//1 second select
        {
            //where = (t) => { string name = t.Name.Trim();return t.Name == name;  };

            ISession session = NHibernateHelper.GetSession();
            return session.CreateCriteria(new TabUser().GetType()).List<TabUser>().Where(where).ToList<TabUser>();//where = t => t.Age > 30 && t.Age < 40;
        }

        private IList<TabUser> Listable(Expression<Func<TabUser, bool>> where)//3
        {
            ISession session = NHibernateHelper.GetSession();
            return session.CreateCriteria(typeof(TabUser)).List<TabUser>().Where(where.Compile()).ToList<TabUser>();
        }

        private IQueryable<TabUser> Queryable(Func<TabUser, bool> where)//4
        {
            ISession session = NHibernateHelper.GetSession();
            return global::System.Linq.Queryable.Where(session.CreateCriteria(typeof(TabUser)).List<TabUser>().AsQueryable(), ex => where(ex));
        }

        private IQueryable<TabUser> Queryable(Expression<Func<TabUser, bool>> where) //2
        {
            ISession session = NHibernateHelper.GetSession();
            return golSysLin::Queryable.Where(session.CreateCriteria(typeof(TabUser)).List<TabUser>().AsQueryable(), where);//
        }

        private IEnumerable<TabUser> Enumerable(Func<TabUser, bool> where)//1 first select
        {
            ISession session = NHibernateHelper.GetSession();
            return golSysLin::Enumerable.Where(session.CreateCriteria(typeof(TabUser)).List<TabUser>().AsEnumerable<TabUser>(), where);
        }

        private IEnumerable<TabUser> Enumerable(Expression<Func<TabUser, bool>> where)//3
        {
            ISession session = NHibernateHelper.GetSession();
            return golSysLin::Enumerable.Where(session.CreateCriteria(typeof(TabUser)).List<TabUser>().AsEnumerable<TabUser>(), where.Compile());
        } 


        #endregion

        #region Extend



        #endregion

    }

    enum ListOfType
    {
        IQUERYABLE,
        IENUMERABLE
    }
}

MVC控制器層

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using Business;
using Domain;
using Ninject;
using Ninject.Injection;
using Ninject.Modules;
using System.Linq.Expressions;
using System.Diagnostics;

namespace TestMVC.Controllers
{
    public class TabUserController : Controller
    {
        TabUserBusiness obj = new TabUserBusiness();

        public ActionResult Index()
        {
            var iterations = 100;
            var watch = new Stopwatch();

            IList<TabUser> list = new List<TabUser>();
            //var list = new List<TabUser>();
            watch.Start();
            for (int i = 0; i < iterations; i++)
            {
                Func<TabUser, bool> func = null;
                //list = obj.ListByOver();//.ToList();
                list = obj.List((Func<TabUser, bool>)(u => 1 == 1)).ToList();
            }
            watch.Stop();
            ViewData["WatchIListFunc"] = watch.ElapsedMilliseconds;
            var list2 = new List<TabUser>();
            watch.Reset();
            watch.Start();
            for (int i = 0; i < iterations; i++)
            {
                list2 = obj.List((Expression<Func<TabUser, bool>>)(u => 1 == 1)).ToList();
            }
            watch.Stop();
            ViewData["WatchIListExpr"] = watch.ElapsedMilliseconds;

            var list3 = new List<TabUser>();//.AsQueryable();
            watch.Reset();
            watch.Start();
            for (int i = 0; i < iterations; i++)
            {
                list3 = obj.ListByQueryable((Func<TabUser, bool>)(u => 1 == 1)).ToList();
            }
            watch.Stop();
            ViewData["WatchIQueryableFunc"] = watch.ElapsedMilliseconds;
            var list4 = new List<TabUser>();//.AsQueryable();
            watch.Reset();
            watch.Start();
            for (int i = 0; i < iterations; i++)
            {
                list4 = obj.ListByQueryable((Expression<Func<TabUser, bool>>)(u => 1 == 1)).ToList();
            }
            watch.Stop();
            ViewData["WatchIQueryableExpr"] = watch.ElapsedMilliseconds;

            var list5 = new List<TabUser>();//.AsEnumerable();
            watch.Reset();
            watch.Start();
            for (int i = 0; i < iterations; i++)
            {
                list5 = obj.ListByEnumerable((Func<TabUser, bool>)(u => 1 == 1)).ToList();
            }
            watch.Stop();
            ViewData["WatchIEnumerableFunc"] = watch.ElapsedMilliseconds;
            var list6 = new List<TabUser>();//.AsEnumerable();
            watch.Reset();
            watch.Start();
            for (int i = 0; i < iterations; i++)
            {
                list6 = obj.ListByEnumerable((Expression<Func<TabUser, bool>>)(u => 1 == 1)).ToList();
            }
            watch.Stop();
            ViewData["WatchIEnumerableExpr"] = watch.ElapsedMilliseconds;


            return View(list3);             //http://localhost:55881/TabUser/Index
        }

    }
}

BLL層

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using TestPro.DAO;
using Domain;

namespace Business
{
    public class TabUserBusiness
    {

        private TabUserDAO obj;
        public TabUserBusiness()
        {
            obj = new TabUserDAO();
        }

        public IList<TabUser> List(Func<TabUser, bool> where)// 
        {
            return obj.List(where);
        }
        public IList<TabUser> List(Expression<Func<TabUser, bool>> where)
        {
            return obj.List(where);
        }

        public IList<TabUser> ListByQueryable(Func<TabUser, bool> where)
        {
            return obj.ListByQueryable(where);
        }
        public IList<TabUser> ListByQueryable(Expression<Func<TabUser, bool>> where)
        {
            return obj.ListByQueryable(where);
        }

        public IList<TabUser> ListByEnumerable(Func<TabUser, bool> where)
        {         
            return obj.ListByEnumerable(where);
        }        
        public IList<TabUser> ListByEnumerable(Expression<Func<TabUser, bool>> where)
        {
            return obj.ListByEnumerable(where);
        }

        public IEnumerable<TabUser> ListOfEnumerable(Func<TabUser, bool> where)
        {
            return obj.ListOfEnumerable(where);
        }
        public IEnumerable<TabUser> ListOfEnumerable(Expression<Func<TabUser, bool>> where)
        {
            return obj.ListOfEnumerable(where);
        }
    }
}

版權所有，轉載請註明文章出處 http://blog/csdn.net/cadenzasolo