Odczytaj tabelę SQL do C # DataTable

Tutaj daj tę szansę (to jest tylko pseudokod)

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();

 }

}

var table = new DataTable(); 

using (var da = new SqlDataAdapter("SELECT * FROM mytable", "connection string"))

{ 

 da.Fill(table);

}

Jest wiele sposobów.
Użyj ADO.Net i użyj wypełnienia adaptera danych, aby uzyskać DataTable:

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);

}

Następnie możesz pobrać arkusz danych z zestawu danych.
Uwaga Zestaw danych nie używa odpowiedzi za głosem (pojawiła się po mojej odpowiedzi)
To robi

// create data adapter

SqlDataAdapter da = new SqlDataAdapter(cmd);

// this will query your database and return the result to your datatable

da.Fill(dataTable);

Co jest lepsze od mojego.
Gorąco polecam jednak przyjrzenie się strukturze encji ... używanie danych i zbiorów danych nie jest dobrym pomysłem. Nie są bezpieczne dla typów, co oznacza, że ​​debugowanie można przeprowadzić tylko w czasie wykonywania. Dzięki kolekcjom silnie wpisanym (które można uzyskać za pomocą LINQ2SQL lub frameworku jednostek), Twoje życie będzie znacznie łatwiejsze.
Edycja: Może nie wyraziłem się jasno: dane = dobre, zbiory danych = zło. Jeśli korzystasz z ADO.Net, możesz użyć obu tych technologii (EF, linq2sql, dapper, nhibernate, orm of the month), ponieważ zwykle znajdują się one na górze ado.net. Zaletą jest to, że możesz zaktualizować swój model znacznie łatwiej niż zmiany schematu, pod warunkiem, że masz odpowiedni poziom abstrakcji przy użyciu generowania kodu.
Adapter ado.net korzysta z dostawców, którzy dostarczają informacje o typie bazy danych, na przykład domyślnie korzysta z dostawcy serwera sql, możesz również połączyć się - na przykład - dostawca postgress devart i nadal mieć dostęp do informacji o typie, które następnie pozwolą ci . jak wyżej, użyj swojego wyboru (prawie bezbolesne - jest kilka dziwactw) - uważam, że Microsoft zapewnia również dostawcę Oracle. CAŁKOWITY celem tego jest abstrahowanie od implementacji bazy danych tam, gdzie to możliwe.

Wersja niezależna od dostawcy, oparta wyłącznie na interfejsach ADO.NET; 2 drogi:

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];

 }

 }

 }

}

Przeprowadziłem kilka testów wydajności i drugie podejście było zawsze lepsze od pierwszego.

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

wygląda lepiej na oczach, ale adapter danych działa lepiej (nie należy mylić, że jedna baza danych była lepsza od drugiej, wszystkie zapytania były różne). Jednak różnica między nimi zależała od prośby. Przyczyną może być to, że

Load

wymaga sprawdzania różnych ograniczeń wiersz po wierszu

z dokumentacji
http://msdn.microsoft.com/en-u ... .aspx
podczas dodawania wierszy (jest to metoda w

DataTable

), podczas gdy

Fill

jest na DataAdapters, które zostały zaprojektowane dokładnie do tego - szybkiego tworzenia DataTables.

Model wyśrodkowany: możesz go używać z dowolnego miejsca!
Wystarczy wywołać poniższy format z funkcji do tej klasy

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);

To wszystko. to jest idealna metoda.

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;

 }

 }