ODBC Verbindung schließt sich automatisch?

[Brorecas]

Grüßt Euch.

Ich baue über VB.NET eine ODBC Verbindung auf und schreibe Datensätze in eine MYSQL DB.

Soweit klappt alles super, doch nach etlichen Datensätzen (immer unterschiedlich) bricht die Verbindung zur DB weg. Ich erhalte auch nur die Fehlermeldung das ich zum Ausführen des nächsten Inserts eine geöffnete Verbindung benötige (Status: closed). Ich hab schon im SQL Command mit Timeouts gespielt aber es ändert sich nichts. Woran kann das liegen?

So öffne ich die Verbindung:

Try

                ODBC_CONNECTION = New OdbcConnection(ODBC_CONNECTION_STRING)
                ODBC_CONNECTION.Open()
                ODBC_CONNECTION_OPEN = True

            Catch ex As Exception

                ODBC_CONNECTION_OPEN = False
                FEHLER_TEXT = "ODBC Verbindung konnte nicht geöffnet werden!"
                FEHLER_TEXT_SYSTEM = ex.ToString

            End Try

So verwende ich sie anschließend:

Try
           
            'Ausführen von SQL-Statements
            STR_SQL = SQL_STRING

            ODBC_SQL_COMMAND.Connection = ODBC_CONNECTION
            ODBC_SQL_COMMAND.CommandText = STR_SQL
            ODBC_SQL_COMMAND.CommandTimeout = 300
            ODBC_SQL_COMMAND.ExecuteNonQuery()
            ODBC_CONNECTION_CLOSE()
            ODBC_MANIPULATE = True

        Catch ex As Exception

            ODBC_MANIPULATE = False
            FEHLER_TEXT = "ODBC SQL konnte nicht ausgeführt werden!"
            FEHLER_TEXT_SYSTEM = ex.ToString

        End Try

Weis Jemand sagen woran es liegen kann? Ich weis hier echt nicht weiter!

PS: Auf den nativen Treiber kann ich nicht wechseln da der Zugang hier ausschlißlich über ODBC gelöst werden soll.

Vielen Dank schonmal für jeden Hinweis!

[vadym voytas]

[highlight=vb]
Dim queryString As String = "INSERT INTO yourTable (YourColumn) VALUES (YourValues)"
Dim command As New OdbcCommand(queryString)
Using connection As New OdbcConnection(connectionString)
command.Connection = connection
connection.Open()
command.ExecuteNonQuery()
End Using
[/highlight]

[Brorecas]

Vielen Dank für die Antwort.

Ich verstehe das jetz so:

Der Unterschied zu meinem Code ist, dass ich zuerst dem Command die Connection zuweise und anschließend die Connection öffne.

Worin liegt genau der Grund für dieses Vorgehen? Mein Code funktioniert ja "grundsätzlich".

Also was ist der Unterschied / Wirkung zwischen beiden Vorgehensweisen?

Ich möchte ja was dazulernen.

MfG Brorecas

[vadym voytas]

gute Frage.

bei ConnectionA.Open erhält ConnectionA eine Verbindung aus dem Verbindungspool oder erstellt eine neue.

bei command.ConnectionB = connectionA wird nur Referenz auf connectionA übergeben

Versuch mal deine Code wie Folgt zu ändern

            ODBC_SQL_COMMAND.Connection = ODBC_CONNECTION
            ODBC_SQL_COMMAND.CommandText = STR_SQL
            ODBC_SQL_COMMAND.CommandTimeout = 300
            ODBC_SQL_COMMAND.Connection.Open()
            ODBC_SQL_COMMAND.ExecuteNonQuery()

so müsste es auch funktionieren

[Jürgen Thomas]

Die Version mit Using ist unbedingt vorzuziehen. Unter NET sollte eine Verbindung nur so kurz wie möglich existieren (nicht nur: offen sein); den Rest erledigt (wie Vadym sagt) das ConnectionPooling. Durch den Using-Block ist dies sichergestellt. Jürgen

[vadym voytas]

Using ist einfach schöner, übersichtlicher und sicherer. Nicht mehr.

aber try cacth finally ist auch völlig korrekt

try
        connection.Open()
        command.ExecuteNonQuery()
catch
        ' Error Handling
finally
       if connection.State = connectinstate.open
       connection.close()

[Jürgen Thomas]

Using ist einfach schöner, übersichtlicher und sicherer. Nicht mehr.

Mehr nicht? Ich hätte das für drei sehr schwerwiegende Gründe gehalten.

aber try cacth finally ist auch völlig korrekt

Natürlich, sofern der Programmierer (wie du in deinem Beispiel) darauf achtet, die Connection sofort zu schließen und außerdem aufzulösen. Es gilt schließlich (vereinfacht gesagt): Bei allem, was IDisposable benutzt, ist Dispose auch wirklich "sofort" zu benutzen.

Das alles wird durch using vereinfacht und gesichert.

Also was ist der Unterschied / Wirkung zwischen beiden Vorgehensweisen?

Ich hoffe, Vadym und ich haben das durch unsere (eher akademische) Diskussion geklärt und nicht verschleiert.

Gruß Jürgen

[Brorecas]

Vielen Dank für Eure Erklärungen!

Ich denk die Vorteile hab ich nun begriffen.

Aber eins ist mir noch nicht ganz klar:

Ich habe mit meinem CODE Einzeldatensätze weggeschrieben (manchmal eben auch eine große Anzahl, also viel öffnen und schließen der Verbindung).

Das Öffnen der Verbindung hab ich in eine extra Funktion ausgelagert.

Das Schließen ebenso, in dieser Function verwende ich auch Dispose beim Schließen.

Den einzigen Unterschied den ich erstmal feststelle ist, das ich keinen Finaly Block habe und im Catch bzw. Finaly im Fehlerfall die Close Function nicht aufrufe. (werd das mal mit using umsetzen, aber verstanden hätt ich es trotzdem gern zur Gänze)

Aber solange kein Fehler passiert und er im Try Block bleibt spielt das doch keine Rolle oder? Der erste Fehler der passiert ist der beschriebene, solange bleibt er im Try Block. Und dort wird die Verbindung geöffnet und geschlossen. Deshalb verstehe ich den Abbruch noch nicht so richtig.

Wisst Ihr was ich meine?

PS: Ich habs nochmal überflogen, also mein Fehler ist, dass ich eine geöffnete Verbindung dem Command Objekt zuweise. Also ich muß erst die Verbindung initialisieren dann dem Comand zuweisen und anschließend öffnen. So wie es jetzt umgesetzt ist, würde ich dem Connectionpool immer eine neue Verbindung mitgeben, eben solange bis er sagt ich will nicht mehr. Richtig verstanden? Hm da muß ich mal komplett über meine Klasse nachdenken, so klappt mein Plan mit der Fehlerbehandlung nicht.

Gruß Brorecas

[Jürgen Thomas]

Du hast recht:

Hm da muß ich mal komplett über meine Klasse nachdenken, so klappt mein Plan mit der Fehlerbehandlung nicht.

Deswegen will ich nicht noch einmal dazwischenreden, nur noch diese Gedanken:

* Wenn du viele Datensätze "am Stück" übertragen willst, ist selbstverständlich das einmalige Öffnen der Verbindung vorher und das Schließen am Schluss in Ordnung.
* Ich bin mir nicht sicher, ob du die try-Konstruktion richtig hast. Close und Dispose gehören in der Regel in den finally-Block, nicht in try.
* Ob die Connection dem Command zugewiesen wird oder umgekehrt, spielte keine Rolle. Es handelt sich um je eine Instanz zweier Klassen, die zusammenarbeiten müssen.

Gruß Jürgen