Méthode la plus rapide pour SQL Server insertions, mises à jour, sélectionne

Cette réponse se concentre principalement sur 'select' vs mettre à jour/créer/supprimer des opérations. Je pense qu'il est plus rare de mettre à jour plus d'un ou de quelques enregistrements à la fois, et donc je pense aussi", sélectionnez " c'est là où les goulots d'étranglement ont tendance à se produire. Cela dit, vous devez connaître votre application (profil). Le meilleur endroit pour l'optimisation de votre temps est presque toujours au niveau base de données dans les requêtes elles-mêmes, plutôt que le code client. Le code du client est tout simplement de la plomberie: ce n'est pas la force principale de votre application. Cependant, comme la plomberie a tendance à être ré-utilisé dans de nombreuses applications différentes, je ne compatis avec le désir d'obtenir aussi près optimale que possible, et donc je ne m'ont beaucoup à dire sur la façon de générer ce code.

J'ai une méthode générique pour les requêtes select/procédures dans ma couche de données qui ressemble à quelque chose comme ceci:

private static IEnumerable<IDataRecord> Retrieve(string sql, Action<SqlParameterCollection> addParameters)
{
    //ConnectionString is a private static property in the data layer
    //You can implement it to read from a config file or elsewhere
    using (var cn = new SqlConnection(ConnectionString))
    using (var cmd = new SqlCommand(sql, cn))
    {
        addParameters(cmd.Parameters);

        cn.Open();
        using (var rdr = cmd.ExecuteReader())
        {
            while (rdr.Read())
                yield return rdr;
            rdr.Close();
        }
    }
}

Et qui me permet d'écrire des données publiques de la couche de méthodes qui utilisent des méthodes anonymes pour ajouter les paramètres. Le code ci fonctionne avec .Net 2.0+, mais peut être écrit de manière encore plus courte à l'aide .Net 3.5:

public IEnumerable<IDataRecord> GetFooChildrenByParentID(int ParentID)
{
    //I could easily use a stored procedure name instead of a full sql query
    return Retrieve(
        @"SELECT c.* 
         FROM [ParentTable] p 
         INNER JOIN [ChildTable] c ON c.ParentID = f.ID 
         WHERE f.ID= @ParentID", delegate(SqlParameterCollection p)
       {
          p.Add("@ParentID", SqlDbType.Int).Value = ParentID;
       }
     );
}

---

Je vais arrêter ici donc, je peux vous diriger à nouveau le code juste au-dessus qui utilise la méthode anonyme pour le paramètre de la création.

C'est très propre code, en ce qu'elle met la définition de la requête de paramètre et de la création dans le même endroit tout en vous permettant de faire abstraction de la passe-partout de connexion de base de données/code appelant à un endroit plus ré-utilisable. Je ne pense pas que cette technique est couvert par aucun des points de balle dans votre question, et il arrive à être sacrément rapide. Je pense que ce sujet couvre l'essentiel de votre question.

---

J'ai envie de continuer, même si, pour expliquer comment cela fonctionne ensemble. Le reste est assez simple, mais il est également facile de se débarrasser de cette à une liste ou similaires et de faire les choses mal, en fin de compte mal de performance. Donc, aller de l'avant, la couche de gestion utilise ensuite une usine de traduire les résultats de la requête aux objets (c# 3.0 ou ultérieure):

public class Foo
{
    //various normal properties and methods go here

    public static Foo FooFactory(IDataRecord record)
    {
        return new Foo
        {
            Property1 = record[0],
            Property2 = record[1]
            //...
        };
    }
}

Plutôt que d'avoir ces vivre dans leur classe, vous pouvez également les regrouper tous ensemble dans une classe statique spécifiquement destiné à tenir l'usine méthodes.

J'ai besoin de faire un changement à l'origine de récupérer de la méthode. Cette méthode de "rendements" le même objet, et ce n'est pas toujours bien. Ce que nous voulons faire différemment pour le faire fonctionner est de forcer une copie de l'objet représenté par l'enregistrement en cours, de sorte que lorsque le lecteur se transforme pour l'enregistrement suivant, nous travaillons avec des données "propres". J'ai attendu jusqu'à ce que après la présentation de la méthode de fabrique, de sorte que nous pouvons l'utiliser dans le code final. La nouvelle Récupérer méthode ressemble à ceci:

private static IEnumerable<T> Retrieve(Func<IDataRecord, T> factory,
                  string sql, Action<SqlParameterCollection> addParameters)
{
    //ConnectionString is a private static property in the data layer
    //You can implement it to read from a config file or elsewhere
    using (var cn = new SqlConnection(ConnectionString))
    using (var cmd = new SqlCommand(sql, cn))
    {
        addParameters(cmd.Parameters);

        cn.Open();
        using (var rdr = cmd.ExecuteReader())
        {
            while (rdr.Read())
                yield return factory(rdr);
            rdr.Close();
        }
    }
}

Et maintenant, nous dirions que les nouveaux Récupérer() la méthode comme ceci:

public IEnumerable<Foo> GetFooChildrenByParentID(int ParentID)
{
    //I could easily use a stored procedure name instead of a full sql query
    return Retrieve(Foo.FooFactory,
        @"SELECT c.* 
         FROM [ParentTable] p 
         INNER JOIN [ChildTable] c ON c.ParentID = f.ID 
         WHERE f.ID= @ParentID", delegate(SqlParameterCollection p)
       {
          p.Add("@ParentID", SqlDbType.Int).Value = ParentID;
       }
     );
}

Évidemment cette dernière méthode peut être étendue pour inclure toute logique métier supplémentaire nécessaire. Il s'avère également que ce code est exceptionnellement rapide, car il faut profiter de l'évaluation différée des fonctionnalités de l'interface IEnumerable. L'inconvénient est qu'il tend à créer un grand nombre d'objets éphémères, et qui peut nuire à la performance transactionnelle vous m'avez demandé. Pour contourner ce problème j'ai parfois briser les bon n-tier et de passer le IDataRecord directement les objets de la couche de présentation et d'éviter la création d'objet pour les enregistrements qui sont simplement lié à un contrôle de grille tout de suite.

Mise à jour/Créer un code est similaire, à la différence que vous êtes habituellement seulement l'évolution d'un enregistrement à un moment plutôt qu'à plusieurs.

Ou, je pourrais vous épargner la lecture de ce long post et juste vous dire d'utiliser Entity Framework 😉

OriginalL'auteur

Plus rapide pour l'exécution ou la plus rapide pour la programmation de l'heure? La seule chose que vous pouvez faire pour augmenter le débit sur le #1 est l'utilisation de plusieurs threads et les connexions à faire les inserts - vous pouvez le faire avec SQLCommand.BeginExecuteNonQuery

OriginalL'auteur Cade Roux

Ce n'est pas sur d'Insertion ou de mise à Jour, mais j'ai fait un peu d'analyse comparative pour les vitesses de Lecture avec des approches différentes. De toutes, DataTable itinéraires semblait plus lent de la grappe.. Joël approche est fondamentalement la manière la plus rapide que vous pouvez obtenir..

OriginalL'auteur nawfal