Ado.net

于 2022-04-26 23:34:35 发布
阅读量256 收藏
点赞数
分类专栏： C# 文章标签： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45701634/article/details/124440032
版权 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SqlClient;
using System.Data;


namespace DAL
{
    /// <summary>
    /// DBHelper 的摘要说明
    /// </summary>
    public class DBHelper : System.IDisposable
    {
        public DBHelper()
        {

        }
        public static readonly string connString = System.Configuration.ConfigurationManager.ConnectionStrings["connString"].ConnectionString;

        /// <summary>
        /// 返回SqlServer连接接口
        /// </summary>
        /// <returns></returns>
        public static SqlConnection SqlCon()
        {
            SqlConnection con = new SqlConnection(connString);
            return con;
        }

        public static int ExecuteNonQuery(SqlTransaction tran, string cmdText, SqlParameter[] parms, CommandType cmdtype)
        {
            int retVal = 0;

            SqlCommand cmd = new SqlCommand(cmdText);
            cmd.Connection = tran.Connection;
            cmd.Transaction = tran;
            cmd.CommandType = cmdtype;
            cmd.CommandTimeout = 600;

            if (parms != null)
            {
                //添加参数
                foreach (SqlParameter parm in parms)
                {
                    cmd.Parameters.Add(parm);
                }
            }

            retVal = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();

            return retVal;
        }

        /// <summary>
        /// 2005.11.21 
        /// </summary>
        /// <param name="tran"></param>
        /// <param name="cmdText"></param>
        /// <returns></returns>
        public static int ExecuteNonQuery(SqlTransaction tran, string cmdText)
        {
            int retVal = 0;

            SqlCommand cmd = new SqlCommand(cmdText);
            cmd.Connection = tran.Connection;
            cmd.Transaction = tran;
            cmd.CommandTimeout = 600;

            retVal = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return retVal;
        }

        /// <summary>
        /// 不限时操作
        /// </summary>
        /// <param name="cmdText"></param>
        /// <param name="parms"></param>
        /// <param name="cmdtype"></param>
        /// <returns></returns>
        public static int ExecuteNonQueryByNoTimeout(string cmdText, SqlParameter[] parms, CommandType cmdtype)
        {
            int retVal;
            using (SqlConnection conn = new SqlConnection(connString))
            {
                SqlCommand cmd = new SqlCommand(cmdText, conn);
                cmd.CommandType = cmdtype;
                cmd.CommandTimeout = 0;
                cmd.Parameters.Clear();
                if (parms != null)
                {
                    //添加参数
                    foreach (SqlParameter spa in parms)
                    {
                        cmd.Parameters.Add(spa);
                    }
                }

                conn.Open();
                retVal = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                conn.Close();
                conn.Dispose();
            }

            return retVal;
        }

        public static int ExecuteNonQuery(string cmdText, SqlParameter[] parms, CommandType cmdtype)
        {
            int retVal;
            try
            {
                using (SqlConnection conn = new SqlConnection(connString))
                {
                    SqlCommand cmd = new SqlCommand(cmdText, conn);
                    cmd.CommandType = cmdtype;
                    cmd.CommandTimeout = 600;
                    cmd.Parameters.Clear();
                    if (parms != null)
                    {
                        //添加参数
                        foreach (SqlParameter spa in parms)
                        {
                            cmd.Parameters.Add(spa);
                        }
                        // cmd.Parameters.AddRange(parms);
                    }

                    conn.Open();
                    retVal = cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                    conn.Close();
                    conn.Dispose();
                }
            }
            catch (Exception ex)
            {
                retVal = -1;

            }
            finally
            { 
            
            }

            return retVal;
        }

        public static int ExecuteNonQuery(string cmdText, SqlParameter parms, CommandType cmdtype)
        {
            int retVal;
            try
            {
                using (SqlConnection conn = new SqlConnection(connString))
                {
                    SqlCommand cmd = new SqlCommand(cmdText, conn);
                    cmd.CommandType = cmdtype;

                    cmd.Parameters.Clear();
                    cmd.CommandTimeout = 600;
                    if (parms != null)
                    {
                        //添加参数
                        cmd.Parameters.Add(parms);
                    }

                    conn.Open();
                    retVal = cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                    conn.Close();
                    conn.Dispose();
                }
            }
            catch (Exception ex)
            {
                retVal = -1;
            }

            return retVal;
        }


        public static int ExecuteNonQuery(string cmdText, CommandType cmdtype)
        {
            int retVal;

            using (SqlConnection conn = new SqlConnection(connString))
            {
                SqlCommand cmd = new SqlCommand(cmdText, conn);
                cmd.CommandType = cmdtype;

                cmd.Parameters.Clear();
                conn.Open();
                retVal = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                cmd.CommandTimeout = 600;
                conn.Close();
                conn.Dispose();
            }

            return retVal;
        }


        public static int ExecuteNonQuery(string cmdText)
        {
            int retVal;

            using (SqlConnection conn = new SqlConnection(connString))
            {
                SqlCommand cmd = new SqlCommand(cmdText, conn);
                cmd.CommandType = CommandType.Text;

                conn.Open();
                cmd.Parameters.Clear();
                cmd.CommandTimeout = 600;
                retVal = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                conn.Close();
                conn.Dispose();
            }

            return retVal;
        }


        public static object ExecuteScalar(SqlTransaction tran, string cmdText, SqlParameter[] parms, CommandType cmdtype)
        {
            object retVal;

            SqlCommand cmd = new SqlCommand(cmdText);
            cmd.Connection = tran.Connection;
            cmd.Transaction = tran;
            cmd.CommandType = cmdtype;
            cmd.CommandTimeout = 600;
            cmd.Parameters.Clear();
            if (parms != null)
            {
                //添加参数
                cmd.Parameters.AddRange(parms);
            }

            retVal = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return retVal;
        }

        /// <summary>
        /// 空参数方法
        /// </summary>
        /// <param name="tran"></param>
        /// <param name="cmdText"></param>
        /// <param name="cmdtype"></param>
        /// <returns></returns>
        public static object ExecuteScalar(SqlTransaction tran, string cmdText, CommandType cmdtype)
        {
            object retVal;

            SqlCommand cmd = new SqlCommand(cmdText);
            cmd.Connection = tran.Connection;
            cmd.Transaction = tran;
            cmd.CommandType = cmdtype;
            cmd.CommandTimeout = 600;
            retVal = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return retVal;
        }

        public static object ExecuteScalar(SqlTransaction tran, string cmdText, SqlParameter parms, CommandType cmdtype)
        {
            object retVal;

            SqlCommand cmd = new SqlCommand(cmdText);
            cmd.Connection = tran.Connection;
            cmd.Transaction = tran;
            cmd.CommandType = cmdtype;
            cmd.CommandTimeout = 600;
            cmd.Parameters.Clear();

            if (parms != null)
            {
                //添加参数
                cmd.Parameters.Add(parms);
            }

            retVal = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return retVal;
        }


        public static object ExecuteScalar(string cmdText, SqlParameter[] parms, CommandType cmdtype)
        {
            object retVal;

            using (SqlConnection conn = new SqlConnection(connString))
            {


                SqlCommand cmd = new SqlCommand(cmdText, conn);
                cmd.CommandType = cmdtype;
                cmd.Parameters.Clear();
                cmd.CommandTimeout = 600;
                if (parms != null)
                {
                    //添加参数                                                                                      
                    foreach (SqlParameter parm in parms)
                    {
                        cmd.Parameters.Add(parm);
                    }
                }
                conn.Open();
                retVal = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                conn.Close();
                conn.Dispose();
            }

            return retVal;
        }

        public static object ExecuteScalar(string cmdText, SqlParameter parm, CommandType cmdtype)
        {
            object retVal;

            using (SqlConnection conn = new SqlConnection(connString))
            {
                SqlCommand cmd = new SqlCommand(cmdText, conn);
                cmd.CommandType = cmdtype;
                cmd.CommandTimeout = 600;
                cmd.Parameters.Clear();
                if (parm != null)
                {
                    //添加参数
                    cmd.Parameters.Add(parm);
                }

                conn.Open();
                retVal = cmd.ExecuteScalar();
                conn.Close();
                conn.Dispose();
            }

            return retVal;
        }


        public static object ExecuteScalar(string cmdText, CommandType cmdtype)
        {
            object retVal;

            using (SqlConnection conn = new SqlConnection(connString))
            {
                SqlCommand cmd = new SqlCommand(cmdText, conn);
                cmd.CommandType = cmdtype;
                cmd.CommandTimeout = 600;
                conn.Open();
                retVal = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                conn.Close();
                conn.Dispose();
            }

            return retVal;
        }


        public static object ExecuteScalar(string cmdText)
        {
            object retVal;

            using (SqlConnection conn = new SqlConnection(connString))
            {
                SqlCommand cmd = new SqlCommand(cmdText, conn);
                cmd.CommandType = CommandType.Text;
                cmd.CommandTimeout = 600;
                conn.Open();
                retVal = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                conn.Close();
                conn.Dispose();
            }

            return retVal;
        }

        //返回一个数据读取器
        public static SqlDataReader ExecuteReader(string cmdText, SqlParameter[] parms, CommandType cmdtype)
        {
            SqlDataReader reader;

            SqlConnection conn = new SqlConnection(connString);

            SqlCommand cmd = new SqlCommand(cmdText, conn);
            cmd.CommandType = cmdtype;
            cmd.CommandTimeout = 60;

            if (parms != null)
            {
                //添加参数
                foreach (SqlParameter parm in parms)
                {
                    cmd.Parameters.Add(parm);
                }
            }
            conn.Open();
            reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            cmd.Parameters.Clear();

            return reader;
        }

        public static SqlDataReader ExecuteReader(string cmdText, SqlParameter parms, CommandType cmdtype)
        {
            SqlDataReader reader;

            SqlConnection conn = new SqlConnection(connString);

            SqlCommand cmd = new SqlCommand(cmdText, conn);
            cmd.CommandType = cmdtype;
            cmd.CommandTimeout = 60;
            if (parms != null)
            {
                //添加参数
                cmd.Parameters.Add(parms);
            }

            conn.Open();
            reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            cmd.Parameters.Clear();
            return reader;
        }


        public static SqlDataReader ExecuteReader(string cmdText, CommandType cmdtype)
        {
            SqlDataReader reader;

            SqlConnection conn = new SqlConnection(connString);
            SqlCommand cmd = new SqlCommand(cmdText, conn);
            cmd.CommandType = cmdtype;
            cmd.CommandTimeout = 60;
            conn.Open();
            reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            cmd.Parameters.Clear();
            return reader;
        }


        public static SqlDataReader ExecuteReader(string cmdText)
        {
            SqlDataReader reader;

            SqlConnection conn = new SqlConnection(connString);
            SqlCommand cmd = new SqlCommand(cmdText, conn);
            cmd.CommandType = CommandType.Text;
            cmd.CommandTimeout = 60;
            conn.Open();
            reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            cmd.Parameters.Clear();
            return reader;
        }


        public static SqlDataReader ExecuteReader(SqlTransaction tran, string cmdText, SqlParameter[] parms, CommandType cmdtype)
        {

            SqlDataReader reader;
            SqlCommand cmd = new SqlCommand(cmdText);
            cmd.Connection = tran.Connection;
            cmd.Transaction = tran;
            cmd.CommandType = cmdtype;
            cmd.CommandTimeout = 600;

            if (parms != null)
            {
                //添加参数
                foreach (SqlParameter parm in parms)
                {
                    cmd.Parameters.Add(parm);
                }
            }
            reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            cmd.Parameters.Clear();
            return reader;
        }


        public static DataTable ExecuteDataTable(string cmdText, SqlParameter[] parms, CommandType cmdtype)
        {
            DataTable dt = new DataTable();

            SqlConnection conn = new SqlConnection(connString);
            SqlDataAdapter apt = new SqlDataAdapter(cmdText, conn);

            apt.SelectCommand.CommandType = cmdtype;
            apt.SelectCommand.CommandTimeout = 600;

            if (parms != null)
            {
                //添加参数
                foreach (SqlParameter parm in parms)
                {
                    apt.SelectCommand.Parameters.Add(parm);
                }
            }

            apt.Fill(dt);
            apt.SelectCommand.Parameters.Clear();
            apt.Dispose();
            conn.Close();
            conn.Dispose();
            return dt;
        }

        public static DataTable ExecuteDataTable(SqlTransaction tran, string cmdText, SqlParameter[] parms, CommandType cmdtype)
        {
            DataTable dt = new DataTable();

            SqlConnection conn = tran.Connection;
            SqlDataAdapter apt = new SqlDataAdapter(cmdText, conn);
            apt.SelectCommand.CommandType = cmdtype;
            apt.SelectCommand.CommandTimeout = 600;
            apt.SelectCommand.Transaction = tran;
            apt.SelectCommand.Parameters.Clear();

            if (parms != null)
            {
                //添加参数
                foreach (SqlParameter parm in parms)
                {
                    apt.SelectCommand.Parameters.Add(parm);
                }
            }
            apt.Fill(dt);
            apt.SelectCommand.Parameters.Clear();

            return dt;
        }

        public static SqlDataAdapter ExecuteDataAdapter(string cmdText, CommandType cmdtype)
        {
            SqlConnection conn = new SqlConnection(connString);
            SqlDataAdapter da = new SqlDataAdapter(cmdText, conn);
            da.SelectCommand.CommandType = cmdtype;
            da.SelectCommand.CommandTimeout = 600;
            return da;
        }

        public static DataTable ExecuteDataTable(string cmdText, CommandType cmdtype)
        {
            DataTable dt = new DataTable();


            SqlConnection conn = new SqlConnection(connString);
            SqlDataAdapter apt = new SqlDataAdapter(cmdText, conn);
            apt.SelectCommand.CommandType = cmdtype;
            apt.SelectCommand.CommandTimeout = 600;
            apt.Fill(dt);
            conn.Close();
            conn.Dispose();
            return dt;
        }
        /// <summary>
        /// 根据参数获取数据
        /// </summary>
        /// <param name="cmdText"></param>
        /// <param name="cmdtype"></param>
        /// <returns></returns>
        public static DataTable ExecuteDataTable(string cmdText, CommandType cmdtype, SqlParameter[] spter)
        {
            DataTable dt = new DataTable();


            SqlConnection conn = new SqlConnection(connString);
            SqlDataAdapter apt = new SqlDataAdapter(cmdText, conn);
            apt.SelectCommand.CommandType = cmdtype;
            apt.SelectCommand.CommandTimeout = 600;
            apt.SelectCommand.Parameters.AddRange(spter);//添加参数
            apt.Fill(dt);
            conn.Close();
            conn.Dispose();
            return dt;
        }


        public static DataTable ExecuteDataTable(string cmdText)
        {
            DataTable dt = new DataTable();

            SqlConnection conn = new SqlConnection(connString);
            SqlDataAdapter apt = new SqlDataAdapter(cmdText, conn);
            apt.SelectCommand.CommandType = CommandType.Text;
            apt.SelectCommand.CommandTimeout = 600;
            apt.Fill(dt);
            conn.Close();
            conn.Dispose();
            return dt;
        }

        public static DataTable ExecuteDataTable(SqlTransaction tran, string cmdText)
        {
            DataTable dt = new DataTable();

            SqlConnection conn = tran.Connection;
            SqlDataAdapter apt = new SqlDataAdapter(cmdText, conn);
            apt.SelectCommand.CommandType = CommandType.Text;
            apt.SelectCommand.CommandTimeout = 600;
            apt.SelectCommand.Transaction = tran;
            apt.Fill(dt);
            //conn.Close();
            //conn.Dispose();
            return dt;
        }
        public static SqlParameter GetSqlParameter(string paraName, SqlDbType sqlDbType, SqlParameter para, object obj)
        {
            para = new SqlParameter(paraName, sqlDbType);
            para.Value = obj;
            return para;
        }

        public static SqlParameter GetSqlParameter(string paramName, SqlDbType sqlDbType, object obj)
        {
            SqlParameter para = new SqlParameter(paramName, sqlDbType);
            para.Value = obj;
            return para;
        }


        public static object[] ExecuteNonQuery(string sql, CommandType type, SqlParameter[] inparam, SqlParameter[] outparam)
        {
            using (SqlConnection con = new SqlConnection(connString))
            {
                con.Open();

                SqlCommand cmd = new SqlCommand(sql, con);

                cmd.CommandType = type;
                cmd.CommandTimeout = 600;
                if (outparam != null)
                {
                    for (int i = 0; i < outparam.Length; i++)
                    {
                        cmd.Parameters.Add(outparam[i]);

                        cmd.Parameters[i].Direction = ParameterDirection.Output;
                    }
                }

                if (inparam != null)
                {
                    for (int i = 0; i < inparam.Length; i++)
                    {
                        cmd.Parameters.Add(inparam[i]);
                    }
                }

                cmd.ExecuteNonQuery();

                object[] obj = new object[outparam.Length];

                for (int i = 0; i < outparam.Length; i++)
                {
                    obj[i] = cmd.Parameters[i].Value;
                }

                cmd.Dispose();
                con.Close();
                con.Dispose();

                return obj;
            }
        }

        public static DataSet ExecuteDataSet(string cmdText, SqlParameter[] parms, CommandType cmdtype)
        {
            DataSet ds = new DataSet();

            SqlConnection conn = new SqlConnection(connString);
            SqlDataAdapter apt = new SqlDataAdapter(cmdText, conn);

            apt.SelectCommand.CommandType = cmdtype;
            apt.SelectCommand.CommandTimeout = 600;

            if (parms != null)
            {
                //添加参数
                foreach (SqlParameter parm in parms)
                {
                    apt.SelectCommand.Parameters.Add(parm);
                }
            }

            apt.Fill(ds);
            conn.Close();
            conn.Dispose();
            return ds;
        }



        #region IDisposable 成员

        void IDisposable.Dispose()
        {
            throw new NotImplementedException();
        }

        #endregion
    }
}
qq_45701634
关注
专栏目录
ADO.NET官方参考文档2021-09.pdf
10-18
ADO.NET 是 .NET Framework 中用于访问关系数据库的关键组件，它提供了与各种数据源（如 SQL Server、Oracle 等）交互的灵活性。在2021-09版的官方参考文档中，主要关注了DataSet、DataTable、DataView这三个核心类...
ADO.NET
03-13
ADO.NET是微软.NET框架下的一种数据访问技术，用于与各种数据源进行交互，包括数据库、XML文件等。它是.NET Framework的重要组成部分，为开发者提供了一种高效、可靠的数据库访问方式。在C#编程环境中，ADO.NET提供...
Ado.NET.rar_ado.net
09-24
ADO.NET是微软.NET框架的一部分，它提供了一组用于与数据源交互的库，包括数据库、XML文件和其他数据存储。在本课程中，我们将深入探讨ADO.NET的核心概念和技术，以帮助你理解和利用其强大的功能。 首先，让我们从...
C#使用Ado.net读取Excel表的方法
09-03
在C#编程中，使用ADO.NET来读取Excel表格数据是一种常见的操作，特别是在处理大量数据时。本篇文章将详细介绍如何利用ADO.NET结合OLEDB技术来读取Excel文件中的数据。 首先，我们需要理解ADO.NET和OLEDB的概念。ADO...
asp.net mvc 增删改查通过ado.net实现
05-02
ADO.NET则是.NET Framework中用于数据库交互的核心组件，它可以方便地与各种数据库管理系统（如SQL Server、Oracle等）进行数据操作。 在这个实例中，我们将探讨如何在ASP.NET MVC应用中使用ADO.NET来实现基本的...
EF 中db.Database.SqlQuery＜T＞的用法
qq_45701634的博客
09-10 3421
第一种： public ActionResult Index() { using (MyContext db=new MyContext()) { Classes c = new Classes(); string sql = string.Format("select * from Class where Id={0}",1); IList&l
EF 中 一对多，多对多之间的配置
qq_45701634的博客
08-24 1162
1:一对多配置 student表中ClassId 是 Class表的Id public class StudentEF { public int Id { set; get; } public string SName { set; get; } public int ClassId { get; set; } //最好对应 ClassId 去掉Id就是Class 最好对应上 /
C#基础知识
qq_45701634的博客
03-26 731
Func 有参数,有返回 Func<in T1, in T2, ..., out TResult> (T1, T2, ...) Func<int, int, string> method = (x, y) => { return x.ToString(); }; Console.WriteLine(method(1, 2)); Action<T1, T2, T3, ...>(t1, t2, t3 ...) 无返回...
配置AutoFac(IOC容器)
qq_45701634的博客
09-04 583
基于接口编程： IOC 概念，之前我们写程序的时候，都是程序员自己new的，当项目大了之后的坏处： 1）各模块之间耦合严重 2）想要跟换为其它类的时候麻烦 3）有的程序员只关心，给我一个实现****接口的类，它不想关心这个类是怎么来的 因此就诞生了IOC容器，使用IOC 容器后，不再是由程序员自己new 对象，而是有框架帮你new对象 现在IOC 有很多：Spring.Net,Unity,Castle,AutoFac等，目前最火的就是AutoFac。 使用IOC 编程的时候，一般都是建议接口编程，也就是把方
EF 架构（UI+server）
qq_45701634的博客
09-01 494
EO,DTO,ViewModel 区别 1：EO(Entity Object,实体对象),就是EF中的实体类，对EO的操作会对数据库产生影响，EO不应该传递到其它层 2：DTO(Data Transfer Object,数据传输对象)，用于各个层之间传递数据的普通类，DTO 有那些属性取决于其它层要什么数据，DTO 一般是“扁平类”，也就是没有关联属性，都是普通类型属性，一些复杂项目中，数据访问层（DAL）和业务逻辑层（BLL）直接传递一个DTO类，UI和BLL层之间用一个新的DTO类，简单的项目公用一个D
MVC中用 FormsAuthentication.SetAuthCookie(）来做身份验证
qq_45701634的博客
08-18 426
1：验证用户登录成功，登录成功之后写入cookie中 [HttpPost] public ActionResult ChekLogin(string user,string pwd) { //判断用户名与密码 if (user == "admin" && pwd =="123") { //为当前用户提供一个身份验证票据，并将该票据添加到Cookie,
EF FluentAPI 配置方法
qq_45701634的博客
08-21 411
//1:创建数据库和表 //2:安装EF，配置连接字符串 //3:创建实体类，类映射数据的表 namespace WebApplication4 { public class Class { public int Id { get; set; } public string ClassName { get; set; } } } //4:创建一个xxxConfig的文件夹，存储xxxConfig的类，用来配...
EF简单 DataAnnotation实体配置
qq_45701634的博客
08-21 367
DataAnnotation 这种配置方法，比较方便，但是耦合度比较高 1：数据库中建表T_Person,有 Id(主键，自动增长)，Name,CreateDateTime字段。 2：创建Person类 [Table("T_Person")] //因为类名和表名不一样，所以要使用Table标注 public class Person { public long Id{get;set;} [Column("Name")] public string SName{ get;set
MVC中的DefaultModelBinder类（全角转换）
qq_45701634的博客
09-03 248
DefaultModelBinder类的作用：自动截取空格和进行全角转换 使用方法： 1：安装程序集Install-PackAge Microsoft.AspNet.Mvc 2写一个类，继承自DefaultModelBinder类，在里面写实现逻辑的方法（全角转半角，空格的去除） 3：在Global中添加 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Thr
MVC 中控制器的返回值
qq_45701634的博客
08-18 221
//1:输出简单的文本内容 public ActionResult ContentText() { string content = "<h1>欢迎你的到来</h1>"; return Content(content); } //2:输出JSON 字符串 public ActionResult JsonTest() {...
Npoi 导出功能
qq_45701634的博客
07-28 167
<button id=btn>导出</button> <script> $("#btn").click(function () { Download("本科生课程", $("#select_BenKeShengKeCheng option:selected").text(), $("#key_BenKeShengKeCheng").val()); }); function Download(module,
C#中ref与out
qq_45701634的博客
12-19 131
参数修饰符，out ,ref 的区别 out 可以不赋初始值，但一定得在方法中赋值 private void Form1_Load(){ SendEailg('sss',out string wanStr); MessageBox.Show(wanStr);// 输出99999 } //方法 public void SendEailg (string str ,out string wanStr){ wanStr="9999999" } ref 必须得在方法外部赋初始值，可以不在方法中赋值 p
MVC中ViewData[“De“], ViewBag.De,TempData[“De“]的区别
qq_45701634的博客
08-18 125
ViewData["De"]:控制器传递到视图时，需要类型转换，只能在控制器与视图传递 ViewBag.De：控制器传递到视图时，不需要视图转换，只能在控制器与视图传递 TempData["De"]：控制器与控制器之间的传递，,与session有点类似，但是只能传递一次 ...
ADO.NET 数据库访问技术详解
ADO.NET是微软在.NET框架下开发的一种全新的数据访问技术，相较于传统的ActiveX Data Objects (ADO)，它提供了一种更为高效且强大的数据库交互方式。ADO.NET的设计目标是提高数据处理的性能，增强数据访问的安全性和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值