Hallo,
ich habe mich heute mal dran gesetzt ein Tutorial zuerstellen, mit dessen Hilfe man via PHP-Skript auf eine MySQL-Datenbank zugreifen kann.
Hierzu sind Grundkenntnisse in der Programmierung von PHP und VB.Net von Vorteil.
Dieses Tutorial erklärt Schritt für Schritt den Aufbau des Codes und worauf zu achten ist.
Vorausgesetzt ist eine Datenbank (Spalten können unten entnommen werden)
Zuerst benötigen wir eine weitere Datei:
[Beta]HttpPostRequest (Danke an Dodo)
Nun erstellen wir eine Form. Auf dieser müssen folgende Elemente vorhanden sein:
txtName
txtNachname
txtAnrede
txtStraße
txtNr
cmdSelect
cmdInsert
lsvHaupt
Zuerst müssen wir eine Klasse erstellen, mit der wir den Zugriff auf die Datenbank regeln.
Diese nennen wir cls_Datenbankzugriff.
In dieser setzen wir zu Beginn die Imports:
|
Visual Basic Quellcode
|
1
|
Imports HttpPostRequestLib.Net
|
Danach die eigentliche Funktion:
|
Visual Basic Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
Public Class cls_Datenbankzugriff
''' <summary>
''' Verbindet zu einer MySQL-Datenbank und gibt die angeforderten Daten zurück.
''' </summary>
''' <param name="vPostCollection">Erforderlich. Die Parameter welche an das PHP-Script geschickt werden.</param>
''' <param name="File">Erforderlich. Die Datei auf welcher der Befehl ausgeführt werden soll.</param>
''' <param name="Fehlerausgabe">Optional. Gibt an, ob die Fehlerausgabe Aktiviert ist.</param>
''' <returns>Gibt den Rückgabewert des PHP-Scripts zurück.</returns>
''' <remarks></remarks>
Public Function Zugriff(ByVal vPostCollection As PostCollection, ByVal File As String, Optional ByVal Fehlerausgabe As Boolean = True)
Try
Dim myrequest As New HTTPPostRequest
Dim Ergebnis As String = myrequest.Create(IO.Path.Combine("http://www.DeineSeite.de/DeinProgramm", File), vPostCollection)
Return Ergebnis
Catch ex As Exception
If Fehlerausgabe = True Then 'Wenn Fehlerausgabe aktiv, den Fehler Ausgeben
MessageBox.Show("Folgender Fehler ist aufgetreten: " & vbNewLine & ex.Message, "Fehler!", MessageBoxButtons.OK, MessageBoxIcon.Error)
End If
Return "Verbindungsfehler"
End Try
End Function
End Class
|
Im Parameter vPostCollection wird die PostCollection angegeben, welche die Daten enthält, die wird zur Datenbank schicken möchten. Dazu später mehr.
Der Parameter File gibt die Datei an, in welcher die SQL-Abfrage auf dem Server stattfindet.
Der letze Parameter Fehlerausgabe wird genutzt um die Fehlerausgabe zu aktivieren.
In dieser Klasse muss auch der Link zu dem Ordner angegeben werden, in welchem das PHP-Skript liegt (In diesem Fall "http://www.DeineSeite.de/DeinProgramm").
Als nächstes müssen wir eine Liste erstellen, in der die Rückgabewert geschrieben werden:
Die machen wir in einer Klasse:
|
Visual Basic Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
'Die Klasse cls_ExtentedList:
Public Class cls_ExtentedList
'Die einzelnen Daten-Spalten
Public ID As Integer
Public Name As String
Public Nachname As String
Public Anrede As String
Public Straße As String
Public Nr As Integer
''' <summary>
''' Gibt die angegebenen Daten zurück, um diese in die Liste einzufügen
''' </summary>
''' <returns></returns>
''' <remarks></remarks>
Public Overrides Function ToString() As String
Return ID & " - " & Name & " - " & Nachname & " - " & Anrede & " - " & Straße & " - " & Nr
End Function
End Class
|
Nun muss auf der Form eine Liste erzeugt werden, welche auf die obrige Klasse zugreift:
|
Visual Basic Quellcode
|
1
|
Public vListe As New List(Of cls_ExtentedList) 'Liste mit den Daten aus der Datenbank
|
Der nächste Schritt besteht darin, den Aufruf zur Datenbank zu starten. Hierzu gehen wir in unsere Form und in das cmdSelect_Click-Event.
Hier muss die Verbindung zur Klasse cls_Datenbankzugriff hergestellt werden:
|
Visual Basic Quellcode
|
1
2
3
4
|
'Select ausführen
'Verbindung definieren
Dim Verbindung As cls_Datenbankzugriff
Verbindung = New cls_Datenbankzugriff
|
Danach muss die PostCollection definiert werden.
In dieser werden die Übergabeparameter zum PHP-Skript übergeben:
|
Visual Basic Quellcode
|
1
2
3
|
Dim myCollection As New PostCollection
'Parameter für das PHP-Script
myCollection.Add("SQLQuery", "select_all")
|
Den genauen Ablauf sieht man im Skript.
Nun kann die Verbindung zur Datenbank aufgebaut werden:
|
Visual Basic Quellcode
|
1
2
|
'Verbindung aufbauen und Daten holen/übergeben
Dim Rückgabewert As String = Verbindung.Zugriff(myCollection, "Abfrage.php", False)
|
Logischerweise benötigen wird hierzu auch das PHP-Skript:
Dazu benötigen wir 3 Dateien.
Abfrage.php - Hier werden die eigentlichen SQL-Befehle ausgeführt
Connection_inc.php - Hier werden die Verbindungsdaten zur Datenbank gespeichert
Function_inc.php
Zur Connection_inc.php:
|
PHP-Quelltext
|
1
2
3
4
5
6
|
<?php
header('content-type: text/html; charset=utf-8');
//Datenbankdaten angeben
mysql_connect("Host","Benutzer", "Passwort"); //Zugangsdaten angeben (Host, Benutzer, Passwort)
mysql_select_db("Datenbank"); // Datenbank angeben
?>
|
Zur Function_inc.php:
|
PHP-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
<?php
//Funktion zum Abfragen ob ein Fehler aufgetreten ist
function dbAbfrage($abfrage)
{
$ergebnis = mysql_query($abfrage);
if(!$ergebnis) //Ist ein Fehler aufgetreten?
{
echo mysql_error(); //Den Fehler ausgeben
}
return $ergebnis;
}
?>
|
Zur Abfrage.php:
Zuerst werden die beiden oben genannten Dateien importiert.
Danach wird via Switch der Parameter "SQLQuery" abgefragt.
Jenachdem welchen Wert dieser Parameter hat, wird ein anderer Befehl ausgeführt. (Hier Select und Insert)
Hier hat der Parameter "SQLQuery" den Wert "select_all"
|
PHP-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
<?php
//ini_set("display_errors", false);
include("Connection_inc.php");
include("Function_inc.php");
//SQL-Abfrage wählen
switch ($_POST['SQLQuery'])
{
case "select_all": //Alle Einträge holen
$abfrage = "SELECT * FROM Tabelle";
$ergebnis = dbAbfrage($abfrage);
if($ergebnis == FALSE) //Ist ein Fehler aufgetreten?
{
echo mysql_error(); //Den Fehler ausgeben
}
elseif (is_resource($ergebnis)) //SQL-Befehl ist SELECT...
{
if (mysql_num_rows($ergebnis) == 0)
{
echo "Keine passenden Einträge vorhanden."; //Wenn keine Zeile vorhanden, 0 zurückgeben
}
else
{
while($row = mysql_fetch_assoc($ergebnis)) //Jede Reihe durchlaufen
{
echo (implode("ΛΜΝ", $row)) . "ΡΣΤ"; //hier wird das Array $row implodiert mit , als seperator - ΡΣΤ wird zur Zeilentrennung, ΛΜΝ wird zur Spaltentrennung genutzt
}
}
}
break;
case "insert": //Einträge eintragen
$abfrage = "INSERT INTO Tabelle (name, nachname, anrede, strasse, nr)
VALUES
('" . mysql_real_escape_string($_POST['name']) . "',
'" . mysql_real_escape_string($_POST['nachname']) . "',
'" . mysql_real_escape_string($_POST['anrede']) . "',
'" . mysql_real_escape_string($_POST['strasse']) . "',
'" . mysql_real_escape_string($_POST['nr']) . "')";
if (dbAbfrage($abfrage))
{
echo "Eintrag erfolgreich eingetragen.";
}
else
{
echo "Eintrag nicht eingetragen.";
}
break;
}
?>
|
Wenn wir nun alles speichern und hochladen haben können wir dies schonmal testen.
Jedoch werden wir feststellen, das es noch nicht so funktioniert wie wir es möchten.
Die Daten werden nicht in die ListView übergeben.
Dies machen wir nun.
|
Visual Basic Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
If Rückgabewert = "Verbindungsfehler" Then 'Ist ein Verbindungsfehler aufgetreten
'Nichts machen, da die Meldung schon vom Verbinden angezeigt wird
ElseIf Rückgabewert = "Keine passenden Einträge vorhanden." Then 'Keine Einträge vorhanden
MessageBox.Show("Keine passenden Einträge vorhanden.")
Else
'Zeilen und Spalten auflösen und in vListe einfügen
Call Splitten(Rückgabewert, vListe, 0, 2, 3, 1, 4, 5)
'Hier muss die Reihenfolge festgelegt werden,
'in welcher die Spalten vom PHP-Script zurückgegeben werden.
'In ListView einfügen
For i As Integer = 0 To vListe.Count - 1
lsvHaupt.Items.Add(New ListViewItem(New String() {vListe(i).ID, vListe(i).Name, vListe(i).Nachname, vListe(i).Anrede, vListe(i).Straße, vListe(i).Nr}))
Next
End If
|
Es wird Abgefragt, ob Fehler bei der Verbindung aufgetreten sind.
Sollten keine Fehler aufgetreten sein, werden die Daten in die ListView geschrieben.
Jedoch müssen wir die zurückgegebenen Daten zuerst getrennt werden, da wir diese als kompletten String zurück bekommen.
Das heist wird müssen Zeilen und Spalten trennen.
Die geschieht in der Prozedur Splitten:
|
Visual Basic Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
|
''' <summary>
''' Teilt einzelne Spalten und Zeile auf und fügt diese einer Liste hinzu.
''' </summary>
''' <param name="Source">Der String der gesplittet werden soll.</param>
''' <param name="Liste">Die cls_ExtendetList in der die Spalten gespeichert werden sollen.</param>
''' <param name="Spalte_ID">Gibt den Index der Spalte ID an.</param>
''' <param name="Spalte_Name">Gibt den Index der Spalte Titel an.</param>
''' <param name="Spalte_Nachname">Gibt den Index der Spalte Beschreibung an.</param>
''' <param name="Spalte_Anrede">Gibt den Index der Spalte Code an.</param>
''' <param name="Spalte_Straße">Gibt den Index der Spalte Sprache an.</param>
''' <param name="Spalte_Nr">Gibt den Index der Spalte Anhang an.</param>
''' <remarks></remarks>
<STAThread()> _
Public Sub Splitten(ByVal Source As String, ByVal Liste As List(Of cls_ExtentedList), _
Optional ByVal Spalte_ID As Integer = -1, _
Optional ByVal Spalte_Name As Integer = -1, _
Optional ByVal Spalte_Nachname As Integer = -1, _
Optional ByVal Spalte_Anrede As Integer = -1, _
Optional ByVal Spalte_Straße As Integer = -1, _
Optional ByVal Spalte_Nr As Integer = -1)
Liste.Clear()
'Die Zeilen teilen
Dim vZeile As String()
vZeile = Split(Source, "ΡΣΤ")
'Die Spalten teilen
For i As Integer = 0 To vZeile.Count - 2
Dim vSpalte As String()
vSpalte = Split(vZeile(i), "ΛΜΝ")
Dim Eintrag As cls_ExtentedList
Eintrag = New cls_ExtentedList
If Not Spalte_ID = -1 Then 'Wenn die Spalte ID zugewiesen wurde...
Eintrag.ID = vSpalte(Spalte_ID)
End If
If Not Spalte_Name = -1 Then 'Wenn die Spalte Titel zugewiesen wurde...
Eintrag.Name = (vSpalte(Spalte_Name))
End If
If Not Spalte_Nachname = -1 Then 'Wenn die Spalte Nachname zugewiesen wurde...
Eintrag.Nachname = (vSpalte(Spalte_Nachname))
End If
If Not Spalte_Anrede = -1 Then 'Wenn die Spalte Anrede zugewiesen wurde...
Eintrag.Anrede = (vSpalte(Spalte_Anrede))
End If
If Not Spalte_Straße = -1 Then 'Wenn die Spalte Straße zugewiesen wurde...
Eintrag.Straße = vSpalte(Spalte_Straße)
End If
If Not Spalte_Nr = -1 Then 'Wenn die Spalte Nr zugewiesen wurde...
Eintrag.Nr = vSpalte(Spalte_Nr)
End If
Liste.Add(Eintrag) 'Werte in Liste einfügen
Next
End Sub
|
Wie im Code oben bereits beschrieben, muss hier Reihenfolge der Zurückgegebenen Spalten beachtet werden. Wie oben gezeigt, wird ID in die erste, Name in 2, Nachname in 3 Spalte usw der Liste geschrieben: "Call Splitten(Rückgabewert, vListe, 0, 2, 3, 1, 4, 5)"
Wird bei einem Parameter nichts angegeben, wird diese Spalte nicht in die Liste übernommen.
Danach wird in die ListView geschrieben.
Somit kann es nochmal getestet werden.
Wurde alles richtig gemacht, sollte es funktionieren und alle Daten der Datenbank anzeigen.
Beim Ändern der Datenbank muss in der Klasse cls_ExtentedList die Liste mit den Namen der Spalten geändert werden. Genauso in der Prozedur "Splitten". Hier müssen die einzelnen Spalten als Optionaler Parameter verändert und danach ebenfalls die If-Abfrage angepasst werden.
Das war nun der erste Teil.
Wenn ich die nächsten Tage Zeit habe, kommt noch ein Beispiel mit dem Einfügen von Daten in die Datenbank.
Dies wird nicht ganz so lang wie dieser Post, da der größte Teil hier beschrieben wurde und daran anknüpft.
Viel Spaß damit