<\/p>\n
Manfred Hoffbauer, Düsseldorf<\/b><\/p>\n
Mit den Assistenten und Editoren von Microsoft Access können Sie Abfragen, Formulare und Berichte entwerfen. Nach wenigen Mausklicks können Sie Daten eingeben, bearbeiten und drucken. Das sieht bei Visual Basic.NET anders aus. Hier führt kein Weg an der Eingabe von Programmcode vorbei. Aber auch hier gibt es Assistenten, die Ihnen das Leben leichter machen. Deshalb genügt der folgende Beitrag, um schon zu einer kleinen Adressverwaltung zu kommen.<\/b><\/p>\n
Diese Beitragsreihe zeigt Ihnen anhand einer Adressverwaltung, wie Sie mit .NET Formulare für den Zugriff auf eine Datenbank erstellen. In diesem ersten Teil erstellen Sie zunächst ein einfaches Formular mit einem Datenblatt zur Anzeige von Adressen. Sie können darin Adressen eingeben, ändern und löschen.<\/p>\n
Zur Programmierung einer Adressverwaltung mit Microsoft Visual Basic.NET benötigen Sie eine Datenbank und ein Programm. Als Datenbank bietet sich Microsoft Access an. Die Technik für den Datenzugriff auf eine Access-Datenbank wurde bereits in Heft 5\/2004 unter dem Stichwort ADO.NET beschrieben.<\/p>\n
Der vorliegende Beitrag beschäftigt sich hauptsächlich mit der Gestaltung einer Oberfläche für eine Adressverwaltung. Der Schwerpunkt liegt demnach auf dem Entwurf von Formularen und nicht auf der Datenzugriffstechnik.<\/p>\n
Die Beispieldaten zu diesem Beitrag befinden sich auf der Heft-CD in der .zip-Datei Adressen.zip. Die Beispieldatenbanken heißen Adress97.mdb und Adress00.mdb.<\/p>\n
Die folgenden Beispiele verwenden die kostenlose Entwicklungsumgebung von SharpDevelop.<\/p>\n
Nach dem Start des Programms sollten Sie ein neues Combine anlegen. Markieren Sie die Kategorie VBNET und die Schablone Windows-Anwendung. Damit veranlassen Sie SharpDevelop, einen Applikationsrumpf für Windows-Anwendungen anzulegen. Sie erkennen dies unter anderem daran, dass SharpDevelop der Combine ein leeres Formular hinzufügt und es automatisch die Assemblies System.Windows.Forms und System.Drawing importiert.<\/p>\n
![](\"..\/fileadmin\/_temp_\/{369311D9-FC5E-4208-8579-5F8E28FBF3BC}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Bild 1: Wählen Sie bei der Anlage der neuen Combine die Schablone Windows-Anwendung aus Liste.<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 2: Diesen Programmcode hat der Designer für Sie generiert.<\/span><\/b><\/p>\n Geben Sie den Text Adressen als Name der neuen Combine ein. Nach der Anlage der Combine zeigt SharpDevelop ein Fenster mit dem Programmcode von MainForm.vb. Hierbei handelt es sich um den Quellcode eines leeren Formulars.<\/p>\n Im Unterschied zu Microsoft Access verfügt ein in Microsoft Visual Basic.NET erstelltes Programm nicht über Systemtabellen mit Formularentwürfen. Jeder einzelne Bestandteil eines Formulars muss sich vielmehr in einem Programmbefehl widerspiegeln.<\/p>\n Der Programmcode beginnt mit drei Imports-Anweisungen. Sie importieren die Namespaces System, System.Drawing und System.Windows.Forms. Der Import der Namespaces System.Drawing und System.Windows.Forms ist nicht erforderlich, soll aber wohl die häufig benötigten Namespaces direkt verfügbar machen. Es handelt sich hierbei um eine Besonderheit von SharpDevelop. Wenn Sie mit Microsoft Visual Studio.NET ein neues Formular anlegen, wird standardmäßig nur der Namespace System importiert.<\/p>\n Die Namespace DefaultNamespace definiert einen Namespace namens DefaultNamespace für das Formular. Mit den nächsten zwei Anweisungen geht“s dann richtig los:<\/p>\n In .NET ist jedes Formular eine Objektklasse, die von der Basisklasse Form vererbt wurde. Die Basisklasse befindet sich im Namespace System.Windows.Forms, der bei der Inherits-Anweisung mit angegeben wurde. Der Name der neuen Objektklasse lautet MainForm. Die nächsten vier Anweisungen definieren sozusagen das Hauptprogramm der Windows-Anwendung:<\/p>\n Beim Start eines Programms ruft .NET standardmäßig die Prozedur namens Main auf. Dies ist also der Einstiegspunkt der Anwendung.<\/p>\n SharpDevelop hat hier automatisch den Programmcode eingefügt, der der Variablen fMainForm eine Instanz der Objektklasse MainForm zuweist.<\/p>\n Mit der anschließenden ShowDialog-Methode wird das Formular zur Anzeige gebracht.<\/p>\n Falls Sie die Wirkung einmal ausprobieren wollen, starten Sie das leere Formular mit der F5-Taste. Der Programmablauf stoppt so lange, wie das Formular angezeigt wird. Wenn Sie das Formular schließen, führt .NET die Anweisung End Sub aus. Dies ist im Beispiel die letzte Anweisung des Programms.<\/p>\n Mit der Compileroption \/main können Sie auch einen anderen Einstiegspunkt markieren. Visual Studio.NET macht davon insofern Gebrauch, als Sie hier direkt ein Formular für den Programmstart angeben können. Es ruft den Compiler dann automatisch mit der entsprechenden Option auf. <\/p>\n Auf die Definition der Main-Prozedur folgt die Definition des Konstruktors für die Objektklasse MainForm. Dieser Programmcode wird immer dann aufgerufen, wenn Sie ein Objekt dieser Klasse instanzieren, also die New()-Methode aufrufen. Die Anweisung<\/p>\n ruft den Konstruktor der Basisklasse Form auf. Die zweite Anweisung<\/p>\n startet die Prozedur InitializeComponent. Sie finden diese Prozedur im Programmcode der Region Windows Forms Designer generated code. Mit einem Klick auf das Pluszeichen der Region decken Sie den verborgenen Programmcode auf. Die Prozedur enthält vier Anweisungen zur Definition des aktuellen Formulars:<\/p>\n Die beiden ersten Anweisungen definieren die AutoScaleBaseSize-Größe und die Größe des Formulars in Pixel. Die Eigenschaft Name definiert den Formularnamen und Me.Text den Text der Titelzeile.<\/p>\n Es sei an dieser Stelle ausdrücklich darauf hingewiesen, dass Sie den vom Designer automatisch generierten Programmcode nicht ändern dürfen. Eine änderung kann dazu führen, dass der Designer den Programmcode nicht mehr richtig interpretiert und deshalb die Möglichkeit zum Wechsel in die Designansicht verloren geht. Die Ursache hierfür besteht darin, dass die Programmiersprache Visual Basic.Net weit mehr Möglichkeiten bietet, als sich im Designer abbilden lassen.<\/p>\n Zum Test können Sie aber ausnahmsweise mal eine Ausnahme machen. ändern Sie die obige Anweisung wie folgt:<\/p>\n Achten Sie darauf, dass Sie wirklich die Text- und nicht die Name-Eigenschaft des Formulars ändern.<\/p>\n Am unteren Rand des Fensters MainForm.vb befindet sich die Registerlasche Design. Ein Mausklick auf die Registerlasche veranlasst SharpDevelop, das Design des Formulars anzuzeigen. Diese Ansicht ähnelt der Entwurfsansicht eines Formulars bei Microsoft Access.<\/p>\n SharpDevelop generiert die Designansicht vollständig aus dem Programmcode. Wie zu erwarten, wird der Text Adressen als Titelzeile des Formulars angezeigt. Falls Sie den Programmcode manuell so geändert haben, dass SharpDevelop ihn nicht mehr verstehen kann, zeigt es eine Fehlermeldung an.<\/p>\n Mit dem Menübefehl Ansicht\/Tools blenden Sie die Toolbox ein. Die Elemente der Toolbox sind gruppiert. Die für die Adressverwaltung interessanten Tools sehen Sie nach einem Klick auf den Balken Windows Forms.<\/p>\n Falls das Eigenschaftsfenster nicht sichtbar ist, brauchen Sie nur mit der rechten Maustaste auf einen leeren Bereich des Formularentwurfs zu klicken. Wählen Sie den Befehl Eigenschaften aus dem Kontextmenü. Die Bedienung von Toolbox und Eigenschaftsfenster erfolgt ähnlich wie bei Access.<\/p>\n Um das Formular mit Inhalt zu füllen, benötigen Sie Steuerelemente und Programmcode. Beides werden Sie in den kommenden Abschnitten zu einer kleinen Anwendung zusammenstellen. Am Ende verfügen Sie über ein Formular, mit dem Sie Adressen aus der Access-Datenbank in ein DataGrid-Steuerelement einlesen, dort bearbeiten und wieder in der zugrunde liegenden Tabelle speichern können.<\/p>\n <\/p>\n <\/b><\/p>\n Bild 3: Die Designansicht ähnelt dem Formularentwurf von Microsoft Access.<\/span><\/b><\/p>\n <\/b><\/p>\n Bild 4: Das Formular enthält ein DataGrid- und ein Button-Steuerelement.<\/span><\/b><\/p>\n Mit dem DataGrid-Steuerelement verfügt Microsoft .NET über eine ähnliche Darstellungsmöglichkeit für Daten wie die Datenblätter von Microsoft Access. Zur Anordnung eines solchen Steuerelements gehen Sie wie folgt vor:<\/p>\n Damit verfügen Sie über ein neues, leeres DataGrid-Steuerelement. Nun benötigen Sie noch den Programmcode, der das DataGrid-Steuerelement mit Daten füllt. Zur Anordnung des Programmcodes empfiehlt sich eine Schaltfläche. Um diese anzulegen, gehen Sie wie folgt vor:<\/p>\n Im nächsten Schritt müssen Sie dem Button Programmcode hinzufügen. Führen Sie dazu einen Doppelklick auf das Button-Steuerelement durch. Damit lösen Sie gleich mehrere Aktionen aus:<\/p>\n Quellcode 1<\/b><\/p>\n Die neu hinzugefügte Prozedur enthält noch keinen Programmcode. Auf den ersten Blick verwunderlich ist die Tatsache, dass die neue Prozedur keine offensichtliche Verbindung zu der Schaltfläche hat. Um das Geheimnis zu lüften, sollten Sie sich die Prozedur InitializeComponent noch einmal etwas genauer ansehen.<\/p>\n Der Designer hat hier jede Menge Programmcode hinzugefügt. Für jedes der beiden Steuerelemente finden Sie den Programmcode, der die Position, den Namen und weitere Eigenschaften definiert. Die Verbindung zwischen dem Button-Steuerelement und der Prozedur BtnLesenClick stellt die folgende Anweisung her:<\/p>\n Diese Anweisung fügt dem Programm einen so genannten Ereignishandler für das Ereignis Me.btnLesen.Click hinzu. Dieses Ereignis wird immer dann ausgelöst, wenn der Anwender auf die Schaltfläche btnLesen klickt. Der Ereignishandler startet in diesem Fall die Prozedur BtnLesenClick.<\/p>\n Das Lesen der Adressentabelle sollte möglichst in einer in sich abgeschlossenen Prozedur erfolgen. Sie sparen sich Schreibarbeit, wenn Sie zuerst die Liste der Imports-Anweisungen um folgende Zeilen erweitern:<\/p>\n Den benötigten ConnectionString sollten Sie in einer globalen Konstante hinterlegen. Damit die Variable in allen Prozeduren der Klasse zu sehen ist, sollten Sie unmittelbar nach der Inherits-Anweisung die folgende Anweisung einfügen (in einer Zeile):<\/p>\n Es handelt sich hierbei um den OleDb-Connection-String für den Zugriff auf die Beispieldatenbank. Die Angabe von Laufwerk und Pfad müssen Sie den Gegebenheiten Ihres PCs anpassen.<\/p>\n Das Einlesen der Adressentabelle soll in einer eigenen Prozedur namens LeseAdressen erfolgen (s. Quellcode 1). Zu Beginn der Prozedur werden zunächst die benötigten Objektvariablen deklariert. Um das DataGrid-Objekt später mit Daten füllen zu können, benötigen Sie auf jeden Fall ein DataSet-Objekt.<\/p>\n Objekte dieses Typs beinhalten eine oder mehrere Tabellen und bei Bedarf auch die Beziehungen zwischen diesen Tabellen. Im konkreten Beispiel verwenden wir das DataSet-Objekt nur, weil ein DataTable-Objekt nicht als Datenherkunft für ein DataGrid-Objekt erlaubt ist. Das DataSet-Objekt wird nur eine Tabelle enthalten.<\/p>\n Dem Objekt dsAdressen wird in der gleichen Programmzeile, in der die Deklaration erfolgt, eine neue Objektinstanz eines DataSet-Objekts zugewiesen:<\/p>\n Die folgende Anweisung fügt dem DataSet dsAdressen eine neue Tabelle hinzu. Die Add-Methode gibt hierbei eine DataTable zurück, die dem DataTable-Objekt tblAdressen zugewiesen wird. Diese Vorgehensweise hat den Vorteil, dass der Name der im DataSet enthaltenen Tabelle klar definiert ist.<\/p>\n Alternativ können Sie auch zuerst ein DataTable-Objekt definieren und dieses dann der Tabellenauflistung des DataSet-Objekts hinzufügen. Dann erhält das erste Objekt den Namen Table1, das zweite den Namen Table2 und so weiter. Bei Verwendung des hier vorgestellten Verfahrens heißt die Tabelle im DataSet-Objekt tblAdressen.<\/p>\n Auf das Hinzufügen des DataTable- zum DataSet-Objekt folgen die Anweisungen, die eine Connection zur Access-Datenbank öffnen und das DataTable-Objekt mit dem Inhalt der Adressentabelle füllen:<\/p>\n Nach Ausführung der Fill-Methode enthält das DataTable-Objekt tblAdressen eine Liste aller Adressen aus der Access-Datenbank. Beachten Sie, dass das tblAdressen-Objekt im DataSet-Objekt enthalten ist. Die nun folgende Anweisung übergibt die Adressentabelle an das DataGrid-Objekt:<\/p>\n Abschließend werden die nun nicht mehr benötigten Ressourcen freigegeben. Das bedeutet, dass das DataAdapter-Objekt gelöscht und die Connection geschlossen wird.<\/p>\n Eine Einführung in den Datenzugriff mit ADO.NET finden Sie in Heft 5\/2004. <\/p>\n Abschließend müssen Sie die neu programmierte Prozedur noch aufrufen. Fügen Sie dazu in den Rumpf der Prozedur BtnLesenClick die folgenden Anweisungen ein:<\/p>\n Diese Anweisungen rufen die Prozedur LeseAdressen auf. Falls während der Ausführung dieser Prozedur ein Fehler auftritt, wird dieser abgefangen und der Fehlertext in einer Dialogbox angezeigt. Nun können Sie das Programm durch das Betätigen der F5-Taste starten. Um die Daten aus der Adressentabelle einzulesen, klicken Sie in dem sich öffnenden Formular auf die Schaltfläche Lesen.<\/p>\n Nach dem Einlesen stehen die Adressdaten erstmal im DataGrid. Das DataGrid enthält einen Datensatzmarkierer, der dem von Access ähnlich sieht. Sie können die Daten innerhalb des DataGrids ändern, neue Zeilen hinzufügen und bestehende Zeilen löschen.<\/p>\n <\/b><\/p>\n Bild 5: Das DataGrid-Steuerelement zeigt die Daten aus einer Access-Tabelle an.<\/span><\/b><\/p>\n Aber warum lassen sich die Daten bei geschlossener Connection bearbeiten Der Grund besteht darin, dass .NET die verbindungslose Datenverarbeitung ermöglicht.<\/p>\n Das erneute Herstellen der Verbindung zur Datenquelle ist erst bei der Aktualisierung der Datensätze erforderlich. Falls Sie dies ernsthaft testen wollen, können Sie die Beispieldatenbank nach dem Einlesen der Daten in ein anderes Verzeichnis verschieben.<\/p>\n Danach ist die Eingabe und Bearbeitung von Daten weiterhin möglich. Erst beim erneuten Einlesen der Daten erhalten Sie eine Fehlermeldung.<\/p>\n Quellcode 2<\/b><\/p>\n Um die Daten aus dem DataGrid wieder in die zugrunde liegende Tabelle zu schreiben, ist ein zweiter Button erforderlich. Zur Anlage des Buttons gehen Sie wie folgt vor:<\/p>\n Geben Sie für den Button den folgenden Programmcode ein:<\/p>\n Die Zeile SchreibeAdressen() ruft die gleichnamige Prozedur auf. Die Try Catch-Anweisung schachtelt den Aufruf und fängt eventuell auftretende Fehler ab. Falls ein Fehler auftritt, wird die Meldung in einer MessageBox angezeigt. Damit lässt sich zwar die Fehlerursache nicht beheben, Sie können aber den Fehlertext lesen, ohne dass das Programm abstürzt. Der Programmcode für die Prozedur SchreibeAdressen lautet wie in Quellcode 2.<\/p>\n Die Prozedur entnimmt als Erstes die zu schreibenden Daten aus der Datenquelle des DataGrid-Steuerelements. Die Zuweisung an das DataSet-Objekt dsAdressen übernimmt die folgende Anweisung:<\/p>\n Ein DataSet kann mehrere Tabellen enthalten. Der verwendete DataAdapter enthält aber nur die Verbindung zu der Tabelle tblAdressen. Deshalb müssen Sie die Tabelle tblAdressen aus der Tables-Auflistung des DataSet-Objekts einem DataTable-Objekt zuweisen. Mit dem definierten OleDbCommandBuilder-Objekt können Sie die Aktualisierung der Daten dann dem .NET-Framework überlassen. Die folgende Anweisung führt automatisch die erforderlichen UPDATE-, INSERT- und DELETE-Anweisungen durch:<\/p>\n Der wohl wichtigste Vorteil des hier beschriebenen Verfahrens besteht darin, dass es sehr einfach zu implementieren ist. Es sind nur wenige Programmzeilen erforderlich, um die Daten in das DataGrid-Steuerelement zu lesen und sie von dort wieder in die zugrunde liegende Tabelle zu schreiben.<\/p>\n Unter Verwendung von globalen Objektvariablen für das Connection-, das DataAdapter-, das DataTable- und das DataSet-Objekt ließe sich der Programmcode sogar noch weiter reduzieren. Darauf wurde aber zugunsten der besseren Verdeutlichung der Verbindungslosigkeit im DataGrid-Objekt verzichtet.<\/p>\n Der größte Nachteil der verwendeten Methode besteht wohl darin, dass Sie relativ wenig Kontrolle über die Eingaben des Anwenders haben. So kann der Anwender ohne Weiteres auch Werte in das Feld AnredeID eingeben, die in der Tabelle tblAnreden nicht vorhanden sind. Hier ist eine Programmiertechnik erforderlich, mit der sich die überprüfung der Eingaben pro Feld durchführen lässt.<\/p>\n Ein Nachteil des DataGrid-Steuerelements in dieser einfachen Form besteht darin, dass Sie nicht über Steuerelemente für Benutzereingaben verfügen. So wäre es beispielsweise einfacher, die Anrede aus einem Kombinationsfeld auszuwählen. Hierfür benötigen Sie eine Gruppe von Steuerelementen zur Bearbeitung eines einzelnen Datensatzes. Innerhalb des DataGrids lässt sich das nicht realisieren.<\/p>\n Ein weiterer Nachteil der beschriebenen Lösung besteht darin, dass Fehlermeldungen nur begrenzt im Klartext angezeigt werden. Sie können dies einmal ausprobieren, indem Sie zwei neue Datensätze eingeben. Weisen Sie dem Feld EntryID des ersten Datensatzes den Wert 1 und dem Feld Vorname den Wert Tom und dem Feld EntryID des zweiten Datensatzes den Wert 2 und dem Feld Vorname den Wert Ria zu.<\/p>\n <\/b><\/p>\n Bild 6: Mit dieser Fehlermeldung kann der Anwender vermutlich nicht viel anfangen.<\/span><\/b><\/p>\n Um die Datensätze in der zugrunde liegenden Tabelle zu speichern, klicken Sie auf den Button Schreiben. <\/p>\n Obwohl dem AutoWert-Feld in der zugrunde liegenden Tabelle sofort ein Integer-Wert zugewiesen wird, behält das Feld AdressID im DataGrid den Wert (Null).<\/p>\n Wenn Sie nun die Vornamen der beiden Datensätze erneut ändern und Sie nochmal auf Speichern klicken, dann erhalten Sie die Fehlermeldung in Abbildung 6.<\/p>\n Mit dem Fehlertext Parallelitätsverletzung kann ein Anwender vermutlich nicht viel anfangen. Aus dem Ablauf lässt sich die Fehlerursache aber eventuell erklären: Beim ersten Speichern werden die Datensätze an die zugrunde liegende Tabelle angefügt.<\/p>\n Beim zweiten Speichern sollen die bestehende Datensätze aktualisiert werden. Das Problem besteht aber nun darin, dass die Daten im Feld AdressID aufgrund des AutoWert-Feldes in der Tabelle von denen im DataGrid abweichen.<\/p>\n Deshalb kommt es bei der Aktualisierung zu Komplikationen. Diese können Sie vermeiden, indem Sie nach jedem Speichervorgang die Daten direkt wieder lesen.<\/p>\n Fügen Sie dazu einfach den entsprechenden Prozeduraufruf in den Programmcode ein.<\/p>\n Sie haben in diesem Beitrag eine einfache und schnell zu implementierende Möglichkeit kennen gelernt, mit der Sie Daten aus einer Access-Tabelle lesen, bearbeiten und die geänderten Daten speichern können.<\/p>\n Die Methode hat aber verschiedene Nachteile, zu deren Vermeidung weit mehr Komponenten erforderlich sind. Sie benötigen unter anderem<\/p>\n Im zweiten Teil dieser Beitragsreihe erfahren Sie, wie Sie ein Formular mit einem Listenfeld zur Auswahl einer Adresse und zur Anzeige der entsprechenden Detaildaten erstellen.<\/p>\n","protected":false},"excerpt":{"rendered":" Mit den Assistenten und Editoren von Microsoft Access können Sie Abfragen, Formulare und Berichte entwerfen. Nach wenigen Mausklicks können Sie Daten eingeben, bearbeiten und drucken. Das sieht bei Visual Basic.NET anders aus. Hier führt kein Weg an der Eingabe von Programmcode vorbei. Aber auch hier gibt es Assistenten, die Ihnen das Leben leichter machen. Deshalb genügt der folgende Beitrag, um schon zu einer kleinen Adressverwaltung zu kommen.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[44000017,662004,66062004,44000027],"tags":[],"class_list":["post-55000245","post","type-post","status-publish","format-standard","hentry","category-NET","category-662004","category-66062004","category-Loesungen"],"yoast_head":"\n![](\"..\/fileadmin\/_temp_\/{369311D9-FC5E-4208-8579-5F8E28FBF3BC}\/pic002.png\")
<\/p>\nDer Quellcode eines leerenFormulars<\/h2>\n
Public Class MainForm\r\nInherits System.Windows.Forms.Form<\/pre>\n
Public Shared Sub Main\r\n Dim fMainForm As New MainForm\r\n fMainForm.ShowDialog()\r\nEnd Sub<\/pre>\n
Hinweis<\/h3>\n
MyBase.New<\/pre>\n
Me.InitializeComponent<\/pre>\n
Me.AutoScaleBaseSize = _ New System.Drawing.Size(5, 13)\r\nMe.ClientSize = _ New System.Drawing.Size(292, 266)\r\nMe.Name = \"MainForm\"\r\nMe.Text = \"MainForm\"<\/pre>\n
Me.Text = \"Adressen\"<\/pre>\n
Die Toolbox<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{369311D9-FC5E-4208-8579-5F8E28FBF3BC}\/pic003.png\")
<\/p>\n![](\"..\/fileadmin\/_temp_\/{369311D9-FC5E-4208-8579-5F8E28FBF3BC}\/pic004.png\")
<\/p>\nAdressen einlesen<\/h2>\n
Ein Button-Steuerelement mit Code hinterlegen<\/h2>\n
Private Sub LeseAdressen()\r\n Dim adp As OleDbDataAdapter\r\n Dim tblAdressen As DataTable\r\n Dim dsAdressen As New DataSet\r\n Dim cnn As OleDbConnection\r\n tblAdressen = dsAdressen.Tables.Add(\"tblAdressen\")\r\n cnn = New OleDbConnection(m_CnnString)\r\n cnn.Open()\r\n adp = New OleDbDataAdapter(\"SELECT * FROM tblAdressen\", cnn)\r\n adp.Fill(tblAdressen)\r\n Me.DataGrid1.SetDataBinding(dsAdressen, \"tblAdressen\")\r\n adp.Dispose()\r\n cnn.Close()\r\nEnd Sub<\/pre>\n
AddHandler Me.btnLesen.Click, _ AddressOf Me.BtnLesenClick<\/pre>\n
Programmcode zum Lesen der Adressentabelle<\/h2>\n
Imports System.Data\r\nImports System.Data.OleDb<\/pre>\n
Const m_CnnString = \"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\Daten\\Haufe\\Adressen\\Adress00.mdb\"<\/pre>\n
Private Sub LeseAdressen()\r\nDim adp As OleDbDataAdapter\r\nDim tblAdressen As DataTable\r\nDim dsAdressen As New DataSet\r\nDim cnn As OleDbConnection<\/pre>\n
tblAdressen = _ dsAdressen.Tables.Add(\"tblAdressen\")\r\ncnn = New OleDbConnection(m_CnnString)\r\ncnn.Open()\r\nadp = New OleDbDataAdapter_ (\"SELECT * FROM tblAdressen\", cnn)\r\nadp.Fill(tblAdressen)<\/pre>\n
Me.DataGrid1.SetDataBinding(dsAdressen, \"tblAdressen\")\r\nadp.Dispose()\r\ncnn.Close()\r\nEnd Sub<\/pre>\n
Try\r\n LeseAdressen()\r\n Catch ex As Exception\r\n MessageBox.Show(ex.ToString())\r\nEnd Try<\/pre>\n
![](\"..\/fileadmin\/_temp_\/{369311D9-FC5E-4208-8579-5F8E28FBF3BC}\/pic005.png\")
<\/p>\nDaten ändern und speichern<\/h2>\n
Private Sub SchreibeAdressen()\r\n Dim dsAdressen As DataSet\r\n Dim tblAdressen As DataTable\r\n dsAdressen = Me.DataGrid1.DataSource\r\n tblAdressen = dsAdressen.Tables(\"tblAdressen\")\r\n Dim adp As OleDbDataAdapter\r\n Dim cnn As OleDbConnection\r\n cnn = New OleDbConnection(m_CnnString)\r\n cnn.Open()\r\n adp = New OleDbDataAdapter(\"SELECT * FROM tblAdressen\", cnn)\r\n Dim cb As OleDbCommandBuilder = New OleDbCommandBuilder(adp)\r\n adp.Update(tblAdressen)\r\n adp.Dispose()\r\n cnn.Close()\r\nEnd Sub<\/pre>\n
Try\r\n SchreibeAdressen()\r\n Catch ex As Exception\r\n MessageBox.Show(ex.ToString())\r\nEnd Try<\/pre>\n
dsAdressen = Me.DataGrid1.DataSource<\/pre>\n
adp.Update(tblAdressen)<\/pre>\n
Vor- und Nachteile der beschriebenen Methode<\/h2>\n
![](\"..\/fileadmin\/_temp_\/{369311D9-FC5E-4208-8579-5F8E28FBF3BC}\/pic006.png\")
<\/p>\n