Datenbankverbindung / Datenbankklasse

[monik.]

Hallo!

Ich entwickle ein Projekt, bei dem ich auf mehrere Tabellen in einer Datenbank zugreife. Meine Frage ist, ob ich bei jeder Anfrage jedesmal die Verbindung öffnen (und nach der Anfrage schließen) muss oder ob die Verbindung stets aufrecht erhalten bleibt?

Momentan habe ich es eben so gelöst, dass die Verbindung jedesmal aufs neue geöffnet wird, was auch funktioniert. Dazu greife ich auf meine selbstgebaute Datenbank-Klasse zu, zu der die Methoden open() und close() gehören. Bei jeder Abfrage rufe ich diese Methoden dann auf.

Ist das so korrekt oder ist die andere Lösung besser?

Was mich noch interessieren würde: Kann ich in meinen Datenbankklasse auch eine weitere Methode namens GetData (oder ähnlich) einfügen, sodass ich über diese Methode in allen anderen Programmteilen meine Daten holen kann?

Wie immer danke für eure Hilfe

[gfoidl]

Hallo,

ja - die Verbindungen sollten so schnell wie möglich wieder geschlossen werden und jedesmal geöffnent. Intern wird ein Connection-Pooling verwendet und dadurch wird es so am effizientesten.

Kann ich in meinen Datenbankklasse auch eine weitere Methode namens GetData (oder ähnlich) einfügen, sodass ich über diese Methode in allen anderen Programmteilen meine Daten holen kann?

Ich wieß nicht wie deine Klasse aufgebaut ist und welche Technologie sie zum DB-Zugriff vewendet.
Wenn es Linq2Sql, Ado.net EF, etc. ist dann ist ein Vorgehen gem. Repository-Pattern praktisch und darin hast du dann die Methode GetData. Siehe zB Using Repository and Unit of Work patterns


mfG Gü

[Ralf Jansen]

Ist das so korrekt oder ist die andere Lösung besser?

So spät wie möglich öffnen und und so früh wie möglich schließen ist normalerweise die bessere Methode (Ausnahmen bestätigen die Regel).

Das in Open Close Methoden auszulagern ist IMHO eher ungünstig. Oder liefert dir die Open Methode das Connection Object? Ungünstig weil eine DBConnetion normalerweise IDisposable implementiert und man dadurch durch einen using Block garantieren kann das am Ende des Blocks auch die Connection geschlossen wird.

Ein Standard Template für direkte DB Zugriffe über die ADO.NEt Klassen sähe ja in etwa so aus.

[Highlight=C#]using (SqlConnection con = new SqlConnection(meinLieberConnectionString))
{
con.Open();
using (SqlCommand cmd = new SqlCommand(con))
{
cmd.CommandText = meinLiebesCommando;
cmd.ExecuteBlah .....;
}
}[/Highlight]

Mit Open Close und einem oder mehreren finally Blocken wird das eher unleserlich oder sogar potentiell falsch weil man vergisst Close aufzurufen und/oder das Fehlerhandling diesbezüglich eine Lücke hat.

[monik.]

Hallo und danke für deine schnelle Antwort!

ich verwende System.Data.SqlClient...ist das ADO.NET? Ich kenne mich mit den Bezeichnungne dieser Technologien nicht so gut aus

Meine DB-Klasse ist folgendermaßen aufgebaut:

    public class DataBase
    {
        //Verbindung herstellen und trennen

        //Verbindungsdaten
        private static string myConnectionString = "******;";
        
        //Verbindung
        public static SqlConnection myConnection = new SqlConnection(myConnectionString);
        public static SqlCommand myCommand = new SqlCommand();
        
        //SQL-Statement
        private static string myCommandText;

        //Abfrage-Ergebnisse
        private static DataTable myResults;
     
        //Verbindung öffnen
        public void Connect()
        {
            if (myConnection.State != ConnectionState.Open)
            {
                myConnection.Open();
                myCommand = myConnection.CreateCommand();
                myCommand.Connection = myConnection;
                
                MessageBox.Show("Verbindung erfolgreich hergestellt.");
            }
        }

        //Datenbank-Abfrage
        public static DataTable DoQuery(string query)
        {
            myResults = new DataTable();

            if (query == null)
            {
                return myResults;
            }

            myCommandText = query;
            return myResults;
        }

        //Verbindung trennen
        public void Close()
        {
            if (myConnection.State != ConnectionState.Closed)
            {
                myConnection.Close();
                myConnection.Dispose();
            }
        }
    }
}

Ich hatte da schon mal einen Ansatz mit einer GetData-Methode versucht. Allerdings schreibe ich die Daten doch in jedem Programmteil meist in ein DataSet o.ä. Wie realisiere ich das über diese Klasse? Im Prinzip müsste ja die Methode GetData() aufgerufen werden und dann das DataSet zurückgeben, oder?

Das mit dem Repository werde ich mir heute abend nochmal anschauen, da ich mir darunter leider rein gar nix vorstellen kann.

[Ralf Jansen]

ich verwende System.Data.SqlClient...ist das ADO.NET? Ich kenne mich mit den Bezeichnungne dieser Technologien nicht so gut aus

Die DB Klassen aus System.Data laufen üblicherweise unter dem Titel ADO.Net. Wir reden also vom selben.

Wie realisiere ich das über diese Klasse?

Vermutlich würdest du das in deiner DoQuery Methode über eine SqlDataAdapter lösen wenn dein Ziel ein Dataset bzw. Datatable ist. Sieh dir mal dessen Oberfläche an insbesondere die Fill Methoden dann sollte dir auffallen wie du die Oberfläche deiner DoQuery Methode(n) am besten gestaltest.

Wenn du das hast solltest du dir dein Datanbank Klasse nochmal ansehen ob es nicht vielleicht einfacher ist die DB Klassen aus dem SqlClient Namespace direkt zu verwenden. Insbesondere wegen dem von mir im ersten Post angesprochenen Problem.

[monik.]

Vermutlich würdest du das in deiner DoQuery Methode über eine SqlDataAdapter lösen wenn dein Ziel ein Dataset bzw. Datatable ist. Sieh dir mal dessen Oberfläche an insbesondere die Fill Methoden dann sollte dir auffallen wie du die Oberfläche deiner DoQuery Methode(n) am besten gestaltest.

Das klingt einleuchtend und ich habe damit auch schon gearbeitet.

Wenn du das hast solltest du dir dein Datanbank Klasse nochmal ansehen ob es nicht vielleicht einfacher ist die DB Klassen aus dem SqlClient Namespace direkt zu verwenden. Insbesondere wegen dem von mir im ersten Post angesprochenen Problem.

Es gibt schon vorgefertigte Klassen? Naja...blöde Frage..ist eigentlich klar, dass es sowas schon gibt. Wie kann ich darauf zugreifen? Werde mich jetzt im laufe des Tages mal damit beschäftigen. Aber wie es klingt, bin ich schon auf nem ganz guten Weg :-)

Edit: Habe gerade mal etwas im Internet geschnarcht udn auch die Variante mit using... gefunden, so wie du sie oben beschrieben hast. Das ist doch genau der Zugriff auf den Namespace, oder?

[Ralf Jansen]

Es gibt schon vorgefertigte Klassen?

Ja. SqlConnection, SqlCommand, SqlDataReader etc. Was ich mit dem Hinweis auf die vorhandenen Klassen sagen wollte war das ich wenig Sinn sehe die nochmal in deiner Weise zu kapseln. Die bewegen sich schon auf einem relativen hohen abstrakten Niveau so das man die sehr gut direkt verwenden kann. Wenn man die nochmal kapseln will macht das eigentlich erst wieder Sinn wenn man die direkte Verwendung von SQL 'verstecken' will oder eine bestimmte Modelstruktur erzwingen möchte. Dann ist man bei einem fertigen ORM aber besser aufgehoben.

Das ist doch genau der Zugriff auf den Namespace, oder?

Nein. Ich meinte die using-Anweisung nicht die using-Direktive. Und die using-Direktive erlaubt nicht denn Zugriff auf den Namespace das kann man auch ohne. Die using-Direktive ist nur eine Hilfe damit man bei Typen nicht immer den voll qualifizierten Namen(System.Data.SqlClient.SqlConnection) schreiben muss sondern der Klassenname(SqlConnection) reicht.

[monik.]

Ich stehe leider auf dem Schlauch Wo kapsele ich die denn nochmal? Ich dachte, dass ich ganz normale Verwendung dieser Klassen, so wie ich es gemacht habe?

Meinst du damit, dass ich die nochmal in eigene Methoden (Open/Close) gepackt habe? So wie du es oben beschrieben hast, dass es ungünstig wäre?

[Ralf Jansen]

Meinst du damit, dass ich die nochmal in eigene Methoden (Open/Close) gepackt habe? So wie du es oben beschrieben hast, dass es ungünstig wäre?

Ja. .