web-dev-qa-db-fra.com

SqlDataReader vs SqlDataAdapter: lequel a la meilleure performance pour retourner un DataTable?

Je veux savoir lequel a la meilleure performance pour renvoyer un DataTable. Ici pour SqlDataReader j'utilise DataTable.Load(dr)

Utiliser SqlDataReader:

public static DataTable populateUsingDataReader(string myQuery)
{
    DataTable dt = new DataTable();
    using (SqlConnection con = new SqlConnection(constring))
    {
        SqlCommand cmd = new SqlCommand(myQuery, con);
        con.Open();
        SqlDataReader dr = null;
        dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
        if (dr.HasRows)
        {
            dt.Load(dr);
        }
        return dt;
    }
}

en utilisant SqlDataAdapter:

public DataTable populateUsingDataAdapter(string myQuery)
{
    SqlDataAdapter dap = new SqlDataAdapter(myQuery,cn);
    DataSet ds = new DataSet();
    dap.Fill(ds);
    return ds.Tables[0];
}
c#performancedatatablesqldatareadersqldataadapter
23
Satinder singh

La différence sera négligeable, il est donc probablement préférable d'utiliser la version plus concise: SqlDataAdapter.Fill.

SqlDataReader.Fill crée une classe interne LoadAdapter (dérivée de DataAdapter) en interne et appelle sa méthode Fill: les performances seront très similaires à SqlDataAdapter.Fill(DataTable).

Il y aura quelques petites différences d'initialisation/validation des arguments, mais à mesure que le nombre de lignes augmentera, cela deviendra de moins en moins significatif.

Notez également que votre deuxième échantillon doit être modifié pour être comparable au premier:

public DataTable populateUsingDataAdapter(string myQuery)
{
    using (SqlConnection con = new SqlConnection(constring))
    {
        SqlDataAdapter dap = new SqlDataAdapter(myQuery,con);
        DataTable dt = new DataTable();
        dap.Fill(dt);
        return dt;
    }
}
23
Joe

Cette question , et plus précisément, cette réponse suggère que votre deuxième exemple est plus rapide. Ce n’est certainement pas une référence exhaustive, mais c’est un test intéressant.

Le fait de refléter le code source de DataTable montre que l’appel à DataTable.Load () crée en réalité une sous-classe DataAdapter interne appelée LoadAdapter et appelle la méthode Fill() de DataAdapter. SqlDataAdapter effectue la majeure partie de son chargement au même endroit.

Plus important encore, j'aurais tendance à privilégier le deuxième exemple de lisibilité. Ni l'un ni l'autre exemple ne se compare à l'accès rapide fourni par l'utilisation directe de la variable DataReader, je choisirais donc le code plus propre.

8
Tim Medora

SqlDataReader a toujours été beaucoup plus rapide que SqlDataAdapter. Des améliorations ont peut-être été apportées à .NET 4.5, mais je doute qu’il s’est suffisamment amélioré pour dépasser les performances de DataReader.

4
Rob Epstein

En plus de la solution choisie, j'aimerais ajouter que:

Avec DataReader, vous n’avez pas besoin de savoir quel type de connexion DbConnection vous avez.

Tout ce dont vous avez besoin est une instance qui implémente IDbConnection, avec laquelle vous pouvez utiliser "connection.CreateCommand" puis "dbCommand.ExecuteReader" puis dataTable.Load.

Mais lorsque vous utilisez DataAdapter, vous devez savoir quelle connexion est utilisée (par exemple, Oracle, sqlserver, etc.).

(Ce n'est pas pertinent pour le démarreur de fil, mais j'ai atterri ici en utilisant g ** gle en cherchant ce sujet.)

0
just_a_guest

SqlDataReader sera plus rapide que SQlDataAdapter car il fonctionne dans un état connecté, ce qui signifie que le premier résultat est renvoyé par une requête dès qu'il est disponible.

0
coder