Best practice für die Wiederverwendung SqlConnection

Habe ich von Java-Erfahrung und versuche zu starten mit C#. Ich habe gelesen, SqlConnection SqlCommand SqlDataReader IDisposable und ich kann verstehen, dass die beste Praxis, eine Verbindung zu einem DB-umbricht SqlConnection, SqlCommand und SqlDataReader im eigenen using block.

Aber in Java wir verwenden, um Kapseln die Verbindung in einer Fabrik-Methode, erstellen Sie nur einmal, und wiederverwenden es für alle Abfragen, auch Multithread-ones. Nur statements und Resultsets erstellt für jede Abfrage und so schnell wie möglich geschlossen.

Ist nicht die Schaffung einer neuen SqlConnection für jede Abfrage ein bisschen übertrieben? Kann es nicht wiederverwendet werden?

  • man könnte ein pooling-Mechanismus
  • msdn.microsoft.com/en-us/library/8xx3tyca%28v=vs.110%29.aspx
  • Die .net framework stellt die pooling-Mechanismus für Sie (das ist, warum die Beratung ist immer ein using block)
  • Stellen Sie sicher, dass Sie Fehler behandeln der Verbindung, und im Finally-block schließen. Sonst werden Sie wind-up mit verwaisten verbindungen, ziehen Sie Ihre Leistung nach unten.
  • nicht, wenn seine eingehüllt in einen using-block verwenden, versuchen Sie, schließlich ist nicht erforderlich.
InformationsquelleAutor Hikari | 2014-12-29
  1. 25

    Erstellen einer neuen Instanz der Klasse SqlConnection nicht erstellen Sie eine neue Netzwerk-Verbindung zu SQL-Server, aber leases eine bestehende Verbindung an (oder erstellt einen neuen). .NET behandelt die physikalischen Verbindungs-pooling für Sie.

    Wenn Sie fertig sind mit Ihrer Verbindung (durch die Sie können senden mehrere Abfragen) nur Close() oder Dispose() (oder verwenden Sie eine using{} block vorzugsweise).

    Gibt es keine Notwendigkeit, und nicht gute Praxis, um die cache-Instanzen der SqlConnection Klasse.

    • Gilt für MS SQL. Getestet mit MySQL - die Wiederverwendung von verbindungen gibt erhebliche performance-Gewinn. Allerdings - eigenen "connection-pool" wird benötigt, um die Operationen thread-sicher. Der Zugriff auf connection-Objekt aus einem anderen thread eine Ausnahme ausgelöst. Also für MySQL habe ich die Wiederverwendung von verbindungen für die gleichen ManagedThreadId.
    • seine eine Schande, dass die MySql-Bibliothek-Autoren nicht zu Folgen, die bereits vorhandenen SqlClient-Methodik, aber froh, dass du darauf hingewiesen.
    InformationsquelleAutor PhillipH
  2. 6

    MS SQL server verwaltet die verbindungen in einem eigenen Verbindungs-pool, und Sie sind nicht wirklich entsorgt. Aber Sie sind geschlossen, so dass Sie den Netzwerkverkehr minimieren, und lassen Sie die verfügbaren verbindungen auf Ihrem server.

    Sie sollten auch beachten, dass, wenn Sie mithilfe der Linq-To-SQL, die Daten Kontext wird nicht lassen Sie die Verbindung, bis Sie entsorgt werden, so schlage ich vor, Sie verwenden bereits funktionierenden code und versuchen Sie nicht, es zu optimieren, durch sich selbst.

    • Ich glaube, es ist die .Net-client anstatt der server, der die Verwaltung dieser verbindungen und diese zu bündeln, als erforderlich.
    • "und Sie sind nicht wirklich entsorgt. Aber Sie sind geschlossen" - anders herum; Sie werden entsorgt (wenn Sie richtig mit using, etc), und ganz vielleicht garbage Collection (nicht-determinstic etc), aber zugrunde nicht verwaltete Verbindung bleibt open
    • Danke. Ich glaube nicht, verwenden Sie Linq, es ist Müll. Ich benutze rein und optimierten SQL.
    • Darauf zu erklären downvote?
    InformationsquelleAutor VMAtm
  3. 3

    Als VMAtm gesagt hat .net-Pools die verbindungen auf eigene, so ist es vollkommen ok, um Sie neu erstellen. Als solche habe ich in der Regel schreiben Sie ein wrapper für den gesamten Prozess, wie dieser.

            public static void RunWithOpenSqlConnection(string connectionString, Action<SqlConnection> connectionCallBack)
    {
        SqlConnection conn = null;
        try
        {
            conn = new SqlConnection(connectionString);
            connectionCallBack(conn);
        }
        catch (Exception ex)
        {
            //Log Error Here
        }
        finally
        {
            if (conn != null)
                conn.Dispose(); //will close the connection
        }
    }

    public static void ExecuteSqlDataReader(string connectionString, string sqlCommand, Action<SqlDataReader> readerCallBack)
    {
        RunWithOpenSqlConnection(connectionString, delegate(SqlConnection conn)
        {
            SqlCommand cmd = null;
            SqlDataReader reader = null;
            try
            {
                cmd = new SqlCommand(sqlCommand, conn);
                reader = cmd.ExecuteReader();
                readerCallBack(reader);
            }
            catch (Exception ex)
            {
                //Log Error Here
            }
            finally
            {
                if (reader != null)
                    reader.Dispose();
                if (cmd != null)
                    cmd.Dispose();
            }
        });
    }

//Example calling these
            ExecuteSqlDataReader(ConfigurationManager.ConnectionStrings["myConnectionString"].ConnectionString, "Select EmployeeID FROM Employees;", delegate(SqlDataReader reader)
        {
            List<string> employeeIds = new List<string>();
            if (reader.HasRows)
            {
                while(reader.Read())
                {
                    employeeIds.Add((string)reader[0]);
                }
            }
        });
    • Natürlich könnte man einfach eine Micro-ORM wie Peta Poco und machen Sie Ihre ganze Welt 100* einfacher, ohne all die Ansammlung von Entity Framework.
    • sehr schöne Hülle, würde gerne sehen, ob es verwendet werden kann als ein singleton, von Ihnen positiv bewertet werden!
    • Wir haben verändert diese viel, da ich dies schrieb. Ich werde versuchen zu erinnern, zu posten, ein besseres Beispiel irgendwann bald. Im Grunde aber haben wir warfed in so etwas wie "GetListFromProc<MyThing>(storedProcName, getItemFromReader); gibt eine Liste von MyThing und getItemFromReader ist eine Funktion, get übergeben die SqlDataReader-Zeile, wo Sie instanziieren MyThing und gibt es zurück.
    InformationsquelleAutor Ryan Mann
  4. 1

    Beantworten Ihre spezifische Frage, die Sie wiederverwenden können eine SqlConnection für jede Abfrage. So stellen Sie sicher, schließen Sie Ihre aktuelle Abfrage (SqlDataReaderusw.) bevor Sie einen anderen auszuführen, dh. wickeln Sie Sie in Ihren eigenen using Blöcke.

    InformationsquelleAutor ElGavilan
  5. -2

    Ja, können Sie eine Globale SqlConnection-Instanz. In meinem Fall habe ich die Verwendung der SqlConnection-als Mitglied meiner DataContext, dass ich den Zugriff über Singleton.

    public class DatabaseDataContext : DataContext
{
    private static DatabaseDataContext instance;
    private SqlConnection sqlConnection;        
    private SqlTransaction sqlTransaction;

    //...

    public static DatabaseDataContext Instance
    {
        get
        {
            return instance ?? (instance = new DatabaseDataContext(connectionString));
        }
        set
        {
            instance = value;
        }
    }
}

    Können Sie Kapseln Ihre Transaktionen durch das schließen und öffnen dieser Verbindung, D. H.:

    DatabaseDataContext.Instance.sqlConnection.Open();

//your transactions...

sqlConnection.Close();

    Oder Sie können die Verbindung offen lassen, sondern insbesondere Beginn und Ende von Transaktionen:

    DatabaseDataContext.Instance.sqlConnection.Open();

sqlTransaction = sqlConnection.BeginTransaction("Example Insert users");

try{
    //...your first transaction

    sqlTransaction.Commit();
}
catch{sqlTransaction.Rollback();}

sqlTransaction = sqlConnection.BeginTransaction("Update baked breads");

try{
    //...your second transaction

    sqlTransaction.Commit();
}
catch{sqlTransaction.Rollback();}

//Close the connection at some point
sqlConnection.Close();
    • Ich denke, das ist eine falsche Herangehensweise. Erstens gibt es keinen Vorteil für die Zwischenspeicherung einer SqlConnection-Instanz im code - Rahmen die es für Sie tut, und zweitens verhindert es die multi-threaded Verwendung der DbContext, die Sie erstellt haben.
    InformationsquelleAutor Flaudre
Schreibe einen Kommentar