DataAccessLayer를 만드는 방법은 무엇입니까?

Question

.Net에서 데이터베이스 응용 프로그램을 만들고 있습니다. 나는 데이터베이스와 .NET 객체를 통신하는 DataAccessLayer을 사용하고하지만 난이 클래스가 맞는지 모르겠습니다 아니면 현재 접근하지 않는 볼 수있는 사람이 어떤 실수

namespace IDataaccess 
{ 
    #region Collection Class 

    public class SPParamCollection : List<SPParams> 
    { 

    } 
    public class SPParamReturnCollection : List<SPParams> 
    { 

    } 
    #endregion 
    #region struct 
    public struct SPParams 
    { 
     public string Name 
     { 
      get; 
      set; 
     } 
     public object Value 
     { 
      get; 
      set; 
     } 
     public ParameterDirection ParamDirection 
     { 
      get; 
      set; 
     } 
     public SqlDbType Type 
     { 
      get; 
      set; 
     } 
     public int Size 
     { 
      get; 
      set; 
     } 
     public string TypeName 
     { 
      get; 
      set; 
     } 
     // public string datatype; 
    } 
    #endregion 
    /// <summary> 
    /// Interface DataAccess Layer implimentation New version 
    /// </summary> 

    public interface IDataAccess 
    { 
     DataTable getDataUsingSP(string spName); 
     DataTable getDataUsingSP(string spName, SPParamCollection spParamCollection); 
     DataSet getDataSetUsingSP(string spName); 
     DataSet getDataSetUsingSP(string spName, SPParamCollection spParamCollection); 
     SqlDataReader getDataReaderUsingSP(string spName); 
     SqlDataReader getDataReaderUsingSP(string spName, SPParamCollection spParamCollection); 
     int executeSP(string spName); 
     int executeSP(string spName, SPParamCollection spParamCollection, bool addExtraParmas); 
     int executeSP(string spName, SPParamCollection spParamCollection); 
     DataTable getDataUsingSqlQuery(string strSqlQuery); 
     int executeSqlQuery(string strSqlQuery); 
     SPParamReturnCollection executeSPReturnParam(string spName, SPParamReturnCollection spParamReturnCollection); 
     SPParamReturnCollection executeSPReturnParam(string spName, SPParamCollection spParamCollection, SPParamReturnCollection spParamReturnCollection); 
     SPParamReturnCollection executeSPReturnParam(string spName, SPParamCollection spParamCollection, SPParamReturnCollection spParamReturnCollection, bool addExtraParmas); 
     int executeSPReturnParam(string spName, SPParamCollection spParamCollection, ref SPParamReturnCollection spParamReturnCollection); 
     object getScalarUsingSP(string spName); 
     object getScalarUsingSP(string spName, SPParamCollection spParamCollection); 
    } 
} 

using IDataaccess; 
namespace Dataaccess 
{ 
    /// <summary> 
    /// Class DataAccess Layer implimentation New version 
    /// </summary> 

    public class DataAccess : IDataaccess.IDataAccess 
    { 
     #region Public variables 
     static string Strcon; 
     DataSet dts = new DataSet(); 

     public DataAccess() 
     { 
      Strcon = sReadConnectionString(); 
     } 
     private string sReadConnectionString() 

     { 
      try 
      { 
       //dts.ReadXml("C:\\cnn.config"); 
       //Strcon = dts.Tables[0].Rows[0][0].ToString(); 

       //System.Configuration.Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); 

       //Strcon = config.ConnectionStrings.ConnectionStrings["connectionString"].ConnectionString; 

       // Add an Application Setting. 




       //Strcon = "Data Source=192.168.50.103;Initial Catalog=erpDB;User ID=ipixerp1;Password=NogoXVc3"; 
      Strcon = System.Configuration.ConfigurationManager.AppSettings["connection"]; 
       //Strcon = System.Configuration.ConfigurationSettings.AppSettings[0].ToString(); 
      } 

      catch (Exception) 
      { 
      } 
      return Strcon; 
     } 

     public SqlConnection connection; 
     public SqlCommand cmd; 
     public SqlDataAdapter adpt; 
     public DataTable dt; 
     public int intresult; 
     public SqlDataReader sqdr; 
     #endregion 
     #region Public Methods 
     public DataTable getDataUsingSP(string spName) 
     { 
      return getDataUsingSP(spName, null); 
     } 
     public DataTable getDataUsingSP(string spName, SPParamCollection spParamCollection) 
     { 
      try 
      { 
       using (connection = new SqlConnection(Strcon)) 
       { 
        connection.Open(); 
        using (cmd = new SqlCommand(spName, connection)) 
        { 
         int count, param = 0; 
         if (spParamCollection == null) 
         { param = -1; } 
         else 
         { 
          param = spParamCollection.Count; 
         } 
         for (count = 0; count < param; count++) 
         { 
          cmd.Parameters.AddWithValue(spParamCollection[count].Name, spParamCollection[count].Value); 
         } 
         cmd.CommandType = CommandType.StoredProcedure; 
         cmd.CommandTimeout = 60; 
         adpt = new SqlDataAdapter(cmd); 
         dt = new DataTable(); 
         adpt.Fill(dt); 
         return (dt); 
        } 
       } 
      } 
      finally 
      { 
       connection.Close(); 
      } 

     } 

     public DataSet getDataSetUsingSP(string spName) 
     { 
      return getDataSetUsingSP(spName, null); 
     } 
     public DataSet getDataSetUsingSP(string spName, SPParamCollection spParamCollection) 
     { 
      try 
      { 
       using (connection = new SqlConnection(Strcon)) 
       { 
        connection.Open(); 
        using (cmd = new SqlCommand(spName, connection)) 
        { 
         int count, param = 0; 
         if (spParamCollection == null) 
         { 
          param = -1; 
         } 
         else 
         { 
          param = spParamCollection.Count; 
         } 
         for (count = 0; count < param; count++) 
         { 
          cmd.Parameters.AddWithValue(spParamCollection[count].Name, spParamCollection[count].Value); 
         } 
         cmd.CommandType = CommandType.StoredProcedure; 
         cmd.CommandTimeout = 60; 
         adpt = new SqlDataAdapter(cmd); 
         DataSet ds = new DataSet(); 
         adpt.Fill(ds); 
         return ds; 
        } 
       } 
      } 
      finally 
      { 
       connection.Close(); 
      } 

     } 
     public SqlDataReader getDataReaderUsingSP(string spName) 
     { 
      return getDataReaderUsingSP(spName, null); 
     } 
     public SqlDataReader getDataReaderUsingSP(string spName, SPParamCollection spParamCollection) 
     { 

      try 
      { 
       using (connection = new SqlConnection(Strcon)) 
       { 
        connection.Open(); 
        using (cmd = new SqlCommand(spName, connection)) 
        { 
         int count, param = 0; 
         if (spParamCollection == null) 
         { param = -1; } 
         else 
         { 
          param = spParamCollection.Count; 
         } 
         for (count = 0; count < param; count++) 
         { 
          cmd.Parameters.AddWithValue(spParamCollection[count].Name, spParamCollection[count].Value); 
         } 
         cmd.CommandType = CommandType.StoredProcedure; 
         cmd.CommandTimeout = 60; 
         sqdr = cmd.ExecuteReader(); 

         return (sqdr); 
        } 
       } 
      } 
      finally 
      { 
       connection.Close(); 
      } 
     } 
     public int executeSP(string spName) 
     { 
      return executeSP(spName, null); 
     } 
     public int executeSP(string spName, SPParamCollection spParamCollection, bool addExtraParmas) 
     { 
      try 
      { 

       using (connection = new SqlConnection(Strcon)) 
       { 
        connection.Open(); 
        using (cmd = new SqlCommand(spName, connection)) 
        { 
         int count, param = 0; 
         if (spParamCollection == null) 
         { param = -1; } 
         else 
         { 
          param = spParamCollection.Count; 
         } 
         for (count = 0; count < param; count++) 
         { 
          SqlParameter par = new SqlParameter(spParamCollection[count].Name, spParamCollection[count].Value); 
          if (addExtraParmas) 
          { 
           par.TypeName = spParamCollection[count].TypeName; 
           par.SqlDbType = spParamCollection[count].Type; 
          } 
          cmd.Parameters.Add(par); 
         } 
         cmd.CommandType = CommandType.StoredProcedure; 
         cmd.CommandTimeout = 60; 
         return (cmd.ExecuteNonQuery()); 
        } 
       } 
      } 

      finally 
      { 
       connection.Close(); 
      } 

     } 
     public int executeSP(string spName, SPParamCollection spParamCollection) 
     { 

      return executeSP(spName, spParamCollection, false); 

     } 

     public DataTable getDataUsingSqlQuery(string strSqlQuery) 
     { 

      try 
      { 
       using (connection = new SqlConnection(Strcon)) 
        connection.Open(); 
       { 
        using (cmd = new SqlCommand(strSqlQuery, connection)) 
        { 
         cmd.CommandType = CommandType.Text; 
         cmd.CommandTimeout = 60; 
         adpt = new SqlDataAdapter(cmd); 
         dt = new DataTable(); 
         adpt.Fill(dt); 
         return (dt); 
        } 
       } 
      } 
      finally 
      { 
       connection.Close(); 
      } 

     } 
     public int executeSqlQuery(string strSqlQuery) 
     { 

      try 
      { 
       using (connection = new SqlConnection(Strcon)) 
       { 
        connection.Open(); 
        using (cmd = new SqlCommand(strSqlQuery, connection)) 
        { 
         cmd.CommandType = CommandType.Text; 
         cmd.CommandTimeout = 60; 
         intresult = cmd.ExecuteNonQuery(); 
         return (intresult); 
        } 
       } 
      } 
      finally 
      { 
       connection.Close(); 
      } 

     } 
     public SPParamReturnCollection executeSPReturnParam(string spName, SPParamReturnCollection spParamReturnCollection) 
     { 
      return executeSPReturnParam(spName, null, spParamReturnCollection); 
     } 
     public int executeSPReturnParam() 
     { 
      return 0; 
     } 

     public int executeSPReturnParam(string spName, SPParamCollection spParamCollection, ref SPParamReturnCollection spParamReturnCollection) 
     { 
      try 
      { 
       SPParamReturnCollection spParamReturned = new SPParamReturnCollection(); 
       using (connection = new SqlConnection(Strcon)) 
       { 
        connection.Open(); 
        using (cmd = new SqlCommand(spName, connection)) 
        { 
         int count, param = 0; 
         if (spParamCollection == null) 
         { param = -1; } 
         else 
         { 
          param = spParamCollection.Count; 
         } 
         for (count = 0; count < param; count++) 
         { 
          cmd.Parameters.AddWithValue(spParamCollection[count].Name, spParamCollection[count].Value); 
         } 
         cmd.CommandType = CommandType.StoredProcedure; 
         foreach (SPParams paramReturn in spParamReturnCollection) 
         { 
          SqlParameter _parmReturn = new SqlParameter(paramReturn.Name, paramReturn.Size); 
          _parmReturn.Direction = paramReturn.ParamDirection; 
          if (paramReturn.Size > 0) _parmReturn.Size = paramReturn.Size; 
          else _parmReturn.Size = 32; 
          _parmReturn.SqlDbType = paramReturn.Type; 
          cmd.Parameters.Add(_parmReturn); 
         } 
         cmd.CommandTimeout = 60; 
         intresult = cmd.ExecuteNonQuery(); 
         connection.Close(); 

         //for (int i = 0; i < spParamReturnCollection.Count; i++) 
         //{ 
         // spParamReturned.Add(new SPParams 
         // { 
         //  Name = spParamReturnCollection[i].Name, 
         //  Value = cmd.Parameters[spParamReturnCollection[i].Name].Value 
         // }); 

         //} 
        } 
       } 
       return intresult; 
      } 
      finally 
      { 
       connection.Close(); 

      } 
     } 
     public SPParamReturnCollection executeSPReturnParam(string spName, SPParamCollection spParamCollection, SPParamReturnCollection spParamReturnCollection) 
     { 
      return executeSPReturnParam(spName, spParamCollection, spParamReturnCollection, false); 
     } 
     public SPParamReturnCollection executeSPReturnParam(string spName, SPParamCollection spParamCollection, SPParamReturnCollection spParamReturnCollection, bool addExtraParmas) 
     { 
      try 
      { 
       SPParamReturnCollection spParamReturned = new SPParamReturnCollection(); 
       using (connection = new SqlConnection(Strcon)) 
       { 
        connection.Open(); 
        using (cmd = new SqlCommand(spName, connection)) 
        { 
         int count, param = 0; 
         if (spParamCollection == null) 
         { param = -1; } 
         else 
         { 
          param = spParamCollection.Count; 
         } 
         for (count = 0; count < param; count++) 
         { 
          //cmd.Parameters.AddWithValue(spParamCollection[count].Name, spParamCollection[count].Value); 
          SqlParameter par = new SqlParameter(spParamCollection[count].Name, spParamCollection[count].Value); 
          if (addExtraParmas) 
          { 
           par.TypeName = spParamCollection[count].TypeName; 
           par.SqlDbType = spParamCollection[count].Type; 
          } 
          cmd.Parameters.Add(par); 
         } 
         cmd.CommandType = CommandType.StoredProcedure; 
         foreach (SPParams paramReturn in spParamReturnCollection) 
         { 
          SqlParameter _parmReturn = new SqlParameter(paramReturn.Name, paramReturn.Value); 
          _parmReturn.Direction = paramReturn.ParamDirection; 
          if (paramReturn.Size > 0) _parmReturn.Size = paramReturn.Size; 
          else _parmReturn.Size = 32; 
          _parmReturn.SqlDbType = paramReturn.Type; 
          cmd.Parameters.Add(_parmReturn); 
         } 
         cmd.CommandTimeout = 60; 
         cmd.ExecuteNonQuery(); 
         connection.Close(); 

         for (int i = 0; i < spParamReturnCollection.Count; i++) 
         { 
          spParamReturned.Add(new SPParams 
          { 
           Name = spParamReturnCollection[i].Name, 
           Value = cmd.Parameters[spParamReturnCollection[i].Name].Value 

          }); 

         } 
        } 
       } 
       return spParamReturned; 
      } 
      catch (Exception ex) 
      { 
       return null; 
      } 
      finally 
      { 
       connection.Close(); 
      } 
     } 
     public object getScalarUsingSP(string spName) 
     { 
      return getScalarUsingSP(spName, null); 
     } 
     public object getScalarUsingSP(string spName, SPParamCollection spParamCollection) 
     { 
      try 
      { 
       using (connection = new SqlConnection(Strcon)) 
       { 
        connection.Open(); 
        using (cmd = new SqlCommand(spName, connection)) 
        { 
         int count, param = 0; 
         if (spParamCollection == null) 
         { param = -1; } 
         else 
         { 
          param = spParamCollection.Count; 
         } 
         for (count = 0; count < param; count++) 
         { 
          cmd.Parameters.AddWithValue(spParamCollection[count].Name, spParamCollection[count].Value); 
          cmd.CommandTimeout = 60; 
         } 
         cmd.CommandType = CommandType.StoredProcedure; 
         return cmd.ExecuteScalar(); 
        } 
       } 
      } 
      finally 
      { 
       connection.Close(); 
       cmd.Dispose(); 
      } 
     } 
     #endregion 
    } 
} 

Answer 1

그것을 확인 건너 해결할 수 없습니다 트랜잭션 환경에 대한 관심, 요즘 DAL을 만드는 방법에 대해 아무도 신경 쓰지 않는다. EF, nhibernate, ...을 사용할 수있는 경우 엔티티 프레임 워크를 확인하고 시작 체크 용으로 사용하는 것이 좋습니다 code first. 2008 및 2010에서 사용할 수 있습니다.

Answer 2

기회가 있다면 코드에서 데이터베이스로 매핑하는 데 사용할 수있는 도구를 사용해보십시오. NHibernate은 인기있는 하나이며 MS Entity framework 4.0
여기에 표시된 코드는이 페이지에서 질문하는 것이 매우 복잡합니다. 이에 대한 구체적인 답변을 얻지 못할지 의심됩니다.

Answer 3

내가 이것을 검토하는 코드라면, 나는 그것을 거절 할 것이다. 내 첫 코멘트는 : 그것은 데이터 액세스 레이어가 아닙니다 - 당신은 데이터 독립 레이어 (사실 아주 드물게 그 중 하나가 필요함)이라고 부를 수 있습니다.

데이터 액세스 계층은이를 호출하는 계층에서 데이터 리포지토리를 추상화합니다. getScalarUsingSP() 및 getDataUsingSP()과 같은 기능을 노출하는 것은 데이터베이스를 추상화하지 않고 단순히 호출 스타일에 더 적합한 몇 개의 래퍼 함수를 ​​만드는 것입니다.

인터페이스를 통해 물건을 드러냄으로써 올바른 길을 가고 있지만 노출 된 기능을 변경해야합니다. getDataUsingSP() 대신 GetSelectedAccounts() 또는 SaveCustomer()과 같은 전화 번호가 필요합니다. getDataUsingSP()은 비공개이며 공개 된 "친숙한"기능에서 호출됩니다.