Le lecteur de données est-il plus rapide que le jeu de données lors du remplissage d'une base de données?

Qui serait plus rapide.

1) la Boucle à un datareader et la création d'une coutume des lignes et des colonnes en fonction peuplée datatable

2) Ou la création d'un objet dataAdapter et juste (.Remplir)ing un datatable.

La performance d'un datareader est toujours vrai lors de la création dynamique d'un datatable?

9

Le DataAdapter utilise un DataReader sous le capot de sorte que votre expérience aurait probablement le même.

Le bénéfice de la DataAdapter est de couper beaucoup de code qui aurait besoin d'entretien.

Ce débat est un peu une question de religion, donc certainement regarder autour et de décider ce qui fonctionne le mieux pour votre situation:
11

En supposant que vous voulez vraiment toutes les données provenant de la base de données, le temps pris à la base de données et sur le réseau est presque certain que les nains du temps pris en cours de processus pour remplir des structures de données en mémoire.

Oui, dans certains cas, vous pouvez avoir une petite économie en utilisant les DataReader - et, en particulier, si vous souhaitez transmettre les données, il peut être utile - mais si vous n'avez réellement besoin de tout ça, je collerais avec le code le plus simple. Si vous croyez que le jeu de données de la population est à l'origine d'un important problème de performance, profil et puis essayer de l'améliorer.

Votre option #1 serait plus lent. Cependant, il existe une meilleure façon de convertir un datareader pour un datatable que l'ajout de lignes à la main:

DataTable dt = new DataTable();

using (SqlConnection conn = GetOpenSqlConnection())
using (SqlCommand cmd = new SqlCommand("SQL Query here", conn)
using (IDataReader rdr = cmd.ExecuteReader())
{
    dt.Load(rdr);
}

Je ne peux pas commenter sur la différence entre cela et l'aide .Fill().

3

Je ne peux pas parler pour remplir un datatable en soi, mais à l'aide d'un datareader est la plus efficace méthode de lecture.
2

Le datareader est plus rapide. Et si vous utilisez 2.0+ vous probablt n'avez même pas à utiliser un datatable. Vous pouvez utiliser une liste générique de votre objet.
1

C'est agréable d'avoir DataReader lorsque vous avez besoin par exemple de montrer les progrès de chargement de données. Dans le DataSet, vous ne pouvez pas faire quelque chose dans un milieu de chargement de données.

D'autre part DataSet est tout-en-un objet. Si l'ensemble de données est beaucoup plus lent. DataReader peut vous donner le coup de pouce supplémentaire dans des endroits dans votre code où les données de fonctionnement est très lent. Dans ces lieux, le modifier à partir d'un jeu de données pour DataReader. DataReader prend également moins de place en mémoire.

Oh bien sûr, il faut plus de temps pour le code de bonne DataReader, mais ça en vaut la peine. Par exemple, lorsque vous jouez avec des images ou de la musique à partir de la base de données.

Plus sur ce sujet dans MSDN Magazine
1

Comme beaucoup de ce genre de questions, la réponse est: ça dépend.

Si vous ne connaissez pas la structure de vos données avant et de la création d'TableAdapters à la volée, puis la dynamique DataTable serait plus efficace. Il y a une bonne affaire de génération de code impliqués dans la création d'un TableAdapter.

Toutefois, si vous connaissez la structure de vos données avant la question devient alors, Comment beaucoup de fonctionnalités dont j'ai besoin?

Si vous avez besoin d'un CRUD mise en œuvre puis il y a des économies réalisées par l'utilisation d'un TableAdapter plutôt que d'écrire tout ce que CRUD code vous-même. Aussi, la mise en œuvre de TableAdapter est OK (pas grand). Si vous avez besoin de quelque chose de plus efficace, alors vous feriez mieux d'utiliser nHibernate ou certains autres ORM.

Si vous n'avez pas besoin d'un CRUD de mise en œuvre (à savoir, c'est en lecture seule solution) et de connaître la structure de données à l'avant, alors vous aurez à tester l'efficacité d'un TableAdapter en lecture seule mise en œuvre par rapport généré dynamiquement, un DataTable. Si j'étais un homme de pari, je mettrais mon argent sur le TableAdapter mise en œuvre puisque vous lier des données à la fois et de le lire plusieurs fois.

En passant par DataReader's Read qui est un avant uniquement, une ligne-à-un-temps approche, qui lit les données séquentiellement de façon à ce que vous obtenez des dossiers dès qu'ils sont lus lorsque connecté, sera le meilleur pour la mémoire et les performances.

Cela dit, entre les deux approches, je trouve IDataAdapter.Fill beaucoup plus rapide que DataTable.Load. Bien sûr, cela dépend des implémentations.. Voici un benchmark entre les deux que j'ai posté ici:

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

La deuxième approche toujours surclassé la première.

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 l'air mieux sur les yeux, mais les données de l'adaptateur fonctionne mieux (à ne pas confondre qu'un db surperformé les autres, les requêtes étaient tous différents). La différence entre les deux dépendait de la requête. La raison pourrait être que Load nécessite diverses contraintes à vérifier ligne par ligne à partir de la documentation lors de l'ajout de lignes (une méthode sur DataTable), tandis que Fill est sur DataAdapters qui ont été conçus pour que la création rapide des tables de données.

Vous devez vous connecter pour publier un commentaire.