三层架构登陆

最新推荐文章于 2024-01-11 11:01:52 发布
最新推荐文章于 2024-01-11 11:01:52 发布
阅读量775 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qhx556/article/details/8752657
版权

前台：

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Login.aspx.cs" Inherits="UserLogin.Login" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        用户名<asp:TextBox ID="TextBox1" runat="server"></asp:TextBox>
        <br />
        密码<asp:TextBox ID="TextBox2"
            runat="server"></asp:TextBox>
        <br />
        <asp:Button ID="btnLogin" runat="server" Text="登录" οnclick="btnLogin_Click" />
    </div>
    </form>
</body>
</html>

 

后台：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Data.SqlClient;
using System.Data;

namespace UserLogin
{
    public partial class Login : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {

        }

        protected void btnLogin_Click(object sender, EventArgs e)
        {          
            //表示层的作用就是现实数据给用户看，或者收集用户输入的数据，并且将数据传递到BLL层
            UserLogin.Model.T_User muser = new Model.T_User();
            muser.UserName = TextBox1.Text;
            muser.Password = TextBox2.Text;
            UserLogin.BLL.T_User btuser = new BLL.T_User();
            if (btuser.ValidatorUser(muser) == true)
            {
                Response.Write("成功");
            }
            else
            {
                Response.Write("失败");
            }
           
            #region 原始方式验证登录
            /*using (SqlConnection conn=new SqlConnection("strcon"))
            {
                using (SqlCommand cmd=conn.CreateCommand())
                {
                    cmd.CommandText = "select * from T_User where username=@usernmae and password=@password";
                    //参数替换
                    conn.Open();
                    SqlDataAdapter adapter = new SqlDataAdapter(cmd);
                    DataTable dt = new DataTable();
                    adapter.Fill(dt);
                    if (dt.Rows.Count > 0)
                    {
                        Response.Write("登录成功");
                    }
                    else
                    {
                        Response.Write("登录失败");
                    }
                }
            }*/
            #endregion
           
        }
    }
}

 

BLL类：

/**  版本信息模板在安装目录下，可自行修改。
* T_User.cs
*
* 功 能： N/A
* 类 名： T_User
*
* Ver    变更日期             负责人  变更内容
* ───────────────────────────────────
* V0.01  2013/4/2 15:19:11   N/A    初版
*
* Copyright (c) 2012 Maticsoft Corporation. All rights reserved.
*┌──────────────────────────────────┐
*│　此技术信息为本公司机密信息，未经本公司书面同意禁止向第三方披露．　│
*│　版权所有：动软卓越（北京）科技有限公司　　　　　　　　　　　　　　│
*└──────────────────────────────────┘
*/
using System;
using System.Data;
using System.Collections.Generic;

using UserLogin.Model;
namespace UserLogin.BLL
{
 /// <summary>
 /// T_User
 /// </summary>
 public partial class T_User
 {
  private readonly UserLogin.DAL.T_User dal=new UserLogin.DAL.T_User();
  public T_User()
  {}
  #region  BasicMethod

        public bool ValidatorUser(UserLogin.Model.T_User model)
        {
            return dal.ValidatorUser(model);
        }
  /// <summary>
  /// 得到最大ID
  /// </summary>
  public int GetMaxId()
  {
   return dal.GetMaxId();
  }

  /// <summary>
  /// 是否存在该记录
  /// </summary>
  public bool Exists(int Id)
  {
   return dal.Exists(Id);
  }

  /// <summary>
  /// 增加一条数据
  /// </summary>
  public int  Add(UserLogin.Model.T_User model)
  {
   return dal.Add(model);
  }

  /// <summary>
  /// 更新一条数据
  /// </summary>
  public bool Update(UserLogin.Model.T_User model)
  {
   return dal.Update(model);
  }

  /// <summary>
  /// 删除一条数据
  /// </summary>
  public bool Delete(int Id)
  {
   
   return dal.Delete(Id);
  }
  /// <summary>
  /// 删除一条数据
  /// </summary>
  public bool DeleteList(string Idlist )
  {
   return dal.DeleteList(Idlist );
  }

  /// <summary>
  /// 得到一个对象实体
  /// </summary>
  public UserLogin.Model.T_User GetModel(int Id)
  {
   
   return dal.GetModel(Id);
  }

  
  /// <summary>
  /// 获得前几行数据
  /// </summary>
  public DataSet GetList(int Top,string strWhere,string filedOrder)
  {
   return dal.GetList(Top,strWhere,filedOrder);
  }
  /// <summary>
  /// 获得数据列表
  /// </summary>
  public List<UserLogin.Model.T_User> GetModelList(string strWhere)
  {
   DataSet ds = dal.GetList(strWhere);
   return DataTableToList(ds.Tables[0]);
  }
  /// <summary>
  /// 获得数据列表
  /// </summary>
  public List<UserLogin.Model.T_User> DataTableToList(DataTable dt)
  {
   List<UserLogin.Model.T_User> modelList = new List<UserLogin.Model.T_User>();
   int rowsCount = dt.Rows.Count;
   if (rowsCount > 0)
   {
    UserLogin.Model.T_User model;
    for (int n = 0; n < rowsCount; n++)
    {
     model = dal.DataRowToModel(dt.Rows[n]);
     if (model != null)
     {
      modelList.Add(model);
     }
    }
   }
   return modelList;
  }

  

  /// <summary>
  /// 分页获取数据列表
  /// </summary>
  public int GetRecordCount(string strWhere)
  {
   return dal.GetRecordCount(strWhere);
  }
  /// <summary>
  /// 分页获取数据列表
  /// </summary>
  public DataSet GetListByPage(string strWhere, string orderby, int startIndex, int endIndex)
  {
   return dal.GetListByPage( strWhere,  orderby,  startIndex,  endIndex);
  }
  /// <summary>
  /// 分页获取数据列表
  /// </summary>
  //public DataSet GetList(int PageSize,int PageIndex,string strWhere)
  //{
   //return dal.GetList(PageSize,PageIndex,strWhere);
  //}

  #endregion  BasicMethod
  #region  ExtensionMethod

  #endregion  ExtensionMethod
 }
}

 

DAL类：

/**  版本信息模板在安装目录下，可自行修改。
* T_User.cs
*
* 功 能： N/A
* 类 名： T_User
*
* Ver    变更日期             负责人  变更内容
* ───────────────────────────────────
* V0.01  2013/4/2 15:19:11   N/A    初版
*
* Copyright (c) 2012 Maticsoft Corporation. All rights reserved.
*┌──────────────────────────────────┐
*│　此技术信息为本公司机密信息，未经本公司书面同意禁止向第三方披露．　│
*│　版权所有：动软卓越（北京）科技有限公司　　　　　　　　　　　　　　│
*└──────────────────────────────────┘
*/
using System;
using System.Data;
using System.Text;
using System.Data.SqlClient;
using UserLogin.DataAccess;
namespace UserLogin.DAL
{
 /// <summary>
 /// 数据访问类:T_User
 /// </summary>
 public partial class T_User
 {
  public T_User()
  {}
  #region  BasicMethod

        public bool ValidatorUser(UserLogin.Model.T_User model)
        {
            bool result=false;
            StringBuilder sb1 = new StringBuilder();
            sb1.Append("SELECT COUNT(*) FROM T_User WHERE UserName=@username AND Password=@password");
            SqlParameter[] parameters = {
     new SqlParameter("@username", model.UserName),
     new SqlParameter("@password", model.Password)};
            object obj= DbHelperSQL.GetSingle(sb1.ToString(), parameters);
            if (Convert.ToInt32(obj)!=0)
            {
                result = true;
            }
            return result;
        }
       
  /// <summary>
  /// 得到最大ID
  /// </summary>
  public int GetMaxId()
  {
  return DbHelperSQL.GetMaxID("Id", "T_User");
  }

  /// <summary>
  /// 是否存在该记录
  /// </summary>
  public bool Exists(int Id)
  {
   StringBuilder strSql=new StringBuilder();
   strSql.Append("select count(1) from T_User");
   strSql.Append(" where Id=@Id");
   SqlParameter[] parameters = {
     new SqlParameter("@Id", SqlDbType.Int,4)
   };
   parameters[0].Value = Id;

   return DbHelperSQL.Exists(strSql.ToString(),parameters);
  }


  /// <summary>
  /// 增加一条数据
  /// </summary>
  public int Add(UserLogin.Model.T_User model)
  {
   StringBuilder strSql=new StringBuilder();
   strSql.Append("insert into T_User(");
   strSql.Append("UserId,UserName,Password,RealName,Mobile,Department)");
   strSql.Append(" values (");
   strSql.Append("@UserId,@UserName,@Password,@RealName,@Mobile,@Department)");
   strSql.Append(";select @@IDENTITY");
   SqlParameter[] parameters = {
     new SqlParameter("@UserId", SqlDbType.VarChar,8),
     new SqlParameter("@UserName", SqlDbType.VarChar,16),
     new SqlParameter("@Password", SqlDbType.VarChar,16),
     new SqlParameter("@RealName", SqlDbType.VarChar,16),
     new SqlParameter("@Mobile", SqlDbType.VarChar,16),
     new SqlParameter("@Department", SqlDbType.VarChar,32)};
   parameters[0].Value = model.UserId;
   parameters[1].Value = model.UserName;
   parameters[2].Value = model.Password;
   parameters[3].Value = model.RealName;
   parameters[4].Value = model.Mobile;
   parameters[5].Value = model.Department;

   object obj = DbHelperSQL.GetSingle(strSql.ToString(),parameters);
   if (obj == null)
   {
    return 0;
   }
   else
   {
    return Convert.ToInt32(obj);
   }
  }
  /// <summary>
  /// 更新一条数据
  /// </summary>
  public bool Update(UserLogin.Model.T_User model)
  {
   StringBuilder strSql=new StringBuilder();
   strSql.Append("update T_User set ");
   strSql.Append("UserId=@UserId,");
   strSql.Append("UserName=@UserName,");
   strSql.Append("Password=@Password,");
   strSql.Append("RealName=@RealName,");
   strSql.Append("Mobile=@Mobile,");
   strSql.Append("Department=@Department");
   strSql.Append(" where Id=@Id");
   SqlParameter[] parameters = {
     new SqlParameter("@UserId", SqlDbType.VarChar,8),
     new SqlParameter("@UserName", SqlDbType.VarChar,16),
     new SqlParameter("@Password", SqlDbType.VarChar,16),
     new SqlParameter("@RealName", SqlDbType.VarChar,16),
     new SqlParameter("@Mobile", SqlDbType.VarChar,16),
     new SqlParameter("@Department", SqlDbType.VarChar,32),
     new SqlParameter("@Id", SqlDbType.Int,4)};
   parameters[0].Value = model.UserId;
   parameters[1].Value = model.UserName;
   parameters[2].Value = model.Password;
   parameters[3].Value = model.RealName;
   parameters[4].Value = model.Mobile;
   parameters[5].Value = model.Department;
   parameters[6].Value = model.Id;

   int rows=DbHelperSQL.ExecuteSql(strSql.ToString(),parameters);
   if (rows > 0)
   {
    return true;
   }
   else
   {
    return false;
   }
  }

  /// <summary>
  /// 删除一条数据
  /// </summary>
  public bool Delete(int Id)
  {
   
   StringBuilder strSql=new StringBuilder();
   strSql.Append("delete from T_User ");
   strSql.Append(" where Id=@Id");
   SqlParameter[] parameters = {
     new SqlParameter("@Id", SqlDbType.Int,4)
   };
   parameters[0].Value = Id;

   int rows=DbHelperSQL.ExecuteSql(strSql.ToString(),parameters);
   if (rows > 0)
   {
    return true;
   }
   else
   {
    return false;
   }
  }
  /// <summary>
  /// 批量删除数据
  /// </summary>
  public bool DeleteList(string Idlist )
  {
   StringBuilder strSql=new StringBuilder();
   strSql.Append("delete from T_User ");
   strSql.Append(" where Id in ("+Idlist + ")  ");
   int rows=DbHelperSQL.ExecuteSql(strSql.ToString());
   if (rows > 0)
   {
    return true;
   }
   else
   {
    return false;
   }
  }


  /// <summary>
  /// 得到一个对象实体
  /// </summary>
  public UserLogin.Model.T_User GetModel(int Id)
  {
   
   StringBuilder strSql=new StringBuilder();
   strSql.Append("select  top 1 Id,UserId,UserName,Password,RealName,Mobile,Department from T_User ");
   strSql.Append(" where Id=@Id");
   SqlParameter[] parameters = {
     new SqlParameter("@Id", SqlDbType.Int,4)
   };
   parameters[0].Value = Id;

   UserLogin.Model.T_User model=new UserLogin.Model.T_User();
   DataSet ds=DbHelperSQL.Query(strSql.ToString(),parameters);
   if(ds.Tables[0].Rows.Count>0)
   {
    return DataRowToModel(ds.Tables[0].Rows[0]);
   }
   else
   {
    return null;
   }
  }


  /// <summary>
  /// 得到一个对象实体
  /// </summary>
  public UserLogin.Model.T_User DataRowToModel(DataRow row)
  {
   UserLogin.Model.T_User model=new UserLogin.Model.T_User();
   if (row != null)
   {
    if(row["Id"]!=null && row["Id"].ToString()!="")
    {
     model.Id=int.Parse(row["Id"].ToString());
    }
    if(row["UserId"]!=null)
    {
     model.UserId=row["UserId"].ToString();
    }
    if(row["UserName"]!=null)
    {
     model.UserName=row["UserName"].ToString();
    }
    if(row["Password"]!=null)
    {
     model.Password=row["Password"].ToString();
    }
    if(row["RealName"]!=null)
    {
     model.RealName=row["RealName"].ToString();
    }
    if(row["Mobile"]!=null)
    {
     model.Mobile=row["Mobile"].ToString();
    }
    if(row["Department"]!=null)
    {
     model.Department=row["Department"].ToString();
    }
   }
   return model;
  }

  /// <summary>
  /// 获得数据列表
  /// </summary>
  public DataSet GetList(string strWhere)
  {
   StringBuilder strSql=new StringBuilder();
   strSql.Append("select Id,UserId,UserName,Password,RealName,Mobile,Department ");
   strSql.Append(" FROM T_User ");
   if(strWhere.Trim()!="")
   {
    strSql.Append(" where "+strWhere);
   }
   return DbHelperSQL.Query(strSql.ToString());
  }

  /// <summary>
  /// 获得前几行数据
  /// </summary>
  public DataSet GetList(int Top,string strWhere,string filedOrder)
  {
   StringBuilder strSql=new StringBuilder();
   strSql.Append("select ");
   if(Top>0)
   {
    strSql.Append(" top "+Top.ToString());
   }
   strSql.Append(" Id,UserId,UserName,Password,RealName,Mobile,Department ");
   strSql.Append(" FROM T_User ");
   if(strWhere.Trim()!="")
   {
    strSql.Append(" where "+strWhere);
   }
   strSql.Append(" order by " + filedOrder);
   return DbHelperSQL.Query(strSql.ToString());
  }

  /// <summary>
  /// 获取记录总数
  /// </summary>
  public int GetRecordCount(string strWhere)
  {
   StringBuilder strSql=new StringBuilder();
   strSql.Append("select count(1) FROM T_User ");
   if(strWhere.Trim()!="")
   {
    strSql.Append(" where "+strWhere);
   }
   object obj = DbHelperSQL.GetSingle(strSql.ToString());
   if (obj == null)
   {
    return 0;
   }
   else
   {
    return Convert.ToInt32(obj);
   }
  }
  /// <summary>
  /// 分页获取数据列表
  /// </summary>
  public DataSet GetListByPage(string strWhere, string orderby, int startIndex, int endIndex)
  {
   StringBuilder strSql=new StringBuilder();
   strSql.Append("SELECT * FROM ( ");
   strSql.Append(" SELECT ROW_NUMBER() OVER (");
   if (!string.IsNullOrEmpty(orderby.Trim()))
   {
    strSql.Append("order by T." + orderby );
   }
   else
   {
    strSql.Append("order by T.Id desc");
   }
   strSql.Append(")AS Row, T.*  from T_User T ");
   if (!string.IsNullOrEmpty(strWhere.Trim()))
   {
    strSql.Append(" WHERE " + strWhere);
   }
   strSql.Append(" ) TT");
   strSql.AppendFormat(" WHERE TT.Row between {0} and {1}", startIndex, endIndex);
   return DbHelperSQL.Query(strSql.ToString());
  }

  /*
  /// <summary>
  /// 分页获取数据列表
  /// </summary>
  public DataSet GetList(int PageSize,int PageIndex,string strWhere)
  {
   SqlParameter[] parameters = {
     new SqlParameter("@tblName", SqlDbType.VarChar, 255),
     new SqlParameter("@fldName", SqlDbType.VarChar, 255),
     new SqlParameter("@PageSize", SqlDbType.Int),
     new SqlParameter("@PageIndex", SqlDbType.Int),
     new SqlParameter("@IsReCount", SqlDbType.Bit),
     new SqlParameter("@OrderType", SqlDbType.Bit),
     new SqlParameter("@strWhere", SqlDbType.VarChar,1000),
     };
   parameters[0].Value = "T_User";
   parameters[1].Value = "Id";
   parameters[2].Value = PageSize;
   parameters[3].Value = PageIndex;
   parameters[4].Value = 0;
   parameters[5].Value = 0;
   parameters[6].Value = strWhere; 
   return DbHelperSQL.RunProcedure("UP_GetRecordByPage",parameters,"ds");
  }*/

  #endregion  BasicMethod
  #region  ExtensionMethod

  #endregion  ExtensionMethod
 }
}

 

DataAccess类：

using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
using System.Data.Common;
using System.Collections.Generic;
namespace UserLogin.DataAccess
{
    /// <summary>
    /// 数据访问抽象基础类
    /// Copyright (C) Maticsoft
    /// </summary>
    public abstract class DbHelperSQL
    {
        //数据库连接字符串(web.config来配置)，多数据库可使用DbHelperSQLP来实现.
        public static string connectionString = ConfigurationManager.ConnectionStrings["sqlservercon"].ConnectionString;
        public DbHelperSQL()
        {           
        }

        #region 公用方法
        /// <summary>
        /// 判断是否存在某表的某个字段
        /// </summary>
        /// <param name="tableName">表名称</param>
        /// <param name="columnName">列名称</param>
        /// <returns>是否存在</returns>
        public static bool ColumnExists(string tableName, string columnName)
        {
            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;
        }
        public static int GetMaxID(string FieldName, string TableName)
        {
            string strsql = "select max(" + FieldName + ")+1 from " + TableName;
            object obj = GetSingle(strsql);
            if (obj == null)
            {
                return 1;
            }
            else
            {
                return int.Parse(obj.ToString());
            }
        }
        public 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()); //也可能=0
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <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;
            }
        }
        public 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;
            }
        }
        #endregion

        #region  执行简单SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }

        public static int ExecuteSqlByTime(string SQLString, int Times)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        cmd.CommandTimeout = Times;
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }
     
      
       
        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, string content)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                SqlCommand cmd = new SqlCommand(SQLString, connection);
                System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
                myParameter.Value = content;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.SqlClient.SqlException e)
                {
                    throw e;
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }
        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static object ExecuteSqlGet(string SQLString, string content)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                SqlCommand cmd = new SqlCommand(SQLString, connection);
                System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@content", SqlDbType.NText);
                myParameter.Value = content;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    object obj = cmd.ExecuteScalar();
                    if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                    {
                        return null;
                    }
                    else
                    {
                        return obj;
                    }
                }
                catch (System.Data.SqlClient.SqlException e)
                {
                    throw e;
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }
        /// <summary>
        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
        /// </summary>
        /// <param name="strSQL">SQL语句</param>
        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                SqlCommand cmd = new SqlCommand(strSQL, connection);
                System.Data.SqlClient.SqlParameter myParameter = new System.Data.SqlClient.SqlParameter("@fs", SqlDbType.Image);
                myParameter.Value = fs;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.SqlClient.SqlException e)
                {
                    throw e;
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string SQLString)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }
        public static object GetSingle(string SQLString, int Times)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        cmd.CommandTimeout = Times;
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }
        /// <summary>
        /// 执行查询语句，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string strSQL)
        {
            SqlConnection connection = new SqlConnection(connectionString);
            SqlCommand cmd = new SqlCommand(strSQL, connection);
            try
            {
                connection.Open();
                SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                return myReader;
            }
            catch (System.Data.SqlClient.SqlException e)
            {
                throw e;
            }  

        }
        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string SQLString)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
                    command.Fill(ds, "ds");
                }
                catch (System.Data.SqlClient.SqlException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }
        public static DataSet Query(string SQLString, int Times)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    SqlDataAdapter command = new SqlDataAdapter(SQLString, connection);
                    command.SelectCommand.CommandTimeout = Times;
                    command.Fill(ds, "ds");
                }
                catch (System.Data.SqlClient.SqlException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }

 

        #endregion

        #region 执行带参数的SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, params SqlParameter[] cmdParms)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        int rows = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                        return rows;
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        throw e;
                    }
                }
            }
        }


        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
        public static void ExecuteSqlTran(Hashtable SQLStringList)
        {
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                conn.Open();
                using (SqlTransaction trans = conn.BeginTransaction())
                {
                    SqlCommand cmd = new SqlCommand();
                    try
                    {
                        //循环
                        foreach (DictionaryEntry myDE in SQLStringList)
                        {
                            string cmdText = myDE.Key.ToString();
                            SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val = cmd.ExecuteNonQuery();
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }
      
       
        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的SqlParameter[]）</param>
        public static void ExecuteSqlTranWithIndentity(Hashtable SQLStringList)
        {
            using (SqlConnection conn = new SqlConnection(connectionString))
            {
                conn.Open();
                using (SqlTransaction trans = conn.BeginTransaction())
                {
                    SqlCommand cmd = new SqlCommand();
                    try
                    {
                        int indentity = 0;
                        //循环
                        foreach (DictionaryEntry myDE in SQLStringList)
                        {
                            string cmdText = myDE.Key.ToString();
                            SqlParameter[] cmdParms = (SqlParameter[])myDE.Value;
                            foreach (SqlParameter q in cmdParms)
                            {
                                if (q.Direction == ParameterDirection.InputOutput)
                                {
                                    q.Value = indentity;
                                }
                            }
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val = cmd.ExecuteNonQuery();
                            foreach (SqlParameter q in cmdParms)
                            {
                                if (q.Direction == ParameterDirection.Output)
                                {
                                    indentity = Convert.ToInt32(q.Value);
                                }
                            }
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }
        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string SQLString, params SqlParameter[] cmdParms)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        object obj = cmd.ExecuteScalar();
                        cmd.Parameters.Clear();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.SqlClient.SqlException e)
                    {
                        throw e;
                    }
                }
            }
        }

        /// <summary>
        /// 执行查询语句，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader ExecuteReader(string SQLString, params SqlParameter[] cmdParms)
        {
            SqlConnection connection = new SqlConnection(connectionString);
            SqlCommand cmd = new SqlCommand();
            try
            {
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                SqlDataReader myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                return myReader;
            }
            catch (System.Data.SqlClient.SqlException e)
            {
                throw e;
            }
            //   finally
            //   {
            //    cmd.Dispose();
            //    connection.Close();
            //   } 

        }

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string SQLString, params SqlParameter[] cmdParms)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                SqlCommand cmd = new SqlCommand();
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                using (SqlDataAdapter da = new SqlDataAdapter(cmd))
                {
                    DataSet ds = new DataSet();
                    try
                    {
                        da.Fill(ds, "ds");
                        cmd.Parameters.Clear();
                    }
                    catch (System.Data.SqlClient.SqlException ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    return ds;
                }
            }
        }


        private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, string cmdText, SqlParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open)
                conn.Open();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
                cmd.Transaction = trans;
            cmd.CommandType = CommandType.Text;//cmdType;
            if (cmdParms != null)
            {


                foreach (SqlParameter parameter in cmdParms)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    cmd.Parameters.Add(parameter);
                }
            }
        }

        #endregion

        #region 存储过程操作

        /// <summary>
        /// 执行存储过程，返回SqlDataReader ( 注意：调用该方法后，一定要对SqlDataReader进行Close )
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlDataReader</returns>
        public static SqlDataReader RunProcedure(string storedProcName, IDataParameter[] parameters)
        {
            SqlConnection connection = new SqlConnection(connectionString);
            SqlDataReader returnReader;
            connection.Open();
            SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
            command.CommandType = CommandType.StoredProcedure;
            returnReader = command.ExecuteReader(CommandBehavior.CloseConnection);
            return returnReader;
           
        }


        /// <summary>
        /// 执行存储过程
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <param name="tableName">DataSet结果中的表名</param>
        /// <returns>DataSet</returns>
        public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                DataSet dataSet = new DataSet();
                connection.Open();
                SqlDataAdapter sqlDA = new SqlDataAdapter();
                sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
                sqlDA.Fill(dataSet, tableName);
                connection.Close();
                return dataSet;
            }
        }
        public static DataSet RunProcedure(string storedProcName, IDataParameter[] parameters, string tableName, int Times)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                DataSet dataSet = new DataSet();
                connection.Open();
                SqlDataAdapter sqlDA = new SqlDataAdapter();
                sqlDA.SelectCommand = BuildQueryCommand(connection, storedProcName, parameters);
                sqlDA.SelectCommand.CommandTimeout = Times;
                sqlDA.Fill(dataSet, tableName);
                connection.Close();
                return dataSet;
            }
        }


        /// <summary>
        /// 构建 SqlCommand 对象(用来返回一个结果集，而不是一个整数值)
        /// </summary>
        /// <param name="connection">数据库连接</param>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlCommand</returns>
        private static SqlCommand BuildQueryCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
        {
            SqlCommand command = new SqlCommand(storedProcName, connection);
            command.CommandType = CommandType.StoredProcedure;
            foreach (SqlParameter parameter in parameters)
            {
                if (parameter != null)
                {
                    // 检查未分配值的输出参数,将其分配以DBNull.Value.
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    command.Parameters.Add(parameter);
                }
            }

            return command;
        }

        /// <summary>
        /// 执行存储过程，返回影响的行数  
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <param name="rowsAffected">影响的行数</param>
        /// <returns></returns>
        public static int RunProcedure(string storedProcName, IDataParameter[] parameters, out int rowsAffected)
        {
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                int result;
                connection.Open();
                SqlCommand command = BuildIntCommand(connection, storedProcName, parameters);
                rowsAffected = command.ExecuteNonQuery();
                result = (int)command.Parameters["ReturnValue"].Value;
                //Connection.Close();
                return result;
            }
        }

        /// <summary>
        /// 创建 SqlCommand 对象实例(用来返回一个整数值) 
        /// </summary>
        /// <param name="storedProcName">存储过程名</param>
        /// <param name="parameters">存储过程参数</param>
        /// <returns>SqlCommand 对象实例</returns>
        private static SqlCommand BuildIntCommand(SqlConnection connection, string storedProcName, IDataParameter[] parameters)
        {
            SqlCommand command = BuildQueryCommand(connection, storedProcName, parameters);
            command.Parameters.Add(new SqlParameter("ReturnValue",
                SqlDbType.Int, 4, ParameterDirection.ReturnValue,
                false, 0, 0, string.Empty, DataRowVersion.Default, null));
            return command;
        }
        #endregion

    }

}

 

MODEL类：

/**  版本信息模板在安装目录下，可自行修改。
* T_User.cs
*
* 功 能： N/A
* 类 名： T_User
*
* Ver    变更日期             负责人  变更内容
* ───────────────────────────────────
* V0.01  2013/4/2 15:19:11   N/A    初版
*
* Copyright (c) 2012 Maticsoft Corporation. All rights reserved.
*┌──────────────────────────────────┐
*│　此技术信息为本公司机密信息，未经本公司书面同意禁止向第三方披露．　│
*│　版权所有：动软卓越（北京）科技有限公司　　　　　　　　　　　　　　│
*└──────────────────────────────────┘
*/
using System;
namespace UserLogin.Model
{
 /// <summary>
 /// T_User:实体类(属性说明自动提取数据库字段的描述信息)
 /// </summary>
 [Serializable]
 public partial class T_User
 {
  public T_User()
  {}
  #region Model
  private int _id;
  private string _userid;
  private string _username;
  private string _password;
  private string _realname;
  private string _mobile;
  private string _department;
  /// <summary>
  ///
  /// </summary>
  public int Id
  {
   set{ _id=value;}
   get{return _id;}
  }
  /// <summary>
  /// 用户编号
  /// </summary>
  public string UserId
  {
   set{ _userid=value;}
   get{return _userid;}
  }
  /// <summary>
  /// 用户名
  /// </summary>
  public string UserName
  {
   set{ _username=value;}
   get{return _username;}
  }
  /// <summary>
  /// 密码
  /// </summary>
  public string Password
  {
   set{ _password=value;}
   get{return _password;}
  }
  /// <summary>
  /// 用户姓名
  /// </summary>
  public string RealName
  {
   set{ _realname=value;}
   get{return _realname;}
  }
  /// <summary>
  /// 手机
  /// </summary>
  public string Mobile
  {
   set{ _mobile=value;}
   get{return _mobile;}
  }
  /// <summary>
  /// 所属部门
  /// </summary>
  public string Department
  {
   set{ _department=value;}
   get{return _department;}
  }
  #endregion Model

 }
}

 

Web.Config:

<?xml version="1.0" encoding="utf-8"?>

<!--
  有关如何配置 ASP.NET 应用程序的详细消息，请访问
  http://go.microsoft.com/fwlink/?LinkId=169433
  -->

<configuration>
  <system.web>
    <compilation debug="true" targetFramework="4.0" />
  </system.web>
  <connectionStrings>
    <add name="sqlservercon" connectionString="Data Source=PC-20130314PXQG;Initial Catalog=News;Persist Security Info=True;User ID=sa;Password=842674"/>
    <add name="sqlservercon1" connectionString="Data Source=FZW-PC;Initial Catalog=News;Persist Security Info=True;User ID=sa;Password=yhb@163"/>
    <add name="sqlservercon2" connectionString="Data Source=WJP-PC;Initial Catalog=News;Persist Security Info=True;User ID=sa;Password=yhb@163"/>
  </connectionStrings>
</configuration>

 

心如止静
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java三层架构实现登录_用户登录——三层架构
weixin_32273747的博客
02-27 1685
1、MVC开发模式(web开发模式)：M：model-------javabean(封装数据)V：view----------jsp(显示数据)C：controller----servlet(获取数据)2、javaee的三层架构(javaee开发)：web层：与客户端交互service层：复杂的业务处理dao层：与数据库交互3、工程结构：4、三层架构：web层：protected voiddoPo...
动软代码生成器C#连接mysql三层代码模板--修改版
06-08
动软代码生成器 V2.76版，请支持正版。 修改DAL.cmt模板文件： 1、必须增加该命名空间 using MySql.Data.MySqlClient; 2、部分的 SqlParameter 修改为 MySqlParameter 3、获取前几行数据时，修改为 limit 4、参数赋值时，从@修改为？ 动软代码必须修改 “工具”-“选项”弹出窗 后，点击 ”代码生成设置“-”字段类型映射“-”参数符号“中删除 mysql @，添加mysql ? C# 连接 mysql 需要的相应三层结构模板（修改版） 1、该版本 有 增加 读取数据库字段注释的功能。 2、安装软件后，执行“无法生成字段注释请替换”实现读取字段注释功能。 3、把“C#数据库模板修改版”解压后复制到安装路径的“Template”-“TemplateFile”文件夹下 4、打开软件后， 在左边 添加服务器后，选择对用的表右键选择 “模板代码生成”， 5、之后在右边双击选择 “C#数据库模板修改版” 6、点击生成代码， 7、模板代码批量生成，可直接生成相应表代码，复制到项目中，直接调用 BLL部分，实现增删改查。
三层模式开发使用GridPanel(.net)控件代码实例详解(展示层代码)
天天好心情
11-26 1308
ExtJS中的表格功能非常强大，包括了排序、缓存、拖动、隐藏某一列、自动显示行号、列汇总、单元格编辑等实用功能。        表格由类Ext.grid.GridPanel定义，继承自Panel，其xtype为grid。ExtJS中，表格Grid必须包含列定义信息，并指定表格的数据存储器Store。表格的列信息由类Ext.grid.ColumnModel定义、而表格的数据存储器由Ext.data.Store定义，数据存储器根据解析的数据不同分为JsonStore、SimpleStroe、GroupingSt
CS三层登陆系统
05-28
用Winform做的一个三层登陆系统
三层架构之登录
dianpi2993的博客
04-14 344
一：三层构架的基础知识 在项目开发的过程中，有时把整个项目分为三层架构，其中包括：表示层(UI)、业务逻辑层(BLL)和数据访 问层(DAL)。三层的作用分别如下： 表示层： 为用户提供交互操作界面，这一点不论是对于Web还是WinForm都是如此，就是用户界面操作 。我们网站展示给用户看的界面。 业务逻辑层： 负责关键业务的处理和数据的传递。复杂...
C#__三层结构实现登录窗体
07-31
三层结构实现登录窗体.............
从壹开始前后端分离 [.netCore 填坑 ] 三十二║ 四种方法快速实现项目的半自动化搭建...
weixin_30916125的博客
10-09 294
更新 1、更新小伙伴 @大龄Giser提出好点子：试试VS的插件扩展：VSIX、ItemProject等，将T4模板给制作插件，这里先记下，有懂的小伙伴可以自己先试试，我会在以后更新。 2、感谢小伙伴 @博客园董事长的测试和指正，本文 T4 模板已经支持 Oracle 3、再次感谢小伙伴 @大龄Giser 关于使用VSIX+ProjectTemplate创建项目模板，提供开源支持...
php三层架构 注册登陆,什么是三层架构
weixin_36399948的博客
03-11 626
三层架构就是一种软件设计模式和完善的软件体系结构，它将整个业务应用划分为三层分别是表示层，业务逻辑层以及数据访问层三层架构就是一种客户端-服务器体系结构，它将整个业务逻辑划分为三层，接下来在文章中将为大家具体介绍三层架构的相关知识，具有一定的参考作用。希望对大家有所帮助。【推荐课程：设计模式教程】三层架构的含义：三层体系结构是一种软件设计模式和完善的软件体系结构，其中功能过程逻辑，数据访问，计算机...
Java研学-三层架构实现简单登录操作
最新发布
zhlyxx的博客
01-11 1182
将服务器资源给有权限的人访问，只有登录的管理员可以访问员工信息进行 CRUD。
c#三层架构
lisa丶
07-04 1万+
最近公司需要用c#，就简单看了一下三层架构。 三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为:界面层(User Interface layer)、业务逻辑层(Business Logic Layer)、数据访问层(Data access layer)。 UI层：即表示层，就是展现给用户看到的界面 BLL：即业务逻辑层，就是实现功能的，用来写方法及其...
asp.net三层架构实现注册登录,三层架构练习-C#文档类资源
02-27
ASP.NET三层架构是一种常见的软件设计模式，用于组织和分离应用程序的业务逻辑、数据访问和用户界面层。在ASP.NET中，这种架构可以帮助开发者创建可维护、可扩展且易于复用的代码。本资源是一个关于使用ASP.NET三层...
三层架构实现登陆注册
12-22
在“三层架构实现登陆注册”这个项目中，我们将探讨如何使用C#编程语言在Visual Studio 2019环境下实现登录和注册功能，并遵循三层架构的规范。 1. 表现层（Presentation Layer）： 这是用户与系统交互的部分，负责...
一个简单的ASP.NET三层架构登陆模式
05-09
（开始说正题 ）有很多入门学者在为三层架构感到困惑，不知三层架构如何实现，现在本人详细地详一个简单的例子来说明三层架构的实现，至于三层架构是什么原理，51aspx老大说得很详细了，本人不再重复。 最后,说下各...
三层架构登陆的实现
06-11
这是一个三层架构登陆的实现，需要这些方面的都可以看看，欢迎大家来看。
Visual Studio动态生成版权信息
weixin_30664615的博客
01-15 163
Visual Studio动态生成版权信息 VS2008 　　1.1，类文件模板：在安装目录打开CS模板文件夹(D:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE\ItemTemplatesCache\CSharp\Code\2052\Class.zip)，在此文件夹下查找到Class.cs，打开编辑该模版文件。　...
三层架构——三层登录代码分析
热门推荐
至尊宝
12-31 2万+
强烈推荐一个大神的人工智能的教程：http://www.captainbed.net/zhanghan ●时序图 ●U层 private void btnLogin_Click(object sender, EventArgs e) { //IDbConnection conn = new SqlConnection("c......"); ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值