Lire la table SQL dans C # DataTable

J’ai lu beaucoup de messages sur l’insertion d’un DataTable dans une table SQL, mais existe-t-il un moyen simple d’extraire une table SQL dans un .NET DataTable?

Ici, donnez un coup de feu (ceci est juste un 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() { ssortingng connSsortingng = @"your connection ssortingng here"; ssortingng query = "select * from table"; SqlConnection conn = new SqlConnection(connSsortingng); 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 ssortingng")) { da.Fill(table); } 

Beaucoup de façons.

Utilisez ADO.Net et utilisez le remplissage de l’adaptateur de données pour obtenir un 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); } 

Vous pouvez ensuite extraire la table de données du jeu de données.

Notez que le jeu de données de réponse avec voix haute n’est pas utilisé (il est apparu après ma réponse)

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

Ce qui est préférable au mien.

Je recommande fortement de regarder le framework d’entités bien que… l’utilisation de datatables et de jeux de données n’est pas une bonne idée. Il n’y a pas de sécurité de type sur eux, ce qui signifie que le débogage ne peut être effectué qu’au moment de l’exécution. Avec des collections fortement typées (que vous pouvez obtenir en utilisant LINQ2SQL ou un framework d’entités), votre vie sera beaucoup plus facile.

Edit: Peut-être que je n’étais pas clair: Datatables = good, datasets = evil. Si vous utilisez ADO.Net, vous pouvez utiliser ces deux technologies (EF, linq2sql, dapper, nhibernate, orm du mois) car elles se trouvent généralement au-dessus de ado.net. L’avantage que vous obtenez est que vous pouvez mettre à jour votre modèle beaucoup plus facilement à mesure que votre schéma change, à condition que vous disposiez du bon niveau d’abstraction en exploitant la génération de code.

L’adaptateur ado.net utilise des fournisseurs qui exposent les informations de type de la firebase database. Par exemple, par défaut, il utilise un fournisseur de serveur SQL, vous pouvez également connecter, par exemple, le fournisseur postgress de dévartage tout en ayant access au type vous permettre d’utiliser comme ci-dessus votre orm de choix (presque sans peine – il y a quelques bizarreries) – je pense que Microsoft fournit également un fournisseur d’oracle. Le but de ENTIEL est d’abstraire, dans la mesure du possible, de la mise en œuvre de la firebase database.

Version indépendante du fournisseur, qui repose uniquement sur les interfaces ADO.NET; 2 façons:

 public DataTable Read1(ssortingng query) where T : IDbConnection, new() { using (var conn = new T()) { using (var cmd = conn.CreateCommand()) { cmd.CommandText = query; cmd.Connection.ConnectionSsortingng = _connectionSsortingng; cmd.Connection.Open(); var table = new DataTable(); table.Load(cmd.ExecuteReader()); return table; } } } public DataTable Read2(ssortingng 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.ConnectionSsortingng = _connectionSsortingng; DataSet ds = new DataSet(); //conn is opened by dataadapter da.Fill(ds); return ds.Tables[0]; } } } } 

J’ai effectué des tests de performance et la deuxième approche a toujours surpassé la première.

 Stopwatch sw = Stopwatch.StartNew(); DataTable dt = null; for (int i = 0; i < 100; i++) { dt = Read1(query); // ~9800ms dt = Read2(query); // ~2300ms dt = Read1(query); // ~4000ms dt = Read2(query); // ~2000ms dt = Read1(query); // ~5700ms dt = Read2(query); // ~5700ms dt = Read1(query); // ~850ms dt = Read2(query); // ~600ms dt = Read1(query); // ~3900ms dt = Read2(query); // ~3700ms } sw.Stop(); MessageBox.Show(sw.Elapsed.TotalMilliseconds.ToSsortingng()); 

Read1 est plus Read1 sur les yeux, mais l’adaptateur de données est plus performant (ne pas confondre le fait qu’une db a surpassé l’autre, les requêtes étaient toutes différentes). La différence entre les deux dépend cependant de la requête. La raison pourrait être que Load requirejs que diverses contraintes soient vérifiées ligne par ligne à partir de la documentation lors de l’ajout de lignes (c’est une méthode sur DataTable ) alors que Fill est sur DataAdapters qui a été conçu uniquement pour la création rapide de DataTables.