操作數據庫(MySql)表的擴展方法類，對單表可以進行增、刪、改、查。

最近在學ASP.NET MVC的時候，有的時候，要對進行增、刪、改、查操作

一開始感覺用自己帶的那個 ADO.NET Entity Data Model 來進行增、刪，改、查挺方便的

但後來發一個問題，在MYSQL裏不能同時在*.edmx打開多個Read操作，SQL裏可以設置一個屬性，不記得就可以了。

所以就不用它了，由於都是對單表進行操作，沒有複雜的操作。

就寫一個簡單擴展方法

首先有一點就是，自己寫的那個類的名稱，必須和數據庫裏表的名稱一至

要不能在進行增、刪、改、查的時候，就會出問題了。

舉個例子吧

//-->查詢操作

var sp = new SortedParam[] { new SortedParam { FieldName = "id", Sorted = SortedType.Desc } };
user_info ui = new user_info();
var video = ui.ToList(sp, 30);   //-->獲取用戶信息，按 id 降序取出表中前三十條記錄。

//-->插入操作

string errorMessage = string.Empty;
 var ui = new user_info();
 ui.Username = 'aaaa';
 ui.Password = 'bbbb';
 ui.Type = 1
 var result=ui.Insert(null, ref errorMessage);
 if(0< result )
 {
     //...
 }
 else
 {
     //...
 }

//-->刪除、修改基本上都差不多。

個人水平有限，如果更好的見記，還望各告訴。

具體的實例還是看看擴展方法。

擴展中使用到的兩個類

1、排序用

/// <summary>
/// 排序類型
/// </summary>
public enum SortedType
{
    /// <summary>
    /// 升序
    /// </summary>
    Asc,
    /// <summary>
    /// 降序
    /// </summary>
    Desc
}
/// <summary>
/// 排序參數
/// </summary>
public class SortedParam
{
    /// <summary>
    /// 字段名稱
    /// </summary>
    public string FieldName { get; set; }
    /// <summary>
    /// 排序類型
    /// </summary>
    public SortedType Sorted { get; set; }
}

 2、條件用

/// <summary>
/// 字段參數
/// </summary>
public class FieldParam
{
    /// <summary>
    /// 字段名稱
    /// </summary>
    public string FieldName { get; set; }
    /// <summary>
    /// 字段值
    /// </summary>
    public object FieldValue { get; set; }
    /// <summary>
    /// 字段類型
    /// </summary>
    public Type FieldType { get; set; }
}

操作數據庫單表擴展方法

/// <summary>
/// 操作數據庫單表擴展方法
/// </summary>
public static class AccessDBExtend
{
    /// <summary>
    /// 獲取 T 表中記錄集合
    /// </summary>
    /// <typeparam name="T">表的Model類</typeparam>
    /// <param name="source">類的變量</param>
    /// <returns>返回IList集合</returns>
    public static IList<T> ToList<T>(this T source) where T : new()
    {
        string table = typeof(T).Name;
        string sqlSentence = string.Format("select * from {0} ", table);
        return DataTableToList<T>(sqlSentence);
    }
 
    /// <summary>
    /// 獲取 T 表中記錄集合
    /// </summary>
    /// <typeparam name="T">表的Model類</typeparam>
    /// <param name="source">類的變量</param>
    /// <param name="pageSize">每頁的大小</param>
    /// <param name="pageIndex">當前頁面索引</param>
    /// <param name="total">當前表中記錄總數</param>
    /// <returns>返回IList集合</returns>
    public static IList<T> ToList<T>(this T source, int pageSize, int pageIndex, out int total) where T : new()
    {
        return ToList<T>(source, null, null, pageSize, pageIndex, out total);
    }
 
    /// <summary>
    /// 獲取表的總數
    /// </summary>
    /// <param name="tableName">表的名稱</param>
    /// <param name="fields">條件</param>
    /// <returns>返回記錄數</returns>
    static int GetTotal(string tableName, FieldParam[] fields)
    {
        string whereCondition = GetCondition(fields);
        string sqlSentece = string.Format(" select count(*) from {0} {1} ", tableName, whereCondition);
        return string.Format("{0}", DBAccess.ExecuteScalar(sqlSentece)).ConvertTo<int>();
    }
 
    /// <summary>
    /// 獲取 T 表中記錄集合
    /// </summary>
    /// <typeparam name="T">表的Model類</typeparam>
    /// <param name="source">類的變量</param>
    /// <param name="fields">條件字段</param>
    /// <param name="total">當前表中記錄總數</param>
    /// <returns>返回IList集合</returns>
    public static IList<T> ToList<T>(this T source, FieldParam[] fields, out int total) where T : new()
    {
        return ToList<T>(source, fields, null, out total);
    }
 
    /// <summary>
    /// 獲取 T 表中記錄集合
    /// </summary>
    /// <typeparam name="T">表的Model類</typeparam>
    /// <param name="source">類的變量</param>
    /// <param name="fields">條件字段</param>
    /// <param name="sorted">排序</param>
    /// <param name="total">當前表中記錄總數</param>
    /// <returns>返回IList集合</returns>
    public static IList<T> ToList<T>(this T source, FieldParam[] fields, SortedParam[] sorted, out int total) where T : new()
    {
        string table = typeof(T).Name;
        string sqlSentence = string.Format("select * from {0} {1} {2}", table, GetCondition(fields), GetOrderBy(sorted));
        total = GetTotal(table, fields);
        return DataTableToList<T>(sqlSentence);
    }
 
    /// <summary>
    /// 獲取 T 表中記錄集合
    /// </summary>
    /// <typeparam name="T">表的Model類</typeparam>
    /// <param name="source">類的變量</param>
    /// <param name="fields">條件字段</param>
    /// <param name="pageSize">每頁的大小</param>
    /// <param name="pageIndex">當前頁面索引</param>
    /// <param name="total">當前表中記錄總數</param>
    /// <returns>返回IList集合</returns>
    public static IList<T> ToList<T>(this T source, FieldParam[] fields, int pageSize, int pageIndex, out int total) where T : new()
    {
        return ToList<T>(source, fields, null, pageSize, pageIndex, out total);
    }
 
    /// <summary>
    /// 獲取 T 表中記錄集合
    /// </summary>
    /// <typeparam name="T">表的Model類</typeparam>
    /// <param name="source">類的變量</param>
    /// <param name="fields">條件字段</param>
    /// <param name="sorted">排序</param>
    /// <param name="pageSize">每頁的大小</param>
    /// <param name="pageIndex">當前頁面索引</param>
    /// <param name="total">當前表中記錄總數</param>
    /// <returns>返回IList集合</returns>
    public static IList<T> ToList<T>(this T source, FieldParam[] fields, SortedParam[] sorted, int pageSize, int pageIndex, out int total) where T : new()
    {
        string table = typeof(T).Name;
        string sqlSentence = GetSqlSentence(table, fields, sorted, pageSize, pageIndex);
        total = GetTotal(table, fields);
 
        List<String> item = new List<string>();
        item.Add(string.Format("set @count = 0"));
        item.Add(string.Format("set @count = 0"));
        DBAccess.ExecuteNonQuery(item);
        return DataTableToList<T>(sqlSentence);
    }
 
    /// <summary>
    /// 獲取 T 表中記錄集合
    /// </summary>
    /// <typeparam name="T">表的Model類</typeparam>
    /// <param name="source">類的變量</param>
    /// <param name="sorted">排序</param>
    /// <param name="pageSize">每頁的大小</param>
    /// <param name="pageIndex">當前頁面索引</param>
    /// <param name="total">當前表中記錄總數</param>
    /// <returns>返回IList集合</returns>
    public static IList<T> ToList<T>(this T source, SortedParam[] sorted, int pageSize, int pageIndex, out int total) where T : new()
    {
        return ToList<T>(source, null, sorted, pageSize, pageIndex, out total);
    }
 
    /// <summary>
    /// 獲取 T 表中記錄集合
    /// </summary>
    /// <typeparam name="T">表的Model類</typeparam>
    /// <param name="source">類的變量</param>
    /// <param name="sorted">排序</param>
    /// <param name="topSize">獲取表的前幾條記錄</param>
    /// <returns>返回IList集合</returns>
    public static IList<T> ToList<T>(this T source, SortedParam[] sorted, int topSize) where T : new()
    {
        string table = typeof(T).Name;
        string orderBy = GetOrderBy(sorted);
        string sqlSentence = string.Format("SELECT * from {0} {1} ", table, orderBy);
        if (0 < topSize)
        {
            sqlSentence += string.Format(" LIMIT 0,{0} ", topSize);
        }
        return DataTableToList<T>(sqlSentence);
    }
 
    /// <summary>
    /// 獲取 T 表中記錄集合
    /// </summary>
    /// <typeparam name="T">表的Model類</typeparam>
    /// <param name="source">類的變量</param>
    /// <param name="sorted">排序</param>
    /// <returns>返回IList集合</returns>
    public static IList<T> ToList<T>(this T source, SortedParam[] sorted) where T : new()
    {
        return ToList<T>(source,sorted,0);
    }
 
    /// <summary>
    /// 將DataTable轉成 IList
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="sqlSentence"></param>
    /// <returns></returns>
    static IList<T> DataTableToList<T>(string sqlSentence) where T : new()
    {
        var dt = Database.DBAccess.GetDataTable(sqlSentence);
        if (null == dt)
        {
            return null;
        }
        return dt.ToList<T>();
    }
 
    static string GetSqlSentence(string tableName, FieldParam[] fields, SortedParam[] sorted, int pageSize, int pageIndex)
    {
        string _orderBy = GetOrderBy(sorted);
        string sql = string.Format("select * from (");
        sql += string.Format("  SELECT (@count := @count +1) SerialNumber, t.* from {0} t {1} {2}", tableName, GetCondition(fields), _orderBy);
 
        if (0 < pageSize)
        {
            sql += string.Format(" LIMIT 0,{0} ", pageSize * (pageIndex));
        }
        sql += string.Format(") v {0}", _orderBy);
 
        if (0 < pageSize)
        {
            sql += string.Format(" LIMIT {0},{1}", pageSize * (pageIndex - 1), pageSize * (pageIndex));
        }
        return sql;
    }
 
    static string GetCondition(FieldParam[] fields)
    {
        if (null == fields || 0 == fields.Length)
        {
            return null;
        }
        string whereCondtion =
         string.Format(" where {0}",
                string.Join(" and ",
                                    from p in fields
                                    select string.Format("{0} = '{1}'", p.FieldName, p.FieldValue)));
 
        return whereCondtion;
    }
 
    /// <summary>
    ///
    /// </summary>
    /// <param name="fields"></param>
    /// <returns></returns>
    static string GetOrderBy(SortedParam[] fields)
    {
        if (null == fields || 0 == fields.Length)
        {
            return null;
        }
        string whereCondtion =
         string.Format(" order by {0}",
                string.Join(" and ",
                                    from p in fields
                                    select string.Format("{0} {1}", p.FieldName, p.Sorted)));
 
        return whereCondtion;
    }
 
    /// <summary>
    /// 獲取單條記錄
    /// </summary>
    /// <typeparam name="T">表的Model類</typeparam>
    /// <param name="source">類的變量</param>
    /// <param name="fields">條件字段</param>
    /// <returns>返回model類</returns>
    public static T ToModel<T>(this T source, FieldParam[] fields) where T : new()
    {
        string table = typeof(T).Name;
        string sqlSentence = string.Format("select * from {0} {1}", table, GetCondition(fields));
        var dt = Database.DBAccess.GetDataTable(sqlSentence);
        return dt.FirstModel<T>();
    }
 
    /// <summary>
    /// 刪除記錄
    /// </summary>
    /// <typeparam name="T">表的Model類</typeparam>
    /// <param name="source">類的變量</param>
    /// <param name="fields">條件字段</param>
    /// <returns>是否成功 , >0成功；否則失敗。</returns>
    public static int Delete<T>(this  T Source, FieldParam[] fields, ref string errorMessage)
    {
        try
        {
            string tableName = typeof(T).Name;
            string sqlSentence = string.Format("delete from {0} {1} ", tableName, GetCondition(fields));
            var result = DBAccess.ExecuteNonQuery(sqlSentence);
            errorMessage = DBAccess.ErrorMessage;
            return result;
        }
        catch (Exception ee)
        {
            errorMessage = ee.Message;
            return -1;
        }
    }
 
    /// <summary>
    /// 向表中插入記錄
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="source"></param>
    /// <param name="fields">不用進行插入的字符集合</param>
    /// <param name="errorMessage"></param>
    /// <returns></returns>
    public static int Insert<T>(this T source, FieldParam[] fields, ref string errorMessage)
    {
        try
        {
            var tt = typeof(T);
            string sqlSentence = GetInsertSentence<T>(source, fields);
            var result = DBAccess.ExecuteNonQuery(sqlSentence);
            errorMessage = DBAccess.ErrorMessage;
            return result;
        }
        catch (Exception ee)
        {
            errorMessage = ee.Message;
            return -1;
        }
    }
 
    /// <summary>
    /// 編輯，先刪除，然後再進行插入操作，在一個事務裏處理的【 0 成功；其它失敗 】
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="Source"></param>
    /// <param name="fields"></param>
    /// <returns></returns>
    public static int Edit<T>(this T Source, FieldParam[] fields, ref string errorMessage)
    {
        try
        {
            string tableName = typeof(T).Name;
            List<String> item = new List<string>();
            string sqlSentence = string.Format("delete from {0} {1} ", tableName, GetCondition(fields));
            item.Add(sqlSentence);
            sqlSentence = GetInsertSentence<T>(Source, null);
            item.Add(sqlSentence);
 
            var result = DBAccess.ExecuteNonQuery(item);
            errorMessage = DBAccess.ErrorMessage;
            return result;
        }
        catch (Exception ee)
        {
            errorMessage = ee.Message;
            return -1;
        }
    }
 
    /// <summary>
    /// 獲取插入的SQL語句
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="source"></param>
    /// <param name="fields">不用插入的字符</param>
    /// <returns></returns>
    public static string GetInsertSentence<T>(this T source, FieldParam[] fields)
    {
        var tt = typeof(T);
        List<String> fieldNames = new List<String>();
        List<String> fieldValues = new List<String>();
        var piItem = tt.GetProperties();
        foreach (var v in piItem)
        {
            if (v.Name.ToLower().Equals("SerialNumber".ToLower()))
            {
                continue;
            }
            //-->判斷是否存在fields
            if (null != fields && 0 < fields.Length)
            {
                var fp = fields.Where(p => p.FieldName.ToLower().Equals(v.Name.ToLower())).GetFirst<FieldParam>();
                if (null != fp)
                {
                    continue;
                }
            }
            fieldNames.Add(v.Name);
            fieldValues.Add(GetPropertyValue(v, source));
        }
 
        string sql = string.Format("insert into {0} ({1}) values ({2}) ",
            tt.Name,
            string.Join(",", fieldNames),
            string.Join(",", fieldValues));
 
        return sql;
    }
 
    /// <summary>
    /// 獲取屬性的值
    /// </summary>
    /// <param name="pi"></param>
    /// <param name="source"></param>
    /// <returns></returns>
    static string GetPropertyValue(PropertyInfo pi, object source)
    {
        object value = pi.GetValue(source, null);
        string result = string.Format(" '{0}' ", value);
        switch (pi.PropertyType.FullName)
        {
            case "int":
            case "int16":
            case "int32":
            case "int64":
            case "System.UInt16":
            case "System.UInt32":
            case "System.UInt64":
            case "System.Int16":
            case "System.Int32":
            case "System.Int64":
            case "System.Single":
            case "System.Double":
            case "System.decimal":
                result = string.Format(" {0} ", value);
                break;
            case "System.String":
                value = Wrapper.StringReplace(string.Format("{0}", value));
                result = string.Format(" '{0}' ", value);
                break;
            case "System.DateTime":
                var dt = Convert.ToDateTime(value);
                result = string.Format(" STR_TO_DATE('{0}','%Y-%m-%d %H:%i:%s') ", dt.ToString("yyyy-MM-dd HH:mm:ss"));
                break;
        }
        return result;
    }
}