erste Klasse: SQL Klasse für weniger Aufwand

    • VB.NET

    Es gibt 7 Antworten in diesem Thema. Der letzte Beitrag () ist von zn-gong.

      erste Klasse: SQL Klasse für weniger Aufwand

      Hallo Leute ich arbeite derzeit an einem Projekt mit SQL verbindung und habe daher begonnen eine Klasse mit SQL Befhlen zu schreiben. Sie erleichtert das Arbeiten für nichtprofis in SQL und dient zu verkleinerung des Quellcodes. Da dies meine erste Klasse ist, ist sie nochnicht 100% vollständig und wird noch bearbeitet. Allerdings stelle ich den bisjetzt benutzbaren Teil hier Public.

      Bitte keine Posts mit: "Unnötig", "Sinnlos" etc. Wenn ihr sowas nicht braucht dann ist es so für alle anderen Kommentare mit neuen Ideen oder sonsitges würde mich freuen :)

      Klasse:

      Imports:

      VB.NET-Quellcode

      1. Imports System.Data.SqlClient


      Spoiler anzeigen

      VB.NET-Quellcode

      1. Public Class Isql
      2. #Region "Definitionen"
      3. 'MySQL Klasse für Daten
      4. Dim con = New SqlConnection
      5. Dim cmd As New SqlCommand
      6. #End Region
      8. 'Jede Funktion mit einem Try ausführen um Connection probleme oder eingabe fehler vorzubeugen!
      10. ' Connection aufbauen
      11. Public Sub FUNKTION_Verbinden()
      12. con.ConnectionString = My.Settings.connection ' In My.Settings neuen String erstellen name: connection und dort den COnnectionstring angeben
      13. If con.State = Data.ConnectionState.Open Then
      14. ElseIf con.State = Data.ConnectionState.Closed Then
      15. con.open()
      16. cmd.Connection = CType(con, SqlConnection)
      17. Else
      18. MsgBox("Verbindung zur Datenbank fehlgeschlagen!")
      19. End If
      20. End Sub
      22. 'Connection schließen
      23. Public Sub FUNKTION_Trennen()
      24. If con.State = Data.ConnectionState.Open Then
      25. con.Close()
      26. ElseIf con.State = Data.ConnectionState.Closed Then
      27. Else
      28. MsgBox("Fehler beim schließen der Verbindung! Bitte überprüfen sie alle Vorgänge!")
      29. End If
      30. End Sub
      32. ' In Datenbank abfragen machen
      33. ' eineSpalteAbfrageString( Tabelle [string], Spalte [string], AbfrageSpalte [string], Abfragewert [string] )
      34. Public Function FUNKTION_EineSpalteAbfrageString(ByVal Tabelle As String, ByVal Spalte As String, ByVal WoSpalte As String, ByVal SpalteIst_string As String) As String
      35. cmd.CommandText = "SELECT " & Spalte & " as meinergebnis FROM " & Tabelle & " WHERE " & WoSpalte & " = '" & SpalteIst_string & "'"
      36. Dim myreader = cmd.ExecuteReader
      37. Dim ergebnis As String = "Kein Ergebnis"
      38. While myreader.Read
      39. ergebnis = CStr(myreader("meinergebnis"))
      40. End While
      41. myreader.Close()
      42. Return ergebnis.ToString
      43. End Function
      45. ' In Datenbank abfragen machen
      46. ' eineSpalteAbfrageInteger( Tabelle [string], Spalte [string], AbfrageSpalte [string], Abfragewert [Integer]
      47. Public Function FUNKTION_EineSpalteAbfrageInteger(ByVal Tabelle As String, ByVal Spalte As String, ByVal WoSpalte As String, ByVal SpalteIst_integer As String) As Integer
      48. cmd.CommandText = "SELECT " & Spalte & " as meinergebnis FROM " & Tabelle & " WHERE " & WoSpalte & " = " & SpalteIst_integer
      49. Dim myreader = cmd.ExecuteReader
      50. Dim ergebnis As Integer = 0
      51. While myreader.Read
      52. ergebnis = CInt(myreader("meinergebnis"))
      53. End While
      54. myreader.Close()
      55. Return ergebnis
      56. End Function
      58. ' In Datenbank Zeile löschen
      59. ' eineSpalteLöschenStringSuche( Tabelle [string], Spalte [string], Abfragewert [string])
      60. Public Function FUNKTION_EineSpalteLöschenStringSuche(ByVal Tabelle As String, ByVal Spalte As String, ByVal SpalteIst_string As String) As Boolean
      61. cmd.CommandText = "DELETE FROM " & Tabelle & " WHERE " & Spalte & " = '" & SpalteIst_string & "'"
      62. Return CBool(cmd.ExecuteNonQuery())
      63. End Function
      65. ' In Datenbank Zeile löschen
      66. ' eineSpalteLöschenIntegerSuche( Tabelle [string], Spalte [string], Abfragewert [string])
      67. Public Function FUNKTION_EineSpalteLöschenIntegerSuche(ByVal Tabelle As String, ByVal Spalte As String, ByVal SpalteIst_Integer As String) As Boolean
      68. cmd.CommandText = "DELETE FROM " & Tabelle & " WHERE " & Spalte & " = " & SpalteIst_Integer
      69. Return CBool(cmd.ExecuteNonQuery())
      70. End Function
      72. 'In Datenbank Befehl ausführen
      73. ' ausführen( Querry [string] )
      74. Public Function FUNKTION_Ausführen(ByVal querry As String) As Boolean
      75. cmd.CommandText = querry
      76. Return CBool(cmd.ExecuteNonQuery())
      77. End Function
      79. 'In Datenbank String updaten
      80. ' updateString(Tabelle [string], diezuänderndespalte [string], neuerwert [string], inwelcherspalter [string], welcherInhaltgesucht [string])
      81. Public Function FUNKTION_UpdateString(ByVal Tabelle As String, ByVal SpalteFeldZuÄndern As String, ByVal neuerwert_string As String, ByVal WhereSpalte As String, ByVal Inhalt_string As String) As Boolean
      82. cmd.CommandText = "UPDATE " & Tabelle & " SET " & SpalteFeldZuÄndern & " = '" & neuerwert_string & "' WHERE " & WhereSpalte & " = '" & Inhalt_string & "'"
      83. Return CBool(cmd.ExecuteNonQuery())
      84. End Function
      86. 'In Datenbank Integer updaten
      87. ' updateInteger(Tabelle [string], diezuänderndespalte [string], neuerwert [string], inwelcherspalter [string], welcherInhaltgesucht [string])
      88. Public Function FUNKTION_UpdateInteger(ByVal Tabelle As String, ByVal SpalteFeldZuÄndern As String, ByVal neuerwert_Integer As String, ByVal WhereSpalte As String, ByVal Inhalt_Integer As String) As Boolean
      89. cmd.CommandText = "UPDATE " & Tabelle & " SET " & SpalteFeldZuÄndern & " = " & neuerwert_Integer & " WHERE " & WhereSpalte & " = " & Inhalt_Integer & ""
      90. Return CBool(cmd.ExecuteNonQuery())
      91. End Function
      93. ' In Datenbank mehrzeilen Ausgeben als Listof strings | Strings
      94. ' mehrzeilerausgeben(Tabelle [string], SpaltezuAusgabe[string](, WoSpalte[string], WoIst_String[String]))
      95. ' ACHTUNG GIBT EINE LISTE VON STRINGS ZURÜCK!
      96. Public Function FUNKTION_Mehrzeilerausgeben_String(ByVal Tabelle As String, ByVal SpaltezuAusgabe As String, Optional ByVal WoSpalte As String = "", Optional ByVal WoIst_String As String = "") As List(Of String)
      97. 'Definitionen
      99. Dim fundListe As New List(Of String)
      100. ' Check ob OK
      101. If WoSpalte = "" Or WoSpalte = " " Then
      102. If WoIst_String = "" Or WoIst_String = " " Then
      103. cmd.CommandText = "SELECT " & SpaltezuAusgabe & " as ergebnis FROM " & Tabelle
      104. ' In Liste eintragen
      105. Dim myreader = cmd.ExecuteReader
      106. While myreader.Read
      107. fundListe.Add(myreader("ergebnis"))
      108. End While
      109. myreader.Close() ' Reader schließen
      110. End If
      111. Else
      112. cmd.CommandText = "SELECT " & SpaltezuAusgabe & " as ergebnis FROM " & Tabelle & " WHERE " & WoSpalte & " = '" & WoIst_String & "'"
      113. ' In Liste eintragen
      114. Dim myreader = cmd.ExecuteReader
      115. While myreader.Read
      116. fundListe.Add(myreader("ergebnis"))
      117. End While
      118. myreader.Close() ' Reader schließen
      119. End If
      120. ' Was er zurück gibt ( Gibt Liste von Ergebnissen zurück )
      121. Return fundListe
      122. End Function
      124. ' In Datenbank mehrzeilen Ausgeben als Listof Integer | Integer
      125. ' mehrzeilerausgeben(Tabelle [string], SpaltezuAusgabe[string](, WoSpalte[string], WoIst_String[String]))
      126. ' ACHTUNG GIBT EINE LISTE VON INTEGERN ZURÜCK!
      127. Public Function FUNKTION_Mehrzeilerausgeben_Integer(ByVal Tabelle As String, ByVal SpaltezuAusgabe As String, Optional ByVal WoSpalte As String = "", Optional ByVal WoIst_Integer As String = "") As List(Of Integer)
      128. 'Definitionen
      130. Dim fundListe As New List(Of Integer)
      131. ' Check ob OK
      132. If WoSpalte = "" Or WoSpalte = " " Then
      133. If WoIst_Integer = "" Or WoIst_Integer = " " Then
      134. cmd.CommandText = "SELECT " & SpaltezuAusgabe & " as ergebnis FROM " & Tabelle
      135. ' In Liste eintragen
      136. Dim myreader = cmd.ExecuteReader
      137. While myreader.Read
      138. fundListe.Add(myreader("ergebnis"))
      139. End While
      140. myreader.Close() ' Reader schließen
      141. End If
      142. Else
      143. cmd.CommandText = "SELECT " & SpaltezuAusgabe & " as ergebnis FROM " & Tabelle & " WHERE " & WoSpalte & " = " & WoIst_Integer
      144. ' In Liste eintragen
      145. Dim myreader = cmd.ExecuteReader
      146. While myreader.Read
      147. fundListe.Add(CInt(myreader("ergebnis")))
      148. End While
      149. myreader.Close() ' Reader schließen
      150. End If
      151. ' Was er zurück gibt
      152. Return fundListe
      153. End Function
      155. ' In Tabelle Zeile(n) einfügen
      156. ' FUNKTION_EinfügenEineZeile_String( Tabelle[string], Item1[string](, Item2[string, item3[string], item4[string], item5[string]))
      157. Public Function FUNKTION_EinfügenEineZeile_String(ByVal Tabelle As String, ByVal Item1 As String, Optional ByVal Item2 As String = "", Optional ByVal item3 As String = "", Optional ByVal item4 As String = "", Optional ByVal item5 As String = "") As Boolean
      158. If Item2 = "" Or Item2 = " " Then
      159. cmd.CommandText = "INSERT INTO " & Tabelle & " VALUES ( '" & Item1 & "' )"
      160. Else
      161. If item3 = "" Or item3 = " " Then
      162. ' HIER ITEM 2 EINFÜGEN
      163. cmd.CommandText = "INSERT INTO " & Tabelle & " VALUES ( '" & Item1 & "', '" & Item2 & "' )"
      164. Else
      165. If item4 = "" Or item4 = " " Then
      166. 'Hier ITEM 3 EINFÜGEN
      167. cmd.CommandText = "INSERT INTO " & Tabelle & " VALUES ( '" & Item1 & "', '" & Item2 & "', '" & item3 & "' )"
      168. Else
      169. If item5 = "" Or item5 = " " Then
      170. 'HIER ITEM 4 EINFÜGEN
      171. cmd.CommandText = "INSERT INTO " & Tabelle & " VALUES ( '" & Item1 & "', '" & Item2 & "', '" & item3 & "', '" & item4 & "' )"
      172. Else
      173. 'HIER ITEM 5 EINFÜGEN
      174. cmd.CommandText = "INSERT INTO " & Tabelle & " VALUES ( '" & Item1 & "', '" & Item2 & "', '" & item3 & "', '" & item4 & "', '" & item5 & "' )"
      175. End If
      176. End If
      177. End If
      178. End If
      179. Return CBool(cmd.ExecuteNonQuery()) ' Gibt wieder ob erfolgreich oder fehlgeschlagen!
      180. End Function
      182. 'Tabelle löschen
      183. ' FUNKTION_TabelleLöschen(Tabelle[string]
      184. Public Function FUNKTION_TabelleLöschen(ByVal Tabelle As String) As Boolean
      185. cmd.CommandText = "DROP TABLE " & Tabelle & " "
      186. Return CBool(cmd.ExecuteNonQuery())
      187. End Function
      189. ' Mehrere Befhele ausführen ( In Reihenfolge )
      190. ' Es wird eine Liste aus strings mit QWuerrys benötigt
      191. ' Man bekommt einen Bericht zurück
      192. Public Function FUNKTION_ListeVonBefehlenAusführen(ByVal ListeMitQuerrys As List(Of String)) As String
      193. 'Definitionen
      194. Dim qcounter As Integer = 0
      195. Dim succescounter As Integer = 0
      196. Dim failcounter As Integer = 0
      198. Dim cmdstatus As Boolean = False
      199. For Each querry In ListeMitQuerrys
      200. qcounter += 1 ' Für jeden Querry Counter + 1
      201. cmd.CommandText = querry
      202. cmdstatus = CBool(cmd.ExecuteNonQuery()) ' Querry ausführen und speichern ob erfolgreich oder nicht
      203. If cmdstatus = True Then
      204. succescounter += 1 ' Neuer erfolgreicher Querry
      205. Else
      206. failcounter += 1 ' Neuer fehlerhafter Querry
      207. End If
      208. Next
      209. ' Bericht schreiben und abgeben
      210. Dim Bericht As String = " Von " & qcounter.ToString & " Befehlen konnten " & succescounter.ToString & " Befehle ausgeführt werden und " & failcounter.ToString & " nicht ausgeführt werden!"
      211. Return Bericht
      212. End Function
      213. End Class



      Ihr könnt alle funktionen mit sql.FUNKTION_ sehen und sie werden sich selber erklären.
      Es kommen noch viele Futures und addons

      Viel Spaß :)

      // Klassen fehler behoben + neue Funkionen

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Schlammy“ ()

      1. Bitte VB-Tag benutzen - aber richtig

      2. DbParameter verwenden!

      3. Die Funktionen scheinen mir einen Logik-Fehler zu enthalten, zB

        VB.NET-Quellcode

        1. Dim ergebnis As String = "Kein Ergebnis"
        2. While myreader.Read
        3. ergebnis = CStr(myreader("meinergebnis"))
        4. End While
        vom Reader werden mehrere Datensätze abgerufen, aber alle werden in dieselbe Ergebnis-Variable geschrieben, sodass bei Vorhandensein mehrerer Abfrage-Ergebnisse alle Datensätze bis auf den letzten verloren gehen.
        Für den Abruf eines EinzelErgebnisses sollteman Command.ExecuteScalar vorziehen.

      4. Insgesamt führt dieser Ansatz dazu, dass man sich jede Möglichkeit verbaut, Databinding für sich arbeiten zu lassen. Also einfache und intuitive Oberflächen wie zB die Samples in DB-Programmierung ohne Datenbank sind nicht möglich, wenn man hierauf aufbaut.

      Ein Tip noch (abgesehen von der Sinnhaftigkeit dieser Klasse):
      Du kommentierst immer über deinen Funktionen ein bisschen was.
      Mach drei Hochkomma (''') über dem Funktionsnamen dann macht dir VS automatisch einen XML-Kommentar welcher die Funktion beschreibt (Musst natürlich selbst dann ausfüllen).
      Somit hat der Benutzer wenn er die Funktion auswählt über IntelliSense eine genaue Definition.

      lg
      ScheduleLib 0.0.1.0
      Kleine Lib zum Anlaufen von Code zu bestimmten Zeiten

      Die Funktionen scheinen mir einen Logik-Fehler zu enthalten, zB






      VB.NET-Quellcode

      1. Dim ergebnis As String = "Kein Ergebnis"
      2. While myreader.Read
      3. ergebnis = CStr(myreader("meinergebnis"))
      4. End While




      vom Reader werden mehrere Datensätze abgerufen, aber alle werden
      in dieselbe Ergebnis-Variable geschrieben, sodass bei Vorhandensein
      mehrerer Abfrage-Ergebnisse alle Datensätze bis auf den letzten verloren
      gehen.
      Nein es ist richtig da ich das letzte ergebnis dass gefunden wird ausgegeben haben möchte

      Die variablen in den Befehlen können anhand der funktion erkannt werden. Falls ich mehr als ein Ergebnis haben möchte würde natürlich jeden fund in eine liste eintragen und diese abgeben ( was ich auch habe (mehrerezeilenausgeben))


      Insgesamt führt dieser Ansatz dazu, dass man sich jede
      Möglichkeit verbaut, Databinding für sich arbeiten zu lassen. Also
      einfache und intuitive Oberflächen wie zB die Samples in DB-Programmierung ohne Datenbank sind nicht möglich, wenn man hierauf aufbaut.
      Es ist ja auchnicht für DB-Programmierung ohne Datenbank ? Es ist für MySQL Datenbänke!


      Warum soll ich db-paramter nehmen? Dann funktioniert das alles nichtmehr so! Ich möchte gerne auf sqlclient bleiben wenn das unangemessen ist bitte den thread löschen. Danke

      Schlammy schrieb:

      Warum soll ich db-paramter nehmen?

      Weils 100000 mal übersichtlicher wird.
      Mach mal einen SQL wo du in der Where Klausel 30 Sachen abfragst. immer mit & Var1 & "...." & Var 2 & ....
      Dann wunderst du dich warum das Statement nicht funktioniert und hast einen Mörderspass bei der Fehlersuche.

      Such mal nach DB-Paramter hier im Forum (gibt glaub ich sogar ein Tut).

      lg
      ScheduleLib 0.0.1.0
      Kleine Lib zum Anlaufen von Code zu bestimmten Zeiten

      Schlammy schrieb:

      Es ist ja auchnicht für DB-Programmierung ohne Datenbank ?
      Ich habe die Beispiele aus DB-Programmierung ohne Datenbank als Beispiele für Oberflächen angeführt, nicht als Beispiele für DB-Programmierung.
      Und eine Benutzer-Oberfläche braucht jede DB-Anwendung, ob nun MySql dahinter steht oder sonstwas. Und mit deim Ansatz bekommst du die dort gezeigten Oberflächen einfach nicht hin, weil du dir Databinding grundlegend verbaust - so meinte ich das.

      Hallo,

      Ich bleibe leiber beim LINQ und bein EntryFramework. Das ist wircklich vei leinfacher. Deine Klasse ist vlt noch für CMD (Consolen Anwendungen) relativ gut zu gebrauchen aber für den rest ist es ein Fail.

      LG, Herbrich