通用Linq增删改查操作

通用Linq增删改查操作，查有些条件限制，复杂查询用动态linq或linq执行sql语句。

    using System.Linq.Expressions;
    using DataModels;
    using PubOptions;
    public class CommonLinqService
    {
        private LinqDataContext db = null;
        public CommonLinqService()
        {
            db = new LinqDataContext();
        }
        #region 通用Linq操作
        #region 通用的lamuda表达式获取查询数据源返回List泛型
        / <summary>
        /  通用的lamuda表达式获取查询数据源返回List泛型
        / </summary>
        public List<T> GetSearchDataSource<T>(Func<T, bool> WhereExpression, Func<T, object> OrderByExpression, int CurrentPageIndex, int PageSize, out int RecordCount) where T : class
        {
            try
            {
                var entity = db.GetTable<T>().Where(WhereExpression).OrderBy(OrderByExpression);
                RecordCount = entity.Count();
                return entity.Skip(CurrentPageIndex * PageSize).Take(PageSize).ToList();
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
        #endregion
        #region 通用的lamuda表达式获取单条数据
        / <summary>
        /  通用的lamuda表达式单条数据
        / </summary>
        public T GetEntity<T>(Expression<Func<T, bool>> expression) where T : class
        {
            try
            {
                return db.GetTable<T>().SingleOrDefault(expression);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
        #endregion
        #region 通用的lamuda表达式获取所有数据返回List泛型
        /// <summary>
        /// 通用的lamuda表达式获取所有数据返回List泛型
        /// </summary>
        public List<T> GetEntityList<T>(Expression<Func<T, bool>> expression) where T : class
        {
            try
            {
                return db.GetTable<T>().Where(expression).ToList<T>();
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
        #endregion
        #region 通用的lamuda表达式判断是否存在记录
        / <summary>
        /  通用的lamuda表达式判断是否存在记录
        / </summary>
        public bool IsExitsData<T>(Expression<Func<T, bool>> expression) where T : class
        {
            bool result = true;
            try
            {
                T entity = db.GetTable<T>().SingleOrDefault(expression);
                if (entity == null)
                {
                    result = false;
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
            return result;
        }
        #endregion
        #region 通用的lamuda表达式新增实体操作
        / <summary>
        /  通用的lamuda表达式新增实体操作
        / </summary>
        public bool AddEntity<T>(T entity) where T : class
        {
            bool result = false;
            try
            {
                db.GetTable<T>().InsertOnSubmit(entity);
                db.SubmitChanges();
                result = true;
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
            return result;
        }
        #endregion
        #region 通用的lamuda表达式删除实体操作
        / <summary>
        /  通用的lamuda表达式删除实体操作[批量删除（string[] array = (string[])KeyIds.ToArray(typeof(string));expression = T => array.Contains(T.KeyId));)]
        / </summary>
        public bool DeleteEntity<T>(Expression<Func<T, bool>> expression) where T : class
        {
            bool result = false;
            try
            {
                var entity = db.GetTable<T>().Where(expression);
                if (entity != null)
                {
                    db.GetTable<T>().DeleteAllOnSubmit(entity);
                    db.SubmitChanges();
                    result = true;
                }
                else
                {
                    result = false;
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
            return result;
        }
        #endregion
        #region 通用的lamuda表达式和反射机制更新实体操作
        / <summary>
        /  通用的lamuda表达式和反射机制更新实体操作(批量更新expression = T => KeyIDs.Contains(T.KeyId))
        / </summary>
        public bool UpdateEntity<T>(List<T> entity, Expression<Func<T, bool>> expression) where T : class
        {
            bool result = false;
            try
            {
                int i = 0;
                var list = db.GetTable<T>().Where(expression).ToList<T>();
                //下面用到循环，是为了能批量更新
                for (; i < list.Count(); i++)
                {
                    if (list[i] != null)
                    {
                        Dynamic.SetObject(entity[i],list[i]);
                    }
                    else
                    {
                        break;
                    }
                }
                if (i == list.Count())
                {
                    db.SubmitChanges();
                    result = true;
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
            return result;
        }
        #endregion
        #endregion
    }

    /// <summary>
    /// 对象属性或字段动态操作类
    /// </summary>
    public class Dynamic
    {
        /// <summary>
        /// 获取对象属性或字段名
        /// </summary>
        /// <param name="obj">对象</param>
        /// <returns></returns>
        public static List<string> GetNames(object obj)
        {
            List<string> names = new List<string>();
            Type type = obj.GetType();
            System.Reflection.PropertyInfo[] pis = type.GetProperties(
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
            System.Reflection.FieldInfo[] fis = type.GetFields(
                System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
            foreach (System.Reflection.PropertyInfo pi in pis)
                names.Add(pi.Name);
            foreach (System.Reflection.FieldInfo fi in fis)
            {
                if (names.IndexOf(fi.Name) == -1)
                    names.Add(fi.Name);
            }
            return names;
        }

        /// <summary>
        /// 获取对象属性或字段的值
        /// </summary>
        /// <param name="obj">要获取值的对象</param>
        /// <param name="name">对象属性或字段名,区分大小写</param>
        /// <returns></returns>
        public static object GetValue(object obj, string name)
        {
            object value = GetPropertyValue(obj, name);
            if (value == null)
                value = GetFieldValue(obj, name);
            return value;
        }

        /// <summary>
        /// 动态给对象属性或字段赋值
        /// </summary>
        /// <param name="obj">要赋值的对象</param>
        /// <param name="name">对象属性或字段名,区分大小写</param>
        /// <param name="value">对象属性或字段要赋的值</param>
        /// <param name="isUpperLower">是否区分大小写，true 区分，false 不区分</param>
        /// <returns></returns>
        public static object SetValue(object obj, string name, object value)
        {
            SetPropertyValue(obj, name, value);
            SetFieldValue(obj, name, value);
            return obj;
        }

        /// <summary>
        /// 动态给对象赋值（把源赋给目标）
        /// </summary>
        /// <param name="source">源对象</param>
        /// <param name="destination">目标对象</param>       
        public static void SetObject(object source, object destination)
        {
            //动态给note对象赋值
            List<String> list = GetNames(source); //获取result的属性名
            //获取result每一个属性值,并赋给un对象对应的属性
            foreach (var name in list)
            {
                object obj = GetValue(source, name);
                if (obj != null)
                {
                    SetValue(destination, name, obj);
                }
            }
        } 
    }