EF架構~性能高效的批量操作(Update篇）

回到目錄

很多時間之長，我寫了EF架構~性能高效的批量操作(Insert篇），而今天我把Update篇也寫一下，這對於批量處理數據很有幫助，它解決了EF與linq to sql批量更新數據上的效率問題。

對於EF架構中的批量更新操作，需要我們為實體的導航屬性進行手動的標示，因為EF生成的實體中沒有一個特殊的說明，所以，我們必須要告訴系統，哪個屬性是導航屬性，而導航屬性是我們不去進行update的。

   /// <summary>
    /// 屬性的導航屬性
    /// </summary>
    public class NavigationAttribute : Attribute
    {

    }

而對於要進行批量更新的實體，我們需要為導航屬性添加這個特性

   public class User
    {
        public int UserID { get; set; }
        [Navigation]
        public User_Extension User_Extension { get; set; }
    }

而對於我們構建批量Update語句，請看代碼，它需要對導航屬性進行過濾

        /// <summary>
        /// 構建Update語句串
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="entity"></param>
        /// <returns></returns>
        private Tuple<string, object[]> CreateUpdateSQL<TEntity>(TEntity entity) where TEntity : class
        {
            if (entity == null)
                throw new ArgumentException("The database entity can not be null.");
            List<string> pkList = GetPrimaryKey<TEntity>().Select(i => i.Name).ToList();

            Type entityType = entity.GetType();
            var table = entityType.GetProperties().Where(i =>
                !pkList.Contains(i.Name)
                && i.GetValue(entity, null) != null
                && i.PropertyType != typeof(EntityState)
                && !(i.GetCustomAttributes(false).Length > 0
                && i.GetCustomAttributes(false).Where(j => j.GetType() == typeof(NavigationAttribute)) != null)
                && (i.PropertyType.IsValueType || i.PropertyType == typeof(string)) //過濾導航屬性
                 ).ToArray();

            //過濾主鍵，航行屬性，狀態屬性等
            if (pkList == null || pkList.Count == 0)
                throw new ArgumentException("The Table entity have not a primary key.");
            List<object> arguments = new List<object>();
            StringBuilder builder = new StringBuilder();

            foreach (var change in table)
            {
                if (pkList.Contains(change.Name))
                    continue;
                if (arguments.Count != 0)
                    builder.Append(", ");
                builder.Append(change.Name + " = {" + arguments.Count + "}");
                if (change.PropertyType == typeof(string) || change.PropertyType == typeof(DateTime))
                    arguments.Add("'" + change.GetValue(entity, null).ToString().Replace("'", "char(39)") + "'");
                else
                    arguments.Add(change.GetValue(entity, null));
            }

            if (builder.Length == 0)
                throw new Exception("沒有任何屬性進行更新");

            builder.Insert(0, " UPDATE " + string.Format("[{0}]", entityType.Name) + " SET ");

            builder.Append(" WHERE ");
            bool firstPrimaryKey = true;

            foreach (var primaryField in pkList)
            {
                if (firstPrimaryKey)
                    firstPrimaryKey = false;
                else
                    builder.Append(" AND ");

                object val = entityType.GetProperty(primaryField).GetValue(entity, null);
                builder.Append(GetEqualStatment(primaryField, arguments.Count));
                arguments.Add(val);
            }
            return new Tuple<string, object[]>(builder.ToString(), arguments.ToArray());

        }

而對子類公開的Update方法，我們進行了一個封裝，它通過操作枚舉來確實你是要insert,update還是delete，看代碼

        /// <summary>
        /// 執行ＳＱＬ，根據ＳＱＬ操作的類型
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="list"></param>
        /// <param name="sqlType"></param>
        /// <returns></returns>
        protected string DoSQL<TEntity>(IEnumerable<TEntity> list, SQLType sqlType) where TEntity : class
        {
            StringBuilder sqlstr = new StringBuilder();
            switch (sqlType)
            {
                case SQLType.Insert:
                    list.ToList().ForEach(i =>
                    {
                        Tuple<string, object[]> sql = CreateInsertSQL(i);
                        sqlstr.AppendFormat(sql.Item1, sql.Item2);
                    });
                    break;
                case SQLType.Update:
                    list.ToList().ForEach(i =>
                    {
                        Tuple<string, object[]> sql = CreateUpdateSQL(i);
                        sqlstr.AppendFormat(sql.Item1, sql.Item2);
                    });
                    break;
                case SQLType.Delete:
                    list.ToList().ForEach(i =>
                    {
                        Tuple<string, object[]> sql = CreateDeleteSQL(i);
                        sqlstr.AppendFormat(sql.Item1, sql.Item2);
                    });
                    break;
                default:
                    throw new ArgumentException("請輸入正確的參數");
            }
            return sqlstr.ToString();
        }

代碼完成，這個批量操作經過測試，在速度上遠遠超過EF自帶的方法，原因，當然是減少了與數據庫交互的次數。

回到目錄