C# 简化生成SQL语句帮助类，只要有“表名”和实体“对象”就能执行增、删、改、查

最新推荐文章于 2022-04-26 16:36:30 发布
最新推荐文章于 2022-04-26 16:36:30 发布
阅读量870 收藏 6
点赞数
分类专栏： ASP.NET代码 SQL代码 文章标签： SQL语句
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/djk8888/article/details/100558869
版权

C# 简化生成SQL语句帮助类，只要有“表名”和实体“对象”就能执行增、删、改、查：

简化生成SQL语句帮助类，负责自动生成sql语句，SqlMaker.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;

namespace StuTests_DAL
{
    /// <summary>
    /// 制造SQL语句字符串的工厂
    /// </summary>
    public class SqlStrFactory
    {
        //public static string ConnStr = string.Empty;//链接字符串，链接不同的数据库，配置于Web.Config中...
        #region 增
        /// <summary>
        /// 直接执行INSERT语句,返回添加条数
        /// </summary>
        /// <param name="sqlStr">INSERT语句</param>
        /// <returns>添加条数</returns>
        public static int INSERT(string sqlStr)
        {
            return ExecuteNonQuery(sqlStr);
        }
        public static int INSERT(string sqlStr, SqlParameter[] sqlparas)
        {
            return ExecuteNonQuery(sqlStr, sqlparas);
        }
        public static int ExecuteNonQuery(string sqlStr)
        {
            return DbHelperSQL.ExecuteNonQuery(sqlStr);
        }
        public static int ExecuteNonQuery(string sqlStr, SqlParameter[] sqlparas)
        {
            return DbHelperSQL.ExecuteNonQuery(sqlStr, sqlparas);
        }
        /// <summary>
        /// 增加一条数据,返回添加条数
        /// </summary>
        /// <typeparam name="T">实体类</typeparam>
        /// <param name="model">实体对象</param>
        /// <param name="TableName">表名</param>
        /// <param name="PrimaryKey">自增长主键(需跳过)</param>
        /// <returns>添加条数</returns>
        public static int INSERT<T>(string TableName, T model, string PrimaryKey = "")
        {
            List<SqlParameter> paralist = new List<SqlParameter>();//Parameter参数
            StringBuilder strSql = new StringBuilder();//SQL语句
            StringBuilder column = new StringBuilder();//列字段
            StringBuilder columnValue = new StringBuilder();//列字段对应的值
            strSql.AppendFormat("INSERT INTO {0}(", TableName);
            foreach (PropertyInfo info in typeof(T).GetProperties())
            {
                PropertyInfo pi = typeof(T).GetProperty(info.Name);
                if (pi.GetValue(model, null) == null)
                    continue;

                if (info.Name.ToLower() != PrimaryKey.ToLower().Replace("[", "").Replace("]", ""))//跳过自增长主键
                {
                    column.AppendFormat(",{0}", info.Name);
                    columnValue.AppendFormat(",@{0}", info.Name);//添加字段
                }
                SqlParameter para = new SqlParameter("@" + info.Name, pi.GetValue(model, null));
                paralist.Add(para);
            }
            strSql.AppendFormat("{0}) VALUES ({1});", Regex.Replace(column.ToString(), "^,", ""), Regex.Replace(columnValue.ToString(), "^,", ""));

            return DbHelperSQL.ExecuteNonQuery(strSql.ToString(), paralist.ToArray());
        }

        #endregion 增

        #region 增(返回新增的主键)
        /// <summary>
        /// 直接执行INSERT语句，返回新ID
        /// insert一条数据，返回自增的id值：insert into table([NAME])values ('名字');Select @@Identity;
        /// </summary>
        /// <param name="sqlStr">INSERT语句</param>
        /// <returns>回新ID</returns>
        public static int INSERT_NewId(string sqlStr)
        {
            return Convert.ToInt32(ExecuteScalar(sqlStr));
        }
        public static int INSERT_NewId(string sqlStr, SqlParameter[] sqlparas)
        {
            return Convert.ToInt32(ExecuteScalar(sqlStr, sqlparas));
        }
        /// <summary>
        /// 增加一条数据,返回新的ID
        /// </summary>
        /// <typeparam name="T">实体类</typeparam>
        /// <param name="model">实体对象</param>
        /// <param name="TableName">表名</param>
        /// <returns>新的ID</returns>
        public static int INSERT_NewId<T>(string TableName, T model)
        {
            List<SqlParameter> paralist = new List<SqlParameter>();//Parameter参数
            StringBuilder strSql = new StringBuilder();//SQL语句
            StringBuilder column = new StringBuilder();//列字段
            StringBuilder columnvalue = new StringBuilder();//列字段对应的值
            strSql.AppendFormat("INSERT INTO {0}(", TableName);
            foreach (PropertyInfo info in typeof(T).GetProperties())
            {
                PropertyInfo pi = typeof(T).GetProperty(info.Name);
                if (pi.GetValue(model, null) == null)
                    continue;

                column.AppendFormat(",{0}", info.Name);
                columnvalue.AppendFormat(",@{0}", info.Name);//添加字段

                SqlParameter para = new SqlParameter("@" + info.Name, pi.GetValue(model, null));
                paralist.Add(para);
            }
            strSql.AppendFormat("{0}) VALUES ({1});SELECT @@Identity;", Regex.Replace(column.ToString(), "^,", ""), Regex.Replace(columnvalue.ToString(), "^,", ""));

            var obj = DbHelperSQL.ExecuteScalar(strSql.ToString(), paralist.ToArray());
            return int.Parse(obj.ToString());
        }
        /// <summary>
        /// 执行查询，并返回查询所返回的结果集中第一行的第一列
        /// </summary>
        /// <param name="sqlStr"></param>
        /// <returns></returns>
        public static object ExecuteScalar(string sqlStr)
        {
            return DbHelperSQL.ExecuteScalar(sqlStr);
        }
        public static object ExecuteScalar(string sqlStr, SqlParameter[] sqlparas)
        {
            return DbHelperSQL.ExecuteScalar(sqlStr, sqlparas);
        }
        #endregion

        #region 删
        /// <summary>
        /// 直接执行DELETE语句,返回删除条数
        /// </summary>
        /// <param name="sqlStr">DELETE语句</param>
        /// <returns>删除条数</returns>
        public static int DELETE(string sqlStr)
        {
            return ExecuteNonQuery(sqlStr);
        }
        public static int DELETE(string sqlStr, SqlParameter[] sqlparas)
        {
            return ExecuteNonQuery(sqlStr, sqlparas);
        }
        /// <summary>
        /// 删除数据,返回删除条数
        /// </summary>
        /// <param name="TableName"></param>
        /// <param name="strWhere"></param>
        /// <returns>删除条数</returns>
        public static int DELETE(string TableName, string strWhere)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.AppendFormat("DELETE FROM {0}", TableName);
            if (!string.IsNullOrEmpty(strWhere))
            {
                strSql.Append(" WHERE " + strWhere);
            }

            int rows = DbHelperSQL.ExecuteNonQuery(strSql.ToString());
            return rows;
        }
        #endregion 删

        #region 改
        /// <summary>
        /// 直接执行UPDATE语句，返回修改条数
        /// </summary>
        /// <param name="sqlStr">UPDATE语句</param>
        /// <returns>修改条数</returns>
        public static int UPDATE(string sqlStr)
        {
            return ExecuteNonQuery(sqlStr);
        }
        public static int UPDATE(string sqlStr, SqlParameter[] sqlparas)
        {
            return ExecuteNonQuery(sqlStr, sqlparas);
        }
        /// <summary>
        /// 更新一条数据，返回修改条数
        /// </summary>
        /// <typeparam name="T">实体类</typeparam>
        /// <param name="model">实体对象</param>
        /// <param name="strWhere">条件</param>
        /// <param name="TableName">表名</param>   
        /// <param name="TableName"></param>
        /// <returns>修改条数</returns>
        public static int UPDATE<T>(string TableName, string strWhere, T model)
        {
            try
            {
                List<SqlParameter> paralist = new List<SqlParameter>();//Parameter参数
                StringBuilder strSql = new StringBuilder();
                StringBuilder column = new StringBuilder();
                strSql.AppendFormat("UPDATE {0} SET ", TableName);
                foreach (PropertyInfo info in typeof(T).GetProperties())
                {
                    PropertyInfo pi = typeof(T).GetProperty(info.Name);
                    if (pi.GetValue(model, null) == null) continue;

                    column.AppendFormat(",{0}=@{0}", info.Name);//添加字段
                    SqlParameter para = new SqlParameter("@" + info.Name, pi.GetValue(model, null));
                    para.Value = pi.GetValue(model, null);//设置SqlParameter对应Value
                    paralist.Add(para);
                }
                strSql.Append(Regex.Replace(column.ToString(), "^,", ""));//去掉第一个,
                if (!string.IsNullOrEmpty(strWhere))
                    strSql.AppendFormat(" WHERE {0}", strWhere);

                int rows = DbHelperSQL.ExecuteNonQuery(strSql.ToString(), paralist.ToArray());
                return rows;
            }
            catch
            {
                return 0;
            }
        }
        #endregion 改

        #region 查
        /// <summary>
        /// 直接执行SELECT语句
        /// </summary>
        /// <param name="strSql">SELECT语句</param>
        /// <returns>数据集</returns>
        public static DataTable SELECT(string strSql)
        {
            return ExecuteReader(strSql);
        }
        public static DataTable SELECT(string strSql, SqlParameter[] sqlparas)
        {
            return ExecuteReader(strSql, sqlparas);
        }
        public static DataTable ExecuteReader(string strSql)
        {
            return DbHelperSQL.ExecuteReader(strSql);
        }
        public static DataTable ExecuteReader(string strSql, SqlParameter[] sqlparas)
        {
            return DbHelperSQL.ExecuteReader(strSql, sqlparas);
        }
        /// <summary>
        /// 获得N行数据,带条件,带排序(单表查询)
        /// </summary>
        /// <param name="tableName">*表名</param>
        /// <param name="Top">N条</param>
        /// <param name="fldName">列</param>
        /// <param name="strWhere">查询条件</param>
        /// <param name="orderBy">排序字符串</param>
        /// <returns>结果集合</returns>
        public static DataTable SELECT(string tableName, int Top = 0, string fldName = "", string strWhere = "", string orderBy = "")
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("SELECT ");
            if (Top > 0)
            {
                strSql.Append(" TOP " + Top);
            }
            if (!string.IsNullOrEmpty(fldName))
            {
                strSql.Append(fldName + " FROM " + tableName);
            }
            else
            {
                strSql.Append(" * FROM " + tableName);
            }
            if (!string.IsNullOrEmpty(strWhere))
            {
                strSql.Append(" WHERE " + strWhere);
            }
            if (!string.IsNullOrEmpty(orderBy))
            {
                strSql.Append(" ORDER BY " + orderBy);
            }

            DataTable dt = DbHelperSQL.ExecuteReader(strSql.ToString());
            return dt;
        }
        /// <summary>
        /// 聚合查询
        /// </summary>
        /// <param name="tableName">TABLE</param>
        /// <param name="top">TOP</param>
        /// <param name="fldName">*</param>
        /// <param name="strWhere">WHERE</param>
        /// <param name="orderBy">ORDER BY</param>
        /// <param name="groupBy">GROUP BY</param>
        /// <param name="having">HAVING</param>
        /// <returns></returns>
        public static DataTable GROUP_BY_HAVING(string tableName, int top = 0, string fldName = "", string strWhere = "", string orderBy = "", string groupBy = "", string having = "")
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("SELECT ");
            if (top > 0)
            {
                strSql.Append(" TOP " + top);
            }
            if (!string.IsNullOrEmpty(fldName))
            {
                strSql.Append(fldName + " FROM " + tableName);
            }
            else
            {
                strSql.Append(" * FROM " + tableName);
            }
            if (!string.IsNullOrEmpty(strWhere))
            {
                strSql.Append(" WHERE " + strWhere);
            }
            if (!string.IsNullOrEmpty(groupBy))
            {
                strSql.Append(" GROUP BY " + groupBy);
            }
            if (!string.IsNullOrEmpty(having))
            {
                strSql.Append(" HAVING " + having);
            }
            if (!string.IsNullOrEmpty(orderBy))
            {
                strSql.Append(" ORDER BY " + orderBy);
            }

            DataTable dt = DbHelperSQL.ExecuteReader(strSql.ToString());
            return dt;
        }
        /// <summary>
        /// 获得分页数据(单表查询)
        /// </summary>
        /// <param name="tableName">*表名</param>
        /// <param name="fldOrder">*排序字段</param>
        /// <param name="fldName">显示字段</param>
        /// <param name="strWhere">查询条件</param>
        /// <param name="PageSize">每页条数</param>
        /// <param name="PageIndex">页码</param>
        /// <returns></returns>
        public static DataTable GetPageData(string tableName, string fldOrder, string fldName = "", string strWhere = "", int PageSize = 10, int PageIndex = 1)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.AppendLine("DECLARE @PageSize INT;");
            strSql.AppendLine("DECLARE @PageIndex INT;");
            strSql.AppendLine("SET @PageSize=" + PageSize + ";");
            strSql.AppendLine("SET @PageIndex=" + PageIndex + ";");

            strSql.Append("SELECT ");
            if (!string.IsNullOrEmpty(fldName))
            {
                strSql.Append(fldName + " FROM (");
            }
            else
            {
                strSql.Append(" * FROM (");
            }
            strSql.AppendFormat("SELECT ROW_NUMBER() OVER(ORDER BY {0}) rownum,", fldOrder);
            if (!string.IsNullOrEmpty(fldName))
            {
                strSql.Append(fldName + " FROM " + tableName);
            }
            else
            {
                strSql.Append(" * FROM " + tableName);
            }
            if (!string.IsNullOrEmpty(strWhere))
            {
                strSql.AppendLine(" WHERE " + strWhere);
            }
            strSql.AppendLine(")a");
            strSql.AppendLine("WHERE rownum > @PageSize * (@PageIndex - 1) AND rownum <= @PageSize * @PageIndex;");

            DataTable dt = DbHelperSQL.ExecuteReader(strSql.ToString());
            return dt;
        }
        /// <summary>
        /// 根据条件获取数量
        /// </summary>
        /// <param name="TableName"></param>
        /// <param name="strWhere"></param>
        /// <returns></returns>
        public static int GetCount(string TableName, string strWhere = "")
        {
            StringBuilder strSql = new StringBuilder();
            strSql.AppendFormat("SELECT COUNT(*) FROM {0}", TableName);
            if (!string.IsNullOrEmpty(strWhere))
            {
                strSql.AppendFormat(" WHERE {0}", strWhere);
            }
            object obj = GetSingle(strSql.ToString());
            if (obj == null)
            {
                return 0;
            }
            else
            {
                return Convert.ToInt32(obj);
            }
        }
        /// <summary>
        /// 获取最大ID
        /// </summary>
        /// <param name="TableName">*表名</param>
        /// <param name="columnname">*列名</param>
        /// <param name="strWhere">条件</param>
        /// <returns>最大值</returns>
        public static int GetMaxID(string TableName, string columnname, string strWhere = "")
        {
            StringBuilder strSql = new StringBuilder();
            strSql.AppendFormat("SELECT MAX({0}) FROM {1}", columnname, TableName);
            if (!string.IsNullOrEmpty(strWhere)) strSql.AppendFormat(" WHERE {0}", strWhere);

            object obj = GetSingle(strSql.ToString());
            try
            {
                if (obj == null)
                {
                    return 0;
                }
                else
                {
                    return Convert.ToInt32(obj);
                }
            }
            catch
            {
                return 0;
            }
        }
        /// <summary>
        /// 获取新的ID(最大ID+1)
        /// </summary>
        /// <param name="TableName">*表名</param>
        /// <param name="columnname">*列名</param>
        /// <param name="strWhere">条件</param>
        /// <returns></returns>
        public static int GetNewID(string TableName, string columnname, string strWhere = "")
        {
            int MaxID = GetMaxID(TableName, columnname, strWhere);
            return MaxID + 1;
        }
        /// <summary>
        /// 是否存在该条件记录
        /// </summary>
        /// <param name="strWhere"></param>
        /// <param name="TableName"></param>
        /// <returns></returns>
        public static bool IsExists(string TableName, string strWhere = "")
        {
            StringBuilder strSql = new StringBuilder();
            strSql.AppendFormat("SELECT COUNT(1) FROM {0}", TableName);
            if (!string.IsNullOrEmpty(strWhere))
            {
                strSql.Append(" WHERE " + strWhere);
            }
            return Exists(strSql.ToString());
        }
        #endregion 查

        #region 私有方法
        private static bool Exists(string strSql)
        {
            object obj = GetSingle(strSql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        private static bool Exists(string strSql, params SqlParameter[] cmdParms)
        {
            object obj = GetSingle(strSql, cmdParms);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        public static object GetSingle(string strSql)
        {
            return DbHelperSQL.ExecuteScalar(strSql);
        }
        public static object GetSingle(string strSql, params SqlParameter[] cmdParms)
        {
            return DbHelperSQL.ExecuteScalar(strSql, cmdParms);
        }
        #endregion

        #region 公用方法
        /// <summary>
        /// 判断是否存在某表的某个字段
        /// </summary>
        /// <param name="columnName">列名称</param>
        /// <param name="TableName">表名称</param>
        /// <returns>是否存在</returns>
        public static bool ColumnExists(string columnName, string tableName)
        {
            string sql = "select count(1) from syscolumns where [id]=object_id('" + tableName + "') and [name]='" + columnName + "'";
            object res = GetSingle(sql);
            if (res == null)
            {
                return false;
            }
            return Convert.ToInt32(res) > 0;
        }
        /// <summary>
        /// 表是否存在
        /// </summary>
        /// <param name="TableName"></param>
        /// <returns></returns>
        public static bool TabExists(string tableName)
        {
            string strsql = "select count(*) from sysobjects where id = object_id(N'[" + tableName + "]') and OBJECTPROPERTY(id, N'IsUserTable') = 1";
            //string strsql = "SELECT count(*) FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[" + TableName + "]') AND type in (N'U')";
            object obj = GetSingle(strsql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        #endregion
    }
}

SqlHelper类，负责执行生成的sql语句，DbHelperSQL.cs

using System;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;

namespace SqlHelper
{
    /// <summary>
    /// SqlHelper类
    /// </summary>
    public class DbHelperSQL
    {
        public static readonly string ConnStr = ConfigurationManager.ConnectionStrings["connectionStr"].ConnectionString;
        private static SqlCommand cmd = null;
        private static SqlConnection conn = new SqlConnection(ConnStr);
        private static SqlDataReader sdr = null;

        private static SqlConnection Getconn()
        {
            if (conn.State == ConnectionState.Closed)
            {
                conn.Open();
            }
            return conn;
        }
        /// <summary>
        /// 增|删|改 INSERT|DELETE|UPDATE
        /// </summary>
        public static int ExecuteNonQuery(String sqlStr)
        {
            int res;
            cmd = new SqlCommand(sqlStr, Getconn());
            res = cmd.ExecuteNonQuery();
            return res;
        }
        /// <summary>
        /// 增|删|改 INSERT|DELETE|UPDATE
        /// </summary>
        public static int ExecuteNonQuery(string sqlStr, SqlParameter[] sqlparas)
        {
            int res;
            cmd = new SqlCommand(sqlStr, Getconn());
            cmd.Parameters.AddRange(sqlparas);
            res = cmd.ExecuteNonQuery();
            conn.Close();
            return res;
        }
        /// <summary>
        /// 查 SELECT
        /// </summary>
        public static DataTable ExecuteReader(string sqlStr)
        {
            DataTable dt = new DataTable();
            try
            {
                cmd = new SqlCommand(sqlStr, Getconn());
                using (sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                {
                    dt.Load(sdr);
                }
            }
            catch { }
            return dt;
        }
        /// <summary>
        /// 查 SELECT
        /// </summary>
        public static DataTable ExecuteReader(string sqlStr, SqlParameter[] sqlparas)
        {
            DataTable dt = new DataTable();
            cmd = new SqlCommand(sqlStr, Getconn());
            cmd.Parameters.AddRange(sqlparas);
            using (sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
            {
                dt.Load(sdr);
            }
            return dt;
        }
        /// <summary>
        /// 执行语句，并返回查询所返回的结果集中第一行的第一列，
        /// 如：insert一条数据，返回自增的id值：insert into table([NAME])values ('名字');Select @@Identity;
        /// </summary>
        public static object ExecuteScalar(string sqlStr)
        {
            object res;
            cmd = new SqlCommand(sqlStr, Getconn());
            res = cmd.ExecuteScalar();
            conn.Close();
            return res;
        }
        /// <summary>
        /// 执行语句，并返回查询所返回的结果集中第一行的第一列，
        /// 如：insert一条数据，返回自增的id值：insert into table([NAME])values ('名字');Select @@Identity;
        /// </summary>
        public static object ExecuteScalar(string sqlStr, SqlParameter[] sqlparas)
        {
            object res;
            cmd = new SqlCommand(sqlStr, Getconn());
            cmd.Parameters.AddRange(sqlparas);
            res = cmd.ExecuteScalar();
            conn.Close();
            return res;
        }     
    }
}

本文配套源码DEMO下载地址：https://download.csdn.net/download/djk8888/11686101

 

djk8888
关注
专栏目录
C#SQL插入语句生成
04-08
用C#实现SQL数据库中表格内容插入语句的txt的生成。
c# 构造sql语句
weixin_33795743的博客
07-04 178
String sql = String.Format(                "SELECT * FROM {0} WHERE {1} IN (SELECT {1} FROM {2} WHERE policyid={3})",                maintable, key, policytable, policyid); 之前都是一段段来做，原来这么便捷的方法 ...
C#使用反射根据实体生成sql语句（添加和批量添加）
sunshine_qqr的博客
08-24 3129
/// &lt;summary&gt;     /// 对象拼接sql语句     /// &lt;/summary&gt;     public class SqlBuilderHelper     {         /// &lt;summary&gt;         /// Insert SQL语句         /// &lt;/summary&gt;         /// &lt...
自动生成SQL语句_C#_sql_
09-30
自动生成SQL语句，根据实体结构，C#编写
根据SQLServer数据表生成C#实体类。生成数据库模型.zip
05-18
本压缩包"根据SQLServer数据表生成C#实体类"提供了相关的工具和源码，旨在帮助开发者快速创建与数据库表结构相对应的C#类。SQLHelper是一个常见的辅助类，用于简化SQL操作，避免了大量的硬编码SQL语句，使得数据库...
C#根据表生成实体类文件
最新发布
04-13
本教程将详细讲解如何在C#中根据数据库表自动生成实体类文件，以便于简化数据操作，提高开发效率。 首先，我们需要理解什么是实体类。在对象关系映射（ORM）框架中，实体类代表了数据库中的表，它们是程序与数据库...
Oracle数据库表生成C#实体类
10-30
一旦实体类生成，就可以在C#项目中使用它们，结合Entity Framework或其他ORM工具，轻松地进行数据的增删改查操作。例如，使用Entity Framework的DbContext，可以创建一个Repository类来处理数据库操作： ```csharp ...
C#自动生成数据库以及实体类代码和操作插件
09-12
本项目“C#自动生成数据库以及实体类代码和操作插件”旨在简化数据库与应用程序之间的交互，通过自动化代码生成，提高开发效率。 首先，我们要理解这个工具的核心功能。它允许开发者导入一个项目，并在Form1界面中...
SqlServer：使用IN（）子句C＃进行参数化查询
04-07
参数化查询是防止SQL注入攻击的有效方法，因为它将用户输入的数据与查询结构分离，避免了直接拼接字符串生成SQL语句。 在C#中，我们可以使用ADO.NET库来实现这个功能。ADO.NET提供了SqlConnection、SqlCommand、Sql...
自动生成SQL语句C#代码
12-15
自动生成增、删、改、查的SQL语句。 C#写的（目前只适用于SQL2000）
C#封装MySql数据库操作，反射动态生成SQL语句
08-02
C#封装MySql数据库操作，反射动态生成SQL语句。看程序前，最好请先看看里面的“数据库说明”文档，不然可能会一头雾水。 这是我第一次写数据库的程序，我知道有很多地方写得不好，希望能得到大家的指点。我的联系方式，邮箱：tqwboy@163.com；QQ：55346161（请注明CSDN）；blog：tqwboy.blog.163.com 欢迎“骚扰”。
(SQL、C#开发人员辅助工具) 由SQL表结构生成C#类及常用的查询、编辑、删除和添加SQL语句
01-28
由SQL表结构生成C#类及常用的查询、编辑、删除和添加SQL语句.
C#根据模型动态生成SQL
02-28
根据模型自动生成SQL语句，加快开发的速度，方便理解EF的原理，代码简单易懂。
C#代码生成器（包括T-sql语句，和实体类代码）
01-07
利用反射技术实现通过实体类生成DLL文件通过发射动态加载技术将实体类加载进来，并且读出所有公共属性转化成T-sql语句，并且还可以通过现有的数据库表动态生成实体类代码！
C#反射获取实体类对象属性拼接生成增删改SQL语句完整实例源码
LilyCoder的博客
04-26 1486
1.创建一个SQL生成帮助类分别写出以下增删改三个公共方法 数据插入方法 public static int Save(object obj) { int n = 0; using (SqlConnection conn = new SqlConnection(connectionString)) { conn.Open(); StringBuilder
C#生成sql分页语句
weixin_30950237的博客
08-22 149
/// <summary> /// 生成分页语句 /// </summary> /// <param name="tableName">数据表名</param> /// <param name="whereString">Where后面的条件</param> ...
C# 根据反射和特性实现ORM 映射[学习]
weixin_33922672的博客
08-07 180
  （一）关于反射 什么是反射？ 反射就是在运行时，动态获取对象信息的方法。比如：运行时获得对象有哪些属性，方法，委托等。 反射的作用？ 能够实现运行时，动态调用对象的方法，以及动态设置、获取属性值等。 反射的示例： using System; u...
C#中一套生成sql条件的类
程序员天空
05-23 1037
    在进行sql查询的时候，有时候要进行很多条件限制，自己来拼写SQLwhere条件容易出错，而且判断条件复杂，后期维护困难，基于这个原因我在一个小 项目中写了一套生成sql条件的类。总共包括一个Condition类，与两个枚举型类型（LogicOper，CompareOper） 代码如下：    public class Condition    ...{        static
C#实战：SQLServer数据库增删改查操作代码示例
在本文档中，我们将深入探讨如何使用C#编程语言与SQL Server数据库进行有效的增删改查操作。首先，我们理解C#访问SQL Server的核心步骤，这些步骤包括建立数据库连接、构造SQL语句、执行命令以及处理结果。 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值