क्या .NET कोर में ADO.NET संभव है?

Question

मैं एएसपी.नेट कोर के नवीनतम संस्करणों का उपयोग करना चाहता हूं, क्योंकि मैं इसके साथ वेब एपीआई का एक सेट बनाना चाहता हूं। हालांकि, जो ट्यूटोरियल मैंने पाया वह एंटीटी फ्रेमवर्क पर दृढ़ता से केंद्रित हैं। मैं इसका उपयोग नहीं कर सकता क्योंकि मेरे पास पहले से ही "विरासत" डेटाबेस है, इसलिए कोड-फर्स्ट दृष्टिकोण एक विकल्प नहीं है।

मेरा विचार है मेरे डेटाबेस में ADO.NET कनेक्शन का उपयोग करना, हालांकि मुझे नहीं पता कि System.Data.SqlClient एएसपी.NET कोर प्रोजेक्ट में उपलब्ध है या नहीं। मुझे पहले से ही पता चला है कि जब मैं .NET Framework प्रोजेक्ट टेम्पलेट का उपयोग करता हूं तो यह उपलब्ध है लेकिन क्या यह अभी भी .NET कोर प्रोजेक्ट में उपलब्ध है?

Answer 1

मौजूदा SqlConnection और अन्य संबंधित कनेक्शन अभी भी System.Data.SqlClient नामस्थान के भीतर मौजूद हैं और पूर्ण ढांचे या .NET कोर का उपयोग करके अपेक्षित कार्य करना चाहिए।

और फिर वाक्य रचना के माध्यम से इसे कहते:

तुम बस उचित संदर्भ जोड़ने के लिए और बयानों का उपयोग कर यह इस तरह System.Data.SqlClient नाम स्थान के रूप में अपने project.json फ़ाइल में नीचे देखा के माध्यम से के रूप में शामिल करना होगा आप के आदी हैं: तो जब तक आप अपने मौजूदा विरासत डेटाबेस से कनेक्ट करने के लिए एक वैध कनेक्शन स्ट्रिंग है के रूप में

using(var connection = new SqlConnection("{your-connection-string}")) 
{ 
     // Do work here 
} 

, आप ठीक होना चाहिए।

ORM उपयोग के बारे में

मैंने यह भी पाया कि कुछ लोगों को, साफ-सुथरी, इकाई की रूपरेखा के लिए एक माइक्रो ORM प्रतिस्थापन का उपयोग कर रहे apparenty अधिक लचीला। यह ADO.NET के बजाय इसका उपयोग करने के किसी भी फायदे हैं?

ये ORMs (वस्तु-संबंधपरक मानचित्रकारों) काम और अक्सर शक्तिशाली उपकरण है कि और अधिक आसानी से विशिष्ट वर्गों और वस्तुओं के लिए अपने मौजूदा डेटाबेस डेटा मैप कर सकते हैं, जो उन्हें आसानी से उपयोग करने के लिए कर सकते हैं (जैसा कि एक डेटा के माध्यम से पुनरावृत्ति करने का विरोध कर रहे हैं पाठक, अपनी प्रत्येक पंक्ति को पार्स करना और प्रत्येक ऑब्जेक्ट को मैन्युअल रूप से बनाना)।

जहां तक ​​प्रदर्शन चलता है, यह अंततः इस बात पर निर्भर करता है कि आप अपने प्रश्नों के साथ क्या करने जा रहे हैं। ADO.NET आमतौर पर सबसे तेज़ होगा क्योंकि यह डेटाबेस के लिए एक नंगे-हड्डियों का कनेक्शन है, हालांकि कुछ परिदृश्यों में डैपर वास्तव में इसे हरा सकता है। इकाई फ्रेमवर्क, बहुत उपयोगी होने पर, आम तौर पर प्रदर्शन में पीछे की ओर जाता है, क्योंकि यह इतना बड़ा ओआरएम है।

फिर से - यह अंततः आप जो कर रहे हैं उस पर निर्भर करता है, लेकिन सभी व्यवहार्य विकल्प हैं।

Answer 2

यह ध्यान रखना महत्वपूर्ण है कि .NET कोर में डेटासेट, डेटाटेबल और संबंधित ऑब्जेक्ट्स नहीं हैं। लेकिन हमारे पास कनेक्शन, कमांड, पैरामीटर, डेटा रीडर और अन्य संबंधित ऑब्जेक्ट्स जैसी सभी मूल विशेषताएं हैं।

SQL सर्वर डेटाबेस प्रदाता के माध्यम से SQL सर्वर से कनेक्टिविटी को सरल बनाने के लिए आप निम्न कॉल का उपयोग कर सकते हैं।

public class BaseDataAccess 
{ 
    protected string ConnectionString { get; set; } 

    public BaseDataAccess() 
    { 
    } 

    public BaseDataAccess(string connectionString) 
    { 
     this.ConnectionString = connectionString; 
    } 

    private SqlConnection GetConnection() 
    { 
     SqlConnection connection = new SqlConnection(this.ConnectionString); 
     if (connection.State != ConnectionState.Open) 
      connection.Open(); 
     return connection; 
    } 

    protected DbCommand GetCommand(DbConnection connection, string commandText, CommandType commandType) 
    { 
     SqlCommand command = new SqlCommand(commandText, connection as SqlConnection); 
     command.CommandType = commandType; 
     return command; 
    } 

    protected SqlParameter GetParameter(string parameter, object value) 
    { 
     SqlParameter parameterObject = new SqlParameter(parameter, value != null ? value : DBNull.Value); 
     parameterObject.Direction = ParameterDirection.Input; 
     return parameterObject; 
    } 

    protected SqlParameter GetParameterOut(string parameter, SqlDbType type, object value = null, ParameterDirection parameterDirection = ParameterDirection.InputOutput) 
    { 
     SqlParameter parameterObject = new SqlParameter(parameter, type); ; 

     if (type == SqlDbType.NVarChar || type == SqlDbType.VarChar || type == SqlDbType.NText || type == SqlDbType.Text) 
     { 
      parameterObject.Size = -1; 
     } 

     parameterObject.Direction = parameterDirection; 

     if (value != null) 
     { 
      parameterObject.Value = value; 
     } 
     else 
     { 
      parameterObject.Value = DBNull.Value; 
     } 

     return parameterObject; 
    } 

    protected int ExecuteNonQuery(string procedureName, List<DbParameter> parameters, CommandType commandType = CommandType.StoredProcedure) 
    { 
     int returnValue = -1; 

     try 
     { 
      using (SqlConnection connection = this.GetConnection()) 
      { 
       DbCommand cmd = this.GetCommand(connection, procedureName, commandType); 

       if (parameters != null && parameters.Count > 0) 
       { 
        cmd.Parameters.AddRange(parameters.ToArray()); 
       } 

       returnValue = cmd.ExecuteNonQuery(); 
      } 
     } 
     catch (Exception ex) 
     { 
      //LogException("Failed to ExecuteNonQuery for " + procedureName, ex, parameters); 
      throw; 
     } 

     return returnValue; 
    } 

    protected object ExecuteScalar(string procedureName, List<SqlParameter> parameters) 
    { 
     object returnValue = null; 

     try 
     { 
      using (DbConnection connection = this.GetConnection()) 
      { 
       DbCommand cmd = this.GetCommand(connection, procedureName, CommandType.StoredProcedure); 

       if (parameters != null && parameters.Count > 0) 
       { 
        cmd.Parameters.AddRange(parameters.ToArray()); 
       } 

       returnValue = cmd.ExecuteScalar(); 
      } 
     } 
     catch (Exception ex) 
     { 
      //LogException("Failed to ExecuteScalar for " + procedureName, ex, parameters); 
      throw; 
     } 

     return returnValue; 
    } 

    protected DbDataReader GetDataReader(string procedureName, List<DbParameter> parameters, CommandType commandType = CommandType.StoredProcedure) 
    { 
     DbDataReader ds; 

     try 
     { 
      DbConnection connection = this.GetConnection(); 
      { 
       DbCommand cmd = this.GetCommand(connection, procedureName, commandType); 
       if (parameters != null && parameters.Count > 0) 
       { 
        cmd.Parameters.AddRange(parameters.ToArray()); 
       } 

       ds = cmd.ExecuteReader(CommandBehavior.CloseConnection); 
      } 
     } 
     catch (Exception ex) 
     { 
      //LogException("Failed to GetDataReader for " + procedureName, ex, parameters); 
      throw; 
     } 

     return ds; 
    } 
} 

अधिक जानकारी और उदाहरण के लिए लेख निम्नलिखित का संदर्भ लें: http://www.ijz.today/2016/09/net-core-10-connecting-sql-server.html

Answer 3

नेट कोर 2.0 डेटासेट, DataTable और SqlDataAdapter है।मेरा उत्तर https://blogs.msdn.microsoft.com/devfish/2017/05/15/exploring-datatable-and-sqldbadapter-in-asp-net-core-2-0/ पर देखें। नीचे

कोड ठीक

public static DataTable ExecuteDataTableSqlDA(SqlConnection conn, CommandType cmdType, string cmdText, SqlParameter[] cmdParms) 
{ 
System.Data.DataTable dt = new DataTable(); 
System.Data.SqlClient.SqlDataAdapter da = new SqlDataAdapter(cmdText, conn); 
da.Fill(dt); 
return dt; 
} 

Answer 4

काम करता है जो हीली डॉटनैट कोर 2.0 में अपने answer में उल्लेख किया है कि यह सब System.Data सुविधाओं का उपयोग करना संभव है।

जोड़े nugets:

• Microsoft.Extensions.Configuration
• Microsoft.Extensions.Configuration.Json - json से कनेक्शन स्ट्रिंग को पढ़ने के लिए
• System.Data.Common
• System.Data .SqlClient

config.json उदाहरण:

{ 
    "connectionString": "your-db-connection-settings" 
} 

यहां एक पूर्ण कंसोल ऐप उदाहरण है।

class Program 
{ 
    static void Main(string[] args) 
    { 
     var configuration = new ConfigurationBuilder() 
      .SetBasePath(Directory.GetCurrentDirectory()) 
      .AddJsonFile("config.json", false) 
      .Build(); 

     var connectionString = configuration.GetSection("connectionString").Value; 

     if(string.IsNullOrEmpty(connectionString)) 
      throw new ArgumentException("No connection string in config.json"); 

     using (var conn = new SqlConnection(connectionString)) 
     { 
      var sql = "SELECT * FROM ExampleTable"; 
      using (var cmd = new SqlCommand(sql, conn)) 
      { 
       using (var adapter = new SqlDataAdapter(cmd)) 
       { 
        var resultTable = new DataTable(); 
        adapter.Fill(resultTable); 
       } 
      } 
     } 
    } 
}