it-swarm.com.de

Lesen Sie die SQL-Tabelle in C # DataTable

Ich habe viele Beiträge zum Einfügen einer DataTable in eine SQL-Tabelle gelesen, aber gibt es eine einfache Möglichkeit, eine SQL-Tabelle in eine .NET DataTable zu ziehen?

72
Will

Hier, geben Sie diesem einen Schuss (dies ist nur ein Pseudocode)

using System;
using System.Data;
using System.Data.SqlClient;


public class PullDataTest
{
    // your data table
    private DataTable dataTable = new DataTable();

    public PullDataTest()
    {
    }

    // your method to pull data from database to datatable   
    public void PullData()
    {
        string connString = @"your connection string here";
        string query = "select * from table";

        SqlConnection conn = new SqlConnection(connString);        
        SqlCommand cmd = new SqlCommand(query, conn);
        conn.Open();

        // create data adapter
        SqlDataAdapter da = new SqlDataAdapter(cmd);
        // this will query your database and return the result to your datatable
        da.Fill(dataTable);
        conn.Close();
        da.Dispose();
    }
}
122
yonan2236
var table = new DataTable();    
using (var da = new SqlDataAdapter("SELECT * FROM mytable", "connection string"))
{      
    da.Fill(table);
}
61
Tim Rogers

Viele möglichkeiten.

Verwenden Sie ADO.Net und füllen Sie den Datenadapter mit fill aus, um eine DataTable abzurufen:

using (SqlDataAdapter dataAdapter
    = new SqlDataAdapter ("SELECT blah FROM blahblah ", sqlConn))
{
    // create the DataSet 
    DataSet dataSet = new DataSet(); 
    // fill the DataSet using our DataAdapter 
    dataAdapter.Fill (dataSet);
}

Sie können die Datentabelle dann aus dem Dataset abrufen. 

Hinweis im aktualisierten Antwortdatensatz wird nicht verwendet (erscheint nach meiner Antwort) .__

// create data adapter
SqlDataAdapter da = new SqlDataAdapter(cmd);
// this will query your database and return the result to your datatable
da.Fill(dataTable);

Welches ist meiner vorzuziehen.

Ich würde jedoch dringend einen Blick auf das Entity-Framework werfen. Die Verwendung von Daten- und Datasets ist keine gute Idee. Es gibt keine Typsicherheit, so dass das Debuggen nur zur Laufzeit ausgeführt werden kann. Mit stark typisierten Sammlungen (die Sie durch die Verwendung von LINQ2SQL oder Entity-Framework erhalten können) wird Ihr Leben wesentlich einfacher.

Edit: Vielleicht war mir nicht klar: Datatables = gut, Datensätze = böse. Wenn Sie ADO.Net verwenden, können Sie beide Technologien (EF, linq2sql, dapper, nhibernate, orm des Monats) verwenden, da sie normalerweise auf ado.net sitzen. Der Vorteil ist, dass Sie Ihr Modell viel einfacher aktualisieren können, wenn sich Ihr Schema ändert, vorausgesetzt, Sie verfügen über die richtige Abstraktionsebene, indem Sie die Code-Generierung nutzen.

Der ado.net-Adapter verwendet Provider, die die Typinformationen der Datenbank verfügbar machen. Standardmäßig wird ein SQL-Serverprovider verwendet. Sie können beispielsweise den devart Postgress-Provider anschließen und weiterhin auf die Typinformationen zugreifen, die dann angezeigt werden Sie können wie oben beschrieben Ihren orm Ihrer Wahl verwenden (fast schmerzlos - es gibt ein paar Macken) - ich glaube, Microsoft bietet auch einen Oracle-Anbieter an. Der Zweck von ENTIRE besteht darin, soweit möglich von der Datenbankimplementierung zu abstrahieren.

11
John Nicholas

Die herstellerunabhängige Version basiert ausschließlich auf ADO.NET-Schnittstellen. 2 Wege:

public DataTable Read1<T>(string query) where T : IDbConnection, new()
{
    using (var conn = new T())
    {
        using (var cmd = conn.CreateCommand())
        {
            cmd.CommandText = query;
            cmd.Connection.ConnectionString = _connectionString;
            cmd.Connection.Open();
            var table = new DataTable();
            table.Load(cmd.ExecuteReader());
            return table;
        }
    }
}

public DataTable Read2<S, T>(string query) where S : IDbConnection, new() 
                                           where T : IDbDataAdapter, IDisposable, new()
{
    using (var conn = new S())
    {
        using (var da = new T())
        {
            using (da.SelectCommand = conn.CreateCommand())
            {
                da.SelectCommand.CommandText = query;
                da.SelectCommand.Connection.ConnectionString = _connectionString;
                DataSet ds = new DataSet(); //conn is opened by dataadapter
                da.Fill(ds);
                return ds.Tables[0];
            }
        }
    }
}

Ich habe einige Leistungstests durchgeführt und der zweite Ansatz übertraf den ersten immer.

Stopwatch sw = Stopwatch.StartNew();
DataTable dt = null;
for (int i = 0; i < 100; i++)
{
    dt = Read1<MySqlConnection>(query); // ~9800ms
    dt = Read2<MySqlConnection, MySqlDataAdapter>(query); // ~2300ms

    dt = Read1<SQLiteConnection>(query); // ~4000ms
    dt = Read2<SQLiteConnection, SQLiteDataAdapter>(query); // ~2000ms

    dt = Read1<SqlCeConnection>(query); // ~5700ms
    dt = Read2<SqlCeConnection, SqlCeDataAdapter>(query); // ~5700ms

    dt = Read1<SqlConnection>(query); // ~850ms
    dt = Read2<SqlConnection, SqlDataAdapter>(query); // ~600ms

    dt = Read1<VistaDBConnection>(query); // ~3900ms
    dt = Read2<VistaDBConnection, VistaDBDataAdapter>(query); // ~3700ms
}
sw.Stop();
MessageBox.Show(sw.Elapsed.TotalMilliseconds.ToString());

Read1 sieht auf den Augen besser aus, aber der Datenadapter funktioniert besser (nicht zu verwirren, dass eine Datenbankeinheit die andere übertrifft, die Abfragen waren alle unterschiedlich). Der Unterschied zwischen den beiden hing jedoch von der Abfrage ab. Der Grund könnte sein, dass Load die Prüfung verschiedener Einschränkungen erfordert, Zeile für Zeile aus der Dokumentation , wenn Zeilen hinzugefügt werden (dies ist eine Methode für DataTable), während Fill auf DataAdapters ist, die nur für diese Zwecke konzipiert wurden - schnelle Erstellung von DataTables.

7
nawfal

Zentralisiertes Modell: Sie können es von überall verwenden!

Sie müssen nur Below Format von Ihrer Funktion zu dieser Klasse aufrufen

DataSet ds = new DataSet();
SqlParameter[] p = new SqlParameter[1];
string Query = "Describe Query Information/either sp, text or TableDirect";
DbConnectionHelper dbh = new DbConnectionHelper ();
ds = dbh. DBConnection("Here you use your Table Name", p , string Query, CommandType.StoredProcedure);

Das ist es. Es ist die perfekte Methode. 

public class DbConnectionHelper {
   public DataSet DBConnection(string TableName, SqlParameter[] p, string Query, CommandType cmdText) {
    string connString = @ "your connection string here";
    //Object Declaration
    DataSet ds = new DataSet();
    SqlConnection con = new SqlConnection();
    SqlCommand cmd = new SqlCommand();
    SqlDataAdapter sda = new SqlDataAdapter();
    try {
     //Get Connection string and Make Connection
     con.ConnectionString = connString; //Get the Connection String
     if (con.State == ConnectionState.Closed) {
      con.Open(); //Connection Open
     }
     if (cmdText == CommandType.StoredProcedure) //Type : Stored Procedure
     {
      cmd.CommandType = CommandType.StoredProcedure;
      cmd.CommandText = Query;
      if (p.Length > 0) // If Any parameter is there means, we need to add.
      {
       for (int i = 0; i < p.Length; i++) {
        cmd.Parameters.Add(p[i]);
       }
      }
     }
     if (cmdText == CommandType.Text) // Type : Text
     {
      cmd.CommandType = CommandType.Text;
      cmd.CommandText = Query;
     }
     if (cmdText == CommandType.TableDirect) //Type: Table Direct
     {
      cmd.CommandType = CommandType.Text;
      cmd.CommandText = Query;
     }
     cmd.Connection = con; //Get Connection in Command
     sda.SelectCommand = cmd; // Select Command From Command to SqlDataAdaptor
     sda.Fill(ds, TableName); // Execute Query and Get Result into DataSet
     con.Close(); //Connection Close
    } catch (Exception ex) {

     throw ex; //Here you need to handle Exception
    }
    return ds;
   }
  }
0
Elango S