SqlDataReader vs SqlDataAdapter: lequel a la meilleure performance pour retourner un DataTable?
je veux savoir qui a la meilleure performance pour retourner un DataTable . Ici pour SqlDataReader j'utilise DataTable.Load(dr)
utilisant 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;
}
}
utilisant SqlDataAdapter :
public DataTable populateUsingDataAdapter(string myQuery)
{
SqlDataAdapter dap = new SqlDataAdapter(myQuery,cn);
DataSet ds = new DataSet();
dap.Fill(ds);
return ds.Tables[0];
}
5 réponses
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 ), et appelle sa méthode Fill : la performance sera très similaire à SqlDataAdapter.Fill(DataTable) .
il y aura quelques petites différences dans l'initialisation / validation des arguments, mais au fur et à mesure que le nombre de lignes augmentera, cela deviendra moins et de moins en moins importants.
Notez aussi que votre second é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;
}
}
cette question , et plus spécifiquement, cette réponse suggère que votre deuxième exemple est plus rapide. Il ne s'agit certainement pas d'un point de repère exhaustif, mais d'un test intéressant.
reflétant le code source de DataTable montre que l'appel DataTable.Load () crée en fait une sous-classe interne DataAdapter appelée LoadAdapter et appelle la méthode Fill() de DataAdapter . SqlDataAdapter , fait l'essentiel de son travail de chargement dans le même endroit exact.
plus important encore, j'aurais tendance à favoriser le second exemple pour la lisibilité. Ni exemple compare à l'accès rapide fournie par l'utilisation directe de la DataReader , donc j'opterais pour le nettoyeur de code.
SqlDataReader a toujours été beaucoup plus rapide que le SqlDataAdapter . Des améliorations ont peut-être été apportées dans .NET 4.5, mais je doute qu'elles aient été suffisantes pour dépasser les performances du lecteur de données.
SqlDataReader sera plus rapide que SQlDataAdapter parce qu'il fonctionne dans un état connecté qui signifie que le premier résultat est retourné de la requête dès que son disponible ..
en plus de la solution choisie, je voudrais ajouter que:
en utilisant le DataReader, vous n'avez pas besoin de savoir quel type de connexion db vous avez.
vous N'avez besoin que d'une instance qui implémente IDbConnection, avec laquelle vous pouvez utiliser "connection".CreateCommand" et ensuite " dbCommand.ExecuteReader " and then datable.Charge.
mais lorsque vous utilisez DataAdapter vous devez savoir quelle connexion est utilisée (i.e. oracle, sqlserver, etc.)
(ce N'est pas pertinent pour le thread starter, mais j'ai atterri ici en utilisant g**gle tout en cherchant ce sujet.)