EF 存储过程

One:理论

A：定义

      存储过程(stored procedure)是一组为了完成特定功能的SQL语句集合，经编译后存储在服务器端的数据库中，利用存储过程可以加速SQL语句的执行。

      存储过程分为系统存储过程和自定义存储过程。

        1.系统存储过程在master数据库中，但是在其他的数据库中可以直接调用，并且在调用时不必在存储过程前加上数据库名，因为在创建一个新数据库时，系统存储过程

           在新的数据库中会自动创建

        2.自定义存储过程，由用户创建并能完成某一特定功能的存储过程，存储过程既可以有参数又有返回值，但是它与函数不同，存储过程的返回值只是指明执行是否成功，

           并不能像函数那样被直接调用，只能利用execute来执行存储过程。

B：优点 

       1.提高应用程序的通用性和可移植性：存储过程创建后，可以在程序中被多次调用，而不必重新编写该存储过程的SQL语句。并且数据库专业人员可以随时对存储过程进行

          修改，且对程序源代码没有影响，这样就极大的提高了程序的可移植性。

       2.可以更有效的管理用户操作数据库的权限：在Sql Server数据库中，系统管理员可以通过对执行某一存储过程的权限进行限制，从而实现对相应的数据访问进行控制，

          避免非授权用户对数据库的访问，保证数据的安全。

       3.可以提高SQL的速度，存储过程是编译过的，如果某一个操作包含大量的SQL代码或分别被执行多次，那么使用存储过程比直接使用单条SQL语句执行速度快的多。

       4.减轻服务器的负担：当用户的操作是针对数据库对象的操作时，如果使用单条调用的方式，那么网络上还必须传输大量的SQL语句，如果使用存储过程，

          则直接发送过程的调用命令即可，降低了网络的负担。

       C：语法

  SQL Server存储过程语法：

      create procedure  过程名

         @parameter       参数类型

         @parameter      参数类型   

          。。。

          as 

          begin

          end

 

          执行存储过程：execute 过程名

Two:应用

A：数据库存储

--查询不带参数的存储过程
 ALTER procedure  [dbo].[GetUser]  
 as
 begin
   Select Theserialnumber, UserID, UserName, UserSet,
       Userphone, work.UserworkType,Details.WorkDetailsSituation,
       [level].UserleverlType,[type].UserType, UserCreationtime, hobby.Userhobby from [User] 
       inner join Work on Work.UserworkID=[User].UserworkID
       inner join [level] on [level].UserlevelID=[user].UserlevelID
       inner join UserType as [type] on [type].UserTypeID=[USER].UserTypeID
       inner join WorkDetails as Details on Details.WorkDetailsID=Work.WorkDetailsID
       inner join Userhobby as hobby on hobby.UserhobbyID=[user].UserhobbyID
 end


--查询带参数的存储过程
ALTER procedure [dbo].[GetUserID] --创建存储过程名
@UserID   varchar(50)      --参数
as
begin
select * from [User] where UserID=@UserID -- 命令行或者命令块
end

B：项目程序

    //根据提供的strSQL语句 访问数据库，返回List集合
        public List<User> GetDataSet(string strSQL)
        {
            Connection();
            try
            {
                SqlDataAdapter da = new SqlDataAdapter(strSQL, con);
                DataSet ds = new DataSet();
                da.Fill(ds);
                List<User> list = new List<User>();
                if (ds.Tables.Count > 0)
                {
                    for (int i = 0; i < ds.Tables.Count; i++)
                    {
                        foreach (DataRow dr in ds.Tables[i].Rows)
                        {
                            User obj = new User();
                            if (ds.Tables[i].Columns.Contains("UserID")) obj.UserID = Convert.ToString(dr["UserID"]);
                            if (ds.Tables[i].Columns.Contains("UserName")) obj.UserName = Convert.ToString(dr["UserName"]);
                            if (ds.Tables[i].Columns.Contains("UserSet")) obj.UserSet = Convert.ToString(dr["UserSet"]);
                            if (ds.Tables[i].Columns.Contains("Userphone")) obj.Userphone = Convert.ToString(dr["Userphone"]);
                            if (ds.Tables[i].Columns.Contains("UserworkType")) obj.UserworkType = Convert.ToString(dr["UserworkType"]);
                            if (ds.Tables[i].Columns.Contains("WorkDetailsSituation")) obj.WorkDetailsSituation = Convert.ToString(dr["WorkDetailsSituation"]);
                            if (ds.Tables[i].Columns.Contains("UserleverlType")) obj.UserleverlType = Convert.ToString(dr["UserleverlType"]);
                            if (ds.Tables[i].Columns.Contains("UserType")) obj.UserType = Convert.ToString(dr["UserType"]);
                            if (ds.Tables[i].Columns.Contains("UserCreationtime")) obj.UserCreationtime = Convert.ToDateTime(dr["UserCreationtime"]);
                            if (ds.Tables[i].Columns.Contains("Userhobby")) obj.Userhobby = Convert.ToString(dr["Userhobby"]);
                            list.Add(obj);
                        }
                    }
                }
                return list;
            }
            catch (Exception)
            {

                throw;
            }
        }



        /// <summary>
        /// 执行返回DataTable的查询
        /// <param name="procName">存储过程名称</param>
        /// <param name="parameters">存储过程参数</param>
        public static DataTable GetDataTableByProc(string procName, params IDataParameter[] parameters)
        {
            Connection();
            DataTable dt = new DataTable();
            SqlCommand cmd = new SqlCommand();
            try
            {
                cmd.Connection = con;
                cmd.CommandText = procName;
                cmd.CommandType = CommandType.StoredProcedure;
                for (int i = 0; i < parameters.Length; i++)
                {
                    cmd.Parameters.Add(parameters[i]);
                }
                SqlDataAdapter dp = new SqlDataAdapter(cmd);
                dp.Fill(dt);
                con.Close();
                return dt;
            }
            catch (Exception ex)
            {

                throw ex;
            }

        }

        /// 执行返回DataSet的查询
        /// <param name="procName">存储过程名称</param>
        /// <param name="parameters">存储过程参数</param>
        public static DataSet GetDataSetByProc(string procName, params IDataParameter[] parameters)
        {

            Connection();
            DataSet ds = new DataSet();
            SqlCommand cmd = new SqlCommand();
            try
            {
                cmd.Connection = con;
                cmd.CommandText = procName;
                cmd.CommandType = CommandType.StoredProcedure;
                con.Open();
                for (int i = 0; i < parameters.Length; i++)
                {
                    cmd.Parameters.Add(parameters[i]);
                }
                SqlDataAdapter dp = new SqlDataAdapter(cmd);
                dp.Fill(ds);
                con.Close();
                return ds;
            }
            catch (Exception ex)
            { 

                throw ex;
            }
           
        }


        /// <summary>
        /// 根据条件查询
        /// </summary>
        /// <param name="SqlStr">存储过程名称/sql语句</param>
        /// <param name="parameters">存储过程参数/参数</param>
        /// <returns></returns>
        public static DataTable GetDataTable(string SqlStr, params IDataParameter[] parameters)
        {
            #region
            Connection();
            DataTable dt = new DataTable();
            SqlDataAdapter da = new SqlDataAdapter(SqlStr, con);
            try
            {
                da.SelectCommand.Parameters.Clear();
                foreach (SqlParameter pam in parameters)
                {
                    da.SelectCommand.Parameters.Add(EncodeParam(pam));
                }

                da.Fill(dt);
                da.SelectCommand.Parameters.Clear();
                da.Dispose();
            }
            catch (Exception e)
            {
                Console.Write(SqlStr + ",SQL异常:" + e.Message);
            }
            finally
            {
                con.Dispose();
            }
            return dt;
            #endregion
        }

C：调用

        //、、、、、、、、存储过程、、、、、、、、、
        //查询全部
        public static List<User> GetUser()
        {
            return db.GetDataSet("GetUser");
        }

        /// <summary>
        /// 根据条件查询
        /// </summary>
        /// <param name="UserID">参数</param>
        public static DataTable GetUserID(string UserID)
        {
            SqlParameter[] parameters = {
                new SqlParameter("@UserID",SqlDbType.VarChar,50)
            };
            parameters[0].Value = UserID;
            return DBbase.GetDataTableByProc("GetUserID", parameters);
        }

            //存储过程

            List<User> u = DAL.Family.GetUser();
            DataTable d = DAL.Family.GetUserID("2020020901494949");
            for (int i = 0; i < d.Rows.Count; i++)
            {
                foreach (DataRow dr in d.Rows)
                {
                    var ID = dr["UserID"].ToString();
                }
            }