entity framewrk訪問數據庫的封裝類 (MSSql 數據庫 )
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
namespace DAL
{
public partial class MyEntities : DbContext
{
public MyEntities(): base(GetEntityConnectionString(connectionString))
{
}
private static string GetEntityConnectionString(string connectionString)
{
EntityConnectionStringBuilder entityBuilder = new EntityConnectionStringBuilder();
entityBuilder.Metadata = "res://*/MyDB.csdl|res://*/MyDB.ssdl|res://*/MyDB.msl";
entityBuilder.ProviderConnectionString = connectionString;
entityBuilder.Provider = "System.Data.SqlClient";
return entityBuilder.ToString();
}
}
/**//// <summary>
/// MSSql 數據庫 數據層 父類
/// </summary>
/// <typeparam name="T"></typeparam>
public class BaseDAL<T> where T : class,new()
{
/**//// <summary>
/// EF 上下文對象
/// </summary>
MyEntities db = new MyEntities();
1.0 新增實體，返回受影響的行數 + int Add(T model)#region 1.0 新增實體，返回受影響的行數 + int Add(T model)
/**//// <summary>
/// 1.0 新增實體，返回受影響的行數
/// </summary>
/// <param name="model"></param>
/// <returns>返回受影響的行數</returns>
public int Add(T model)
{
db.Set<T>().Add(model);
//保存成功後，會將自增的id設置給model的主鍵屬性，並返回受影響的行數。
return db.SaveChanges();
}
#endregion
新增實體，返回對應的實體對象 + T AddReturnModel(T model)#region 新增實體，返回對應的實體對象 + T AddReturnModel(T model)
/**//// <summary>
/// 1.1 新增實體，返回對應的實體對象
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public T AddReturnModel(T model)
{
db.Set<T>().Add(model);
db.SaveChanges();
return model;
}
#endregion
根據id刪除 + int Del(T model)#region 根據id刪除 + int Del(T model)
/**//// <summary>
/// 根據id刪除
/// </summary>
/// <param name="model">必須包含要刪除id的對象</param>
/// <returns></returns>
public int Del(T model)
{
db.Set<T>().Attach(model);
db.Set<T>().Remove(model);
return db.SaveChanges();
}
#endregion
根據條件刪除 + int DelBy(Expression> delWhere)#region 根據條件刪除 + int DelBy(Expression<Func<T, bool>> delWhere)
/**//// <summary>
/// 2.1 根據條件刪除
/// </summary>
/// <param name="delWhere"></param>
/// <returns>返回受影響的行數</returns>
public int DelBy(Expression<Func<T, bool>> delWhere)
{
//2.1.1 查詢要刪除的數據
List<T> listDeleting = db.Set<T>().Where(delWhere).ToList();
//2.1.2 將要刪除的數據 用刪除方法添加到 EF 容器中
listDeleting.ForEach(u =>
{
db.Set<T>().Attach(u); //先附加到EF 容器
db.Set<T>().Remove(u); //標識爲刪除狀態
});
//2.1.3 一次性生成sql語句 到數據庫執行刪除
return db.SaveChanges();
}
#endregion
修改實體 + int Modify(T model)#region 修改實體 + int Modify(T model)
/**//// <summary>
/// 修改實體
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public int Modify(T model)
{
DbEntityEntry entry = db.Entry<T>(model);
entry.State = EntityState.Modified;
return db.SaveChanges();
}
#endregion
修改實體，可修改指定屬性 + int Modify(T model, params string[] propertyNames)#region 修改實體，可修改指定屬性 + int Modify(T model, params string[] propertyNames)
/**//// <summary>
/// 3.1 修改實體，可修改指定屬性
/// </summary>
/// <param name="model"></param>
/// <param name="propertyName"></param>
/// <returns></returns>
public int Modify(T model, params string[] propertyNames)
{
//3.1.1 將對象添加到EF中
DbEntityEntry entry = db.Entry<T>(model);
//3.1.2 先設置對象的包裝狀態爲 Unchanged
entry.State = EntityState.Unchanged;
//3.1.3 循環被修改的屬性名數組
foreach (string propertyName in propertyNames)
{
//將每個被修改的屬性的狀態設置爲已修改狀態；這樣在後面生成的修改語句時，就只爲標識爲已修改的屬性更新
entry.Property(propertyName).IsModified = true;
}
return db.SaveChanges();
}
#endregion
批量修改 + int ModifyBy(T model, Expression> whereLambda, params string[] modifiedPropertyNames)#region 批量修改 + int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedPropertyNames)
/**//// <summary>
/// 3.2 批量修改
/// </summary>
/// <param name="model"></param>
/// <param name="whereLambda"></param>
/// <param name="modifiedPropertyNames"></param>
/// <returns></returns>
public int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] modifiedPropertyNames)
{
//3.2.1 查詢要修改的數據
List<T> listModifing = db.Set<T>().Where(whereLambda).ToList();
//3.2.2 獲取實體類類型對象
Type t = typeof(T);
//3.2.3 獲取實體類所有的公共屬性
List<PropertyInfo> propertyInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
//3.2.4 創建實體屬性字典集合
Dictionary<string, PropertyInfo> dicPropertys = new Dictionary<string, PropertyInfo>();
//3.2.5 將實體屬性中要修改的屬性名 添加到字典集合中 鍵：屬性名 值：屬性對象
propertyInfos.ForEach(p =>
{
if (modifiedPropertyNames.Contains(p.Name))
{
dicPropertys.Add(p.Name, p);
}
});
//3.2.6 循環要修改的屬性名
foreach (string propertyName in modifiedPropertyNames)
{
//判斷要修改的屬性名是否在實體類的屬性集合中存在
if (dicPropertys.ContainsKey(propertyName))
{
//如果存在，則取出要修改的屬性對象
PropertyInfo proInfo = dicPropertys[propertyName];
//取出要修改的值
object newValue = proInfo.GetValue(model, null);
//批量設置要修改對象的屬性
foreach (T item in listModifing)
{
//爲要修改的對象的要修改的屬性設置新的值
proInfo.SetValue(item, newValue, null);
}
}
}
//一次性生成sql語句 到數據庫執行
return db.SaveChanges();
}
#endregion
根據條件查詢單個model + T GetModel(Expression> whereLambda)#region 根據條件查詢單個model + T GetModel(Expression<Func<T, bool>> whereLambda)
/**//// <summary>
/// 4.0 根據條件查詢單個model
/// </summary>
/// <param name="whereLambda"></param>
/// <returns></returns>
public T GetModel(Expression<Func<T, bool>> whereLambda)
{
return db.Set<T>().Where(whereLambda).AsNoTracking().FirstOrDefault();
}
#endregion
根據條件查詢單個model並排序 + T GetModel(Expression> whereLambda, Expression> orderLambda, bool isAsc = true)#region 根據條件查詢單個model並排序 + T GetModel<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
/**//// <summary>
/// 4.1 根據條件查詢單個model並排序
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <param name="whereLambda"></param>
/// <param name="orderLambda"></param>
/// <param name="isAsc"></param>
/// <returns></returns>
public T GetModel<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
{
if (isAsc)
{
return db.Set<T>().Where(whereLambda).OrderBy(orderLambda).AsNoTracking().FirstOrDefault();
}
else
{
return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda).AsNoTracking().FirstOrDefault();
}
}
#endregion
根據條件查詢 + List GetListBy(Expression> whereLambda)#region 根據條件查詢 + List<T> GetListBy(Expression<Func<T, bool>> whereLambda)
/**//// <summary>
/// 5.0 根據條件查詢
/// </summary>
/// <param name="whereLambda"></param>
/// <returns></returns>
public List<T> GetListBy(Expression<Func<T, bool>> whereLambda)
{
return db.Set<T>().Where(whereLambda).AsNoTracking().ToList();
}
#endregion
根據條件查詢，並排序 + List GetListBy(Expression> whereLambda, Expression> orderLambda, bool isAsc = true)#region 根據條件查詢，並排序 + List<T> GetListBy<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
/**//// <summary>
/// 5.1 根據條件查詢，並排序
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <param name="whereLambda"></param>
/// <param name="orderLambda"></param>
/// <param name="isAsc"></param>
/// <returns></returns>
public List<T> GetListBy<TKey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
{
if (isAsc)
{
return db.Set<T>().Where(whereLambda).OrderBy(orderLambda).AsNoTracking().ToList();
}
else
{
return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda).AsNoTracking().ToList();
}
}
#endregion
根據條件查詢Top多少個，並排序 + List GetListBy(int top, Expression> whereLambda, Expression> orderLambda, bool isAsc = true)#region 根據條件查詢Top多少個，並排序 + List<T> GetListBy<TKey>(int top, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
/**//// <summary>
/// 5.2 根據條件查詢Top多少個，並排序
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <param name="top"></param>
/// <param name="whereLambda"></param>
/// <param name="orderLambda"></param>
/// <param name="isAsc"></param>
/// <returns></returns>
public List<T> GetListBy<TKey>(int top, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderLambda, bool isAsc = true)
{
if (isAsc)
{
return db.Set<T>().Where(whereLambda).OrderBy(orderLambda).Take(top).AsNoTracking().ToList();
}
else
{
return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda).Take(top).AsNoTracking().ToList();
}
}
#endregion
根據條件排序查詢 雙排序 + List GetListBy(Expression> whereLambda, Expression> orderLambda1, Expression> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)#region 根據條件排序查詢 雙排序 + List<T> GetListBy<TKey1, TKey2>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
/**//// <summary>
/// 5.3 根據條件排序查詢 雙排序
/// </summary>
/// <typeparam name="TKey1"></typeparam>
/// <typeparam name="TKey2"></typeparam>
/// <param name="whereLambda"></param>
/// <param name="orderLambda1"></param>
/// <param name="orderLambda2"></param>
/// <param name="isAsc1"></param>
/// <param name="isAsc2"></param>
/// <returns></returns>
public List<T> GetListBy<TKey1, TKey2>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
{
if (isAsc1)
{
if (isAsc2)
{
return db.Set<T>().Where(whereLambda).OrderBy(orderLambda1).ThenBy(orderLambda2).AsNoTracking().ToList();
}
else
{
return db.Set<T>().Where(whereLambda).OrderBy(orderLambda1).ThenByDescending(orderLambda2).AsNoTracking().ToList();
}
}
else
{
if (isAsc2)
{
return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda1).ThenBy(orderLambda2).AsNoTracking().ToList();
}
else
{
return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda1).ThenByDescending(orderLambda2).AsNoTracking().ToList();
}
}
}
#endregion
根據條件排序查詢Top個數 雙排序 + List GetListBy(int top, Expression> whereLambda, System.Linq.Expressions.Expression> orderLambda1, Expression> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)#region 根據條件排序查詢Top個數 雙排序 + List<T> GetListBy<TKey1, TKey2>(int top, Expression<Func<T, bool>> whereLambda, System.Linq.Expressions.Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
/**//// <summary>
/// 5.3 根據條件排序查詢Top個數 雙排序
/// </summary>
/// <typeparam name="TKey1"></typeparam>
/// <typeparam name="TKey2"></typeparam>
/// <param name="top"></param>
/// <param name="whereLambda"></param>
/// <param name="orderLambda1"></param>
/// <param name="orderLambda2"></param>
/// <param name="isAsc1"></param>
/// <param name="isAsc2"></param>
/// <returns></returns>
public List<T> GetListBy<TKey1, TKey2>(int top, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderLambda1, Expression<Func<T, TKey2>> orderLambda2, bool isAsc1 = true, bool isAsc2 = true)
{
if (isAsc1)
{
if (isAsc2)
{
return db.Set<T>().Where(whereLambda).OrderBy(orderLambda1).ThenBy(orderLambda2).Take(top).AsNoTracking().ToList();
}
else
{
return db.Set<T>().Where(whereLambda).OrderBy(orderLambda1).ThenByDescending(orderLambda2).Take(top).AsNoTracking().ToList();
}
}
else
{
if (isAsc2)
{
return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda1).ThenBy(orderLambda2).Take(top).AsNoTracking().ToList();
}
else
{
return db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda1).ThenByDescending(orderLambda2).Take(top).AsNoTracking().ToList();
}
}
}
#endregion
分頁查詢 + List GetPagedList#region 分頁查詢 + List<T> GetPagedList<TKey>
/**//// <summary>
/// 分頁查詢 + List<T> GetPagedList
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <param name="pageIndex">頁碼</param>
/// <param name="pageSize">頁容量</param>
/// <param name="whereLambda">條件 lambda表達式</param>
/// <param name="orderBy">排序 lambda表達式</param>
/// <returns></returns>
public List<T> GetPagedList<TKey>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderByLambda, bool isAsc = true)
{
// 分頁 一定注意： Skip 之前一定要 OrderBy
if (isAsc)
{
return db.Set<T>().Where(whereLambda).OrderBy(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
else
{
return db.Set<T>().Where(whereLambda).OrderByDescending(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
}
#endregion
分頁查詢 帶輸出 +List GetPagedList#region 分頁查詢 帶輸出 +List<T> GetPagedList<TKey>
/**//// <summary>
/// 分頁查詢 帶輸出
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="rowCount"></param>
/// <param name="whereLambda"></param>
/// <param name="orderBy"></param>
/// <param name="isAsc"></param>
/// <returns></returns>
public List<T> GetPagedList<TKey>(int pageIndex, int pageSize, ref int rowCount, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey>> orderByLambda, bool isAsc = true)
{
rowCount = db.Set<T>().Where(whereLambda).Count();
if (isAsc)
{
return db.Set<T>().OrderBy(orderByLambda).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
else
{
return db.Set<T>().OrderByDescending(orderByLambda).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
}
#endregion
分頁查詢 帶輸出 並支持雙字段排序#region 分頁查詢 帶輸出 並支持雙字段排序
/**//// <summary>
/// 分頁查詢 帶輸出 並支持雙字段排序
/// </summary>
/// <typeparam name="TKey"></typeparam>
/// <param name="pageIndex"></param>
/// <param name="pageSize"></param>
/// <param name="rowCount"></param>
/// <param name="whereLambda"></param>
/// <param name="orderByLambda1"></param>
/// <param name="orderByLambda2"></param>
/// <param name="isAsc1"></param>
/// <param name="isAsc2"></param>
/// <returns></returns>
public List<T> GetPagedList<TKey1, TKey2>(int pageIndex, int pageSize, ref int rowCount, Expression<Func<T, bool>> whereLambda, Expression<Func<T, TKey1>> orderByLambda1, Expression<Func<T, TKey2>> orderByLambda2, bool isAsc1 = true, bool isAsc2 = true)
{
rowCount = db.Set<T>().Where(whereLambda).Count();
if (isAsc1)
{
if (isAsc2)
{
return db.Set<T>().OrderBy(orderByLambda1).ThenBy(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
else
{
return db.Set<T>().OrderBy(orderByLambda1).ThenByDescending(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
}
else
{
if (isAsc2)
{
return db.Set<T>().OrderByDescending(orderByLambda1).ThenBy(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
else
{
return db.Set<T>().OrderByDescending(orderByLambda1).ThenByDescending(orderByLambda2).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToList();
}
}
}
#endregion
}
}文章轉載自： entity framewrk訪問數據庫的封裝類 http://www.studyofnet.com/news/768.html