<\/p>\n
Manfred Hoffbauer, Düsseldorf<\/b><\/p>\n
Die in Microsoft Access integrierte Programmiersprache VBA unterstützt den Zugriff auf Access-Datenbanken per DAO und ADO. Auch in Microsoft Visual Basic.NET ist mit ADO.NET eine Technik für den Zugriff auf solche Datenbanken enthalten. Der folgende Beitrag beschreibt die wichtigsten Techniken für den lesenden und schreibenden Zugriff auf die Daten einer Access-Datenbank.<\/b><\/p>\n
Einer der Gründe für den Erfolg von Access ist, dass man auch mit wenigen Kenntnissen schnell achtbare Ergebnisse erzielt und alle notwendigen Hilfsmittel in einer einzigen Anwendung findet. Für die Erstellung einer Anwendung auf Basis der .NET-Technologien bedarf es weit mehr: Dazu sind Kenntnisse in Winforms oder ASP.NET, ADO.NET und einer .NET-Programmiersprache wie C#.NET oder VB.NET erforderlich. <\/p>\n
Da der vorliegende Beitrag aber „nur“ eine Einführung in ADO.NET geben möchte, sind die Beispiele auf das Mindeste reduziert – sie haben keine Benutzeroberfläche und auch die Ausgabe der Ergebnisse erfolgt lediglich per Konsole. Alles andere hätte auch den Rahmen gesprengt und zu sehr vom eigentlichen Thema abgelenkt. Dafür lernen Sie aber alle wichtigen Techniken für den Zugriff auf eine Access-Datenbank per ADO.NET kennen und können diese Kenntnisse später leicht aufgreifen, wenn Sie einmal eine „richtige“ .NET-Anwendung mit Benutzeroberfläche erstellen.<\/p>\n
Die Beispieldaten befinden sich auf der Heft-CD in der Zip-Datei ADO.NET.zip. Als Beispieldatenbank dient die Adressverwaltung, die Sie unter dem Dateinamen Adress97.mdb bzw. Adress00.mdb auf der Heft-CD finden. Den kompletten Code mit allen Beispielen enthält die Datei Main.vb. <\/p>\n
Schon seit mehreren Jahren beherrscht Access neben DAO ein weiteres Verfahren für den Datenzugriff. Mit den so genannten Active Data Objects (kurz: ADO) verfügt der Access-Programmierer über ein modernes Verfahren für den Datenzugriff. Zahlreiche Beiträge von Access im Unternehmen haben sich mit den Vor- und Nachteilen von ADO und DAO beschäftigt. Einer der wichtigsten Vorteile von ADO besteht wohl darin, dass Sie mit dieser Technik sowohl auf Access-Datenbanken als auch auf SQL Server-Datenbanken zugreifen können. Microsoft selbst weist immer wieder darauf hin, dass DAO und ADO bei der Programmierung mit Access ihre Berechtigung haben. Je nach Anwendung ist die eine oder die andere Zugriffstechnik besser geeignet.<\/p>\n
Die mit .NET eingeführte Methode für den Datenzugriff nennt Microsoft ADO.NET. Wie der Name schon verrät, hat ADO.NET mehr ähnlichkeiten mit ADO als mit DAO. Access-Programmierer, die bisher vorwiegend mit DAO gearbeitet haben, müssen sich also umstellen. Wie bei ADO basiert bei ADO.NET der gesamte Datenzugriff auf einem Connection-Objekt. Mit ihm öffnen Sie unter Verwendung eines .NET-Datenproviders den Zugang zu einer Datenquelle. Abb. 1 zeigt eine übersicht über die Datenzugriffsobjekte. <\/p>\n
Im Zusammenhang mit ADO.NET ist von Objekten wie Connection, DataCommand und DataAdapter die Rede. Tatsächlich sind diese Objekte in Microsoft.NET gar nicht vorhanden. Es handelt sich lediglich um Oberbegriffe für die je nach verwendeter Technik dedizierten Objekte. Bei Verwendung von OleDB verwenden Sie die Objekte OleDBConnection, OleDbCommand und OleDBDataAdapter. Diese Objekte befinden sich im Namespace System.Data.OleDB. <\/p>\n
![](\"..\/fileadmin\/_temp_\/{D470EB58-B776-45FA-8171-E5B68E5E7B54}\/pic001.png\")
<\/p>\n
<\/b><\/p>\n
Abb. 1: Datenzugriffsobjekte<\/b><\/p>\n
Im Namespace System.Data.SqlClient ist der Datenprovider für SQL Server-Datenbanken (ab Version 7.0) enthalten. <\/p>\n
Im Namespace System.Data.OleDB ist der Datenprovider für andere Datenquellen enthalten. Seit der Version 1.1 des Microsoft .NET-Frameworks befinden sich im Namespace System.Data.ODBC die Objekte für den Zugriff mit der ältesten der drei Techniken. Bei Version 1.0 des .NET-Frameworks musste der ODBC-Provider nachträglich installiert werden.<\/p>\n
Die Anforderungen an den ConnectionString variieren stark zwischen SqlClient, OleDB und ODBC. Speziell beim OleDBConnection-String können Sie innerhalb des Strings einen Datenprovider spezifizieren.<\/p>\n
Mögliche Einträge lauten wie folgt:<\/p>\n
Um die Beispiele aus diesem Beitrag nachzuvollziehen, sollten Sie mit SharpDevelop (Beschreibung und Download siehe Ausgabe 4\/2004, Beitrag .Net-Programmierung mit SharpDevelop) eine neue Combine anlegen.<\/p>\n
Starten Sie das Programm und gehen Sie wie folgt vor:<\/p>\n
SharpDevelop erstellt die Combine und fügt den Standardcode für eine Konsolenanwendung ein. Durch das Betätigen der F5-Taste können Sie das Programm sofort starten.<\/p>\n
Wenn Sie die nachfolgenden Beispiele einfach nur nachvollziehen und nicht selbst eingeben möchten, können Sie nach dem öffnen von SharpDevelop auch direkt auf die Schaltfläche Combine öffnen klicken und die im OrdnerAdo.Jet (Sharp Develop) enthaltene DateiAdo.Jet.cmbx auswählen. Die Prozedur Main enthält alle nachfolgend beschriebenen Beispiele; nach dem Betätigen von F5 durchläuft die Prozedur nacheinander die Beispiele. <\/p>\n
Wie Sie in Abb. 2 erkennen können, führt Windows die Konsolenanwendung im Fenster des Befehlszeileninterpreters aus. Durch das Betätigen einer beliebigen Taste können Sie die Anwendung beenden, was wiederum zum automatischen Schließen des Befehlszeileninterpreterfensters führt.<\/p>\n
Dieser Typ Anwendung eignet sich gut, um Techniken wie beispielsweise den Datenzugriff unabhängig von irgendwelchen Fragen der Benutzeroberfläche zu testen.<\/p>\n
Dim cnnString As String\ncnnString = \"Provider=Microsoft.Jet.OLEDB.4.0;\" & _\n \"Data Source=<Dateipfad>\\\\Adress00.mdb\"\nDim cnn As OleDbConnection\ncnn = New OleDbConnection(cnnString)\ncnn.Open()<\/pre>\nQuellcode 1<\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Abb. 2: Die von SharpDevelop generierte Konsolenanwendung können Sie sofort starten.<\/b><\/p>\n
Dieser Beitrag beschäftigt sich mit dem Zugriff auf Access-Datenbanken. Er geht deshalb vorwiegend auf OleDB und den Zugriff auf Access-Datenbanken ein. Die hierfür benötigten Objekte befinden sich im Namespace System.Data.OleDB.<\/p>\n
Um auf ein Objekt aus diesem Namespace zuzugreifen, können Sie ihm die Bezeichnung des Namespaces voranstellen oder Sie schreiben einmal zu Beginn Ihres Programms die folgende Anweisung:<\/p>\n
Imports System.Data.OleDb<\/pre>\nMit der Imports-Anweisung sparen Sie viel Schreibarbeit. Jetzt können Sie nämlich statt<\/p>\n
Dim cnn As System.Data.OleDb.OleDbConnection<\/pre>\n(ohne Zeilenumbruch) vereinfacht Folgendes schreiben:<\/p>\n
Dim cnn As OleDbConnection<\/pre>\nHierfür benötigen Sie eine Verbindung, die Sie wie in Quellcode 1 erzeugen und öffnen können.<\/p>\n
Mit der Dim-Anweisung definieren Sie die String-Variable cnnString.<\/p>\n
Dieser Variablen weisen Sie den eigentlichen Connection-String zu. Er hat die gleiche Bedeutung wie bei der Programmierung mit dem herkömmlichen ADO.<\/p>\n
Sub Main()\n Dim cnnString As String\n cnnString = \"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\\\Nordwind.mdb\"\n Dim cnn As OleDbConnection\n cnn = New OleDbConnection(cnnString)\n cnn.Open()\n Dim cmdUDI As OleDbCommand\n cmdUDI = New OleDbCommand(\"UPDATE Personal SET Vorname = ''''Hans'''' \" _ & \"WHERE Vorname = ''''Andrew''''\", cnn)\n console.writeline(\"Anzahl geänderter Datensätze: \" + _ cmdUDI.ExecuteNonQuery().ToString)\n cmdUDI = New OleDbCommand(\"INSERT INTO Personal ( Vorname, Nachname ) VALUES \" _ & \"(''''Manfred'''', ''''Hoffbauer'''' )\", cnn)\n console.writeline(\"Anzahl hinzugefügter Datensätze: \" + cmdUDI.ExecuteNonQuery()\n cmdUDI = New OleDbCommand(\"DELETE FROM Personal WHERE Vorname = ''''Manfred'''' \" _ & \"AND Nachname = ''''Hoffbauer''''\", cnn)\n Console.WriteLine(\"Anzahl Deletes: \" + cmdUDI.ExecuteNonQuery().ToString)\n cmdUDI = New OleDbCommand(\"SELECT COUNT(*) FROM Personal\", cnn)\n Console.WriteLine(\"Anzahl Mitarbeiter: \" + cmdUDI.ExecuteScalar().ToString)\n cnn.Close\nEnd Sub<\/pre>\nQuellcode 2<\/b><\/p>\n
Im Beispiel benennt er den zu verwendenden Datenprovider und die zu öffnende Access-MDB-Datei.<\/p>\n
Die zweite Dim-Anweisung definiert ein neues OleDbConnection-Objekt und weist ihm die Verbindung zu. Mit cnn.Open() wird die Verbindung geöffnet.<\/p>\n
Wenn Sie statt auf einen OleDB-Provider auf einen SQL-Provider zugreifen wollen, dann verwenden Sie statt des OleDBConnection- ein SqlConnection-Objekt. Beide Begriffe werden in der Fachliteratur als DataConnection zusammengefasst. Objekte können aber nur den Typ OleDBConnection oder SqlConnection und nicht den Type DataConnection haben. <\/p>\n
Update-, Delete- und Insert-Anweisungen per OleDbCommand-Objekt ausführen<\/h2>\n
Eine Connection an sich ist keine wirkliche Errungenschaft, aber die notwendige Voraussetzung für weitere Verfahren des Datenzugriffs. Basierend auf einer OleDBConnection können Sie ein OleDBCommand-Objekt definieren.<\/p>\n
Das OleDBCommand-Objekt verfügt über die drei folgenden Methoden:<\/p>\n
Die ExecuteNonQuery-Methode ist zur Ausführung von INSERT-, UPDATE- und DELETE-Anweisungen geeignet. Sie ähnelt der Execute-Methode von Access. Die Anzahl der von einer Aktion betroffenen Datensätze erhalten Sie als Funktionsargument zurück. Betrachten Sie dazu die Routine aus Quellcode 2.<\/p>\n
Dim strSQL As String\nstrSQL = \"SELECT Vorname, Nachname, Strasse, \" _ & \"PLZ, Ort FROM tblAdressen;\"\nDim cmd As OleDbCommand\ncmd = New OleDbCommand(strSQL, cnn)\nDim reader As OleDbDataReader\nreader = cmd.ExecuteReader()\nWhile reader.Read()\n Console.WriteLine(reader(\"Vorname\"))\nEnd While<\/pre>\nQuellcode 3<\/b><\/p>\n
Die Dim-Anweisung definiert das Objekt cmdUDI mit dem Typ OleDBCommand. Die anschließende Zuweisung weist dem Objekt ein neues Command-Objekt mit der jeweils angegebenen SQL-Anweisung zu. Die Angabe der Verbindung bestimmt, auf welcher Datenbank die SQL-Anweisung ausgeführt wird.<\/p>\n
Die Methode cmdUDI.ExectureNonQuery() führt die SQL-Anweisung aus. Bei allen Aktionsabfragen wird die Anzahl der betroffenen Datensätze per Console.WriteLine() angezeigt. Die Methode cmdUDI.ExecuteScalar() führt die SELECT-Anweisung aus und gibt den Wert der ersten Spalte der ersten Zeile des Abfrageergebnisses als Wert zurück. Im Beispiel entspricht dies der Anzahl der Datensätze aus der Tabelle Personal.<\/p>\n
Daten per SELECT-Anweisung lesen<\/h2>\n
Mit der ExecuteReader-Methode können Sie ein DataReader-Objekt erzeugen lassen. Mit dem DataReader-Objekt können Sie die Daten einer Abfrage vorwärts gerichtet lesen. Das Verhalten des Objekts entspricht daher ein wenig dem sequenziellen Lesen von Daten aus einer Textdatei. Das DataReader-Objekt hält immer nur einen Datensatz im Speicher und spart deshalb Ressourcen. Gleichzeitig benötigt es die Verbindung aber während seiner gesamten Lebensdauer exklusiv. Das Beispiel aus Quellcode 3 zeigt das satzweise Lesen von Adressen mit dem DataReader-Objekt.<\/p>\n
Sie können eine Objektvariable vom Typ DataReader nicht direkt mit New instanzieren. Ein DataReader-Objekt kann nur mittels der ExecuteReader-Methode eines OleDBCommand-Objektes erzeugt werden.<\/p>\n
Im Beispiel wird eine SELECT-Abfrage auf die Adresstabelle durchgeführt. Die Read-Methode des DataReader-Objektes gibt den Wert True zurück, wenn ein Datensatz gelesen werden konnte.<\/p>\n
Andernfalls gibt die Methode den Wert False zurück. Mit dem DataReader-Objekt können Sie unter Angabe des Feldnamens direkt auf die einzelnen Spaltenwerte zugreifen.<\/p>\n
Abb. 3 zeigt exemplarisch die Anzeige der Vornamen aus der Adressentabelle.<\/p>\n
<\/p>\n
<\/b><\/p>\n
Abb. 3: Ausgabe der Vornamen mittels DataReader-Objekt<\/b><\/p>\n
Die obige Schleife zeigt alle Vornamen aus der Adressentabelle an. Zum Schluss des Beispielprogramms sollten Sie die verwendeten Ressourcen freigeben:<\/p>\n
reader.Close()\ncnn.Close()\nConsole.ReadLine()<\/pre>\nDie Anweisung Console.ReadLine() wartet auf eine Benutzereingabe. Sie hält das Windows-Befehlszeilenfenster so lange offen, bis Sie die Eingabetaste betätigen.<\/p>\n
Dim tblAdressen As New DataTable\nDim adp As New OleDbDataAdapter(\"SELECT * FROM tblAdressen\", cnn)\nadp.Fill(tblAdressen)\nDim row As DataRow\nFor Each row In tblAdressen.Rows\n Console.WriteLine(row.Item(\"Vorname\"))\nNext<\/pre>\nQuellcode 4<\/b><\/p>\n
Dim col As DataColumn\nFor Each col In tblAdressen.Columns\n Console.WriteLine(col.ColumnName.ToString + \"->\" + col.DataType.ToString)\nNext<\/pre>\nQuellcode 5<\/b><\/p>\n
Der Datenzugriff mit ADO.NET basiert auf der verbindungslosen Datenzugriffstruktur. Anders als bei Microsoft Access üblich werden ein oder mehrere Datensätze aus einer oder mehreren Tabellen in den Speicher gelesen, dort bearbeitet und bei Bedarf die änderungen geschrieben. Verbindungslos bedeutet in diesem Fall, dass nach dem Lesen der Bezug zur Datenquelle vollständig verloren gehen kann. Zur Handhabung dieser Architektur stellt ADO.NET das DataTable- und das DataSet-Objekt zur Verfügung.<\/p>\n
Ein DataTable-Objekt besteht aus Zeilen und Spalten und ist prinzipiell mit einer Datentabelle vergleichbar. Ein DataSet-Objekt kann aus ein oder mehreren Tabellen und Relationen bestehen. Ein DataSet ist einerseits mit einer Datenbank vergleichbar, weist aber gleichzeitig gravierende Unterschiede auf. Dadurch bedingt, dass ein DataSet verbindungslos im Speicher gehalten wird, können die Daten der enthaltenen Tabellen aus sehr verschiedenen Quellen stammen. So lassen sich in ein und demselben DataSet Datentabellen aus einer Textdatei, einer Access-Datenbank, einer SQL-Server-Datenbank und aus weiteren Datenquellen zusammenfügen.<\/p>\n
Daten in ein DataTable lesen<\/h2>\n
Das DataAdapter-Objekt ist der Vermittler zwischen einem Connection-Objekt und einer DataTable oder einem DataSet. Es enthält die SQL-Abfragen, mit denen Sie Daten lesen und schreiben. Das Beispiel aus Quellcode 4 zeigt, wie Sie die Vornamen aus der Adressentabelle mit Hilfe eines DataTable-Objektes anzeigen können.<\/p>\n
Die Dim-Anweisung definiert das Objekt tblAdressen vom Typ DataTable. Der Variablen wird gleichzeitig eine neue, leere Instanz des Objekts zugewiesen.<\/p>\n
Die zweite Anweisung definiert ein OleDBDataAdapter-Objekt, das als Vermittler zwischen der Connection und der DataTable fungiert. Bei der Definition des OleDBDataAdapter-Objekts werden eine SELECT-Anweisung und eine Connection angegeben.<\/p>\n
Mit adp.Fill(tblAdressen) werden die Daten aus der Adressentabelle in das DataTable-Objekt tblAdressen übertragen. Beachten Sie, dass der Name des DataTable-Objekts frei gewählt werden kann. Im Beispiel wurde es nur deshalb tblAdressen genannt, damit der Bezug zur Quelltabelle sofort klar wird. Alternativ könnten Sie das Objekt auch tblX oder einfach nur Adressen nennen.<\/p>\n
Mit der Fill-Anweisung werden nicht nur die Daten, sondern es wird auch die Struktur in das DataTable-Objekt übertragen.<\/p>\n
Das Objekt enthält nach der Zuweisung die gleichen Spalten inklusive Feldnamen, Datentypen und die gleiche Primärschlüsseldefinition wie die Herkunftstabelle. Die Definition der Spalten können Sie mit der Schleife aus Quellcode 5 überprüfen.<\/p>\n
Die Schleife durchläuft die Columns-Auflistung des tblAdressen-Objekts. Zu jeder Spalte werden der Name und der von .NET zugewiesene Datentyp angezeigt. Das Ergebnis eines Schleifendurchlaufs sehen Sie in Abb. 4.<\/p>\n
Der Auflistung in der Abbildung können Sie entnehmen, wie .NET die in der Access-Tabelle definierten Datentypen in eigene Datentypen umsetzt. Zusätzlich zu der Struktur hat die Fill-Methode auch alle Daten in das DataTable-Objekt übernommen. Die einzelnen Datensätze stellen die Zeilen innerhalb des Objekts dar. Mit der Rows-Auflistung können Sie die Zeilen durchlaufen und direkt auf die einzelnen Feldwerte zugreifen. Im obigen Beispiel wird exemplarisch der Wert des Feldes Vorname angezeigt.<\/p>\n
Daten aktualisieren<\/h2>\n
Das Aktualisieren der Daten in einem DataTable-Objekt erfolgt durch direkte Zuweisung. Mit der folgenden Anweisung können Sie beispielsweise den Wert im Feld Vorname des vierten Datensatzes ändern (ohne Zeilenumbruch):<\/p>\n
tblAdressen.Rows(3).Item(\"Vorname\") = \"<Unbekannt>\"<\/pre>\n
<\/p>\n
<\/b><\/p>\n
Abb. 4: Diese Feldnamen und Datentypen verwendet .NET zur Verwaltung der Adressentabelle.<\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Abb. 5: Diesen Fehler meldet ADO.NET, falls die zugrunde liegende Datenbank exklusiv gesperrt wurde.<\/b><\/p>\n
Beachten Sie dabei, dass die meisten Indizes in .NET auf 0 basieren. Die erste Zeile erhalten Sie mit Row(0), die zweite mit Row(1) und so weiter.<\/p>\n
Was nutzt das ändern von Daten in einem verbindungslosen DataTable-Objekt? Es hat tatsächlich zunächst keinerlei Auswirkung auf den zugrunde liegenden Datenbestand.<\/p>\n
Sie können dies leicht prüfen, indem Sie einige Feldwerte ändern und dann die folgenden beiden Anweisungen in das Programm aufnehmen (ohne Zeilenumbruch):<\/p>\n
Console.WriteLine(\"<Bitte betätigen Sie die <Enter>-Taste.\")\nConsole.ReadLine()<\/pre>\nWenn Sie das Programm zum Betätigen der Eingabetaste auffordert, können Sie die MDB-Datei öffnen und sich die Daten ansehen. Sie werden feststellen, dass keine änderungen an den Daten durchgeführt wurden. Sie können die Datenbank zu diesem Zeitpunkt sogar exklusiv mit Microsoft Access öffnen. Dies ist gleichzeitig der Beweis dafür, dass die Verbindung vom DataTable-Objekt zur Datenbank vollständig gelöst wurde. Um die Daten in der zugrunde liegenden Datenbank zu aktualisieren, haben Sie prinzipiell zwei Möglichkeiten.<\/p>\n
Sie können die Rows-Auflistung des DataTable-Objekts dazu verwenden, für jede geänderte Zeile eine Update-Anweisung zusammenzusetzen und diese per OleDBCommand-Objekt auszuführen. Ob eine Zeile geändert wurde, können Sie mit der RowState-Eigenschaft abfragen:<\/li>\n If row.RowState=DataRowState.Modified Then\n ...<\/pre>\nDie weitaus komfortablere Methode besteht darin, die beschriebenen Arbeitsschritte dem DataAdapter-Objekt zu überlassen. Dies ist ein klassischer Zweizeiler:<\/li>\n Dim cb As OleDbCommandBuilder = New _ OleDbCommandBuilder(adp)\nadp.Update(tblAdressen)<\/pre>\n
<\/p>\n
<\/b><\/p>\n
Abb. 6: Mit einem Try-Catch-Block erhalten Sie die Fehlermeldung im Klartext.<\/b><\/p>\n
Mit der ersten Anweisung definieren Sie ein OleDBCommandBuilder-Objekt. Durch die Zuweisung mit New OleDBCommandBuilder(adp) veranlassen Sie .NET, dem OleDBCommandBuilder-Objekt automatisch eine UPDATE-, eine INSERT- und eine DELETE-Anweisung hinzuzufügen. Da das OleDBCommandBuilder-Objekt im DataAdapter-Objekt enthalten ist, können die SQL-Anweisungen in der anschließenden Update-Anweisung verwendet werden. Sie schreibt die änderungen in die zugrunde liegende Datentabelle.<\/p>\n
Zu diesem Zeitpunkt stellt .NET die Verbindung zur Datenbank wieder her und versucht, die erforderlichen UPDATE-Anweisungen durchzuführen.<\/p>\n
Falls die Access-Datenbank nicht verfügbar oder exklusiv gesperrt wurde, tritt hierbei ein Fehler auf. In Abb. 5 sehen Sie, dass sich mit der Fehlermeldung nicht allzu viel anfangen lässt.<\/p>\n
Dim cb As OleDbCommandBuilder = _ New OleDbCommandBuilder(adp)\nTry\n adp.Update(tblAdressen)\nCatch exOle As OleDbException\n Console.WriteLine(exOle.ToString)\nCatch ex As Exception\n Console.WriteLine(ex.Message)\nEnd Try<\/pre>\nQuellcode 6<\/b><\/p>\n
Es ist deshalb empfehlenswert, die Update-Anweisung in einen Try Catch-Block zu schachteln (s. Quellcode 6). Mit diesen Programmzeilen erhalten Sie zwar noch keine wirkliche Fehlerbehandlung, Sie erreichen aber immerhin die Anzeige der Fehlermeldung im Klartext.<\/p>\n
Wenn Sie das Programm nun erneut starten und die Access-Datenbank vor der Ausführung der Update-Anweisung exklusiv sperren, dann erhalten Sie die Anzeige in Abb. 6.<\/p>\n
Die oben beschriebene Vorgehensweise basiert auf einem automatisch generierten UPDATE-Statement. Mit wenigen Programmzeilen können Sie den SQL-Text dieses Statements in die Datei C:\\\\Test.TXT exportieren lassen (s. Quellcode 7). Als Ergebnis erhalten Sie die UPDATE-Anweisung aus Abb. 7.<\/p>\n
Dim w As New System.IO.StreamWriter(\"C:\\\\TEST.TXT\")\nw.Write(cb.GetUpdateCommand().CommandText)\nw.Close()<\/pre>\nQuellcode 7<\/b><\/p>\n
strSQL = \"SELECT Vorname, Nachname FROM tblAdressen WHERE PLZ LIKE ''''4%''''\"\nDim daFilter As New OleDbDataAdapter(strSQL, cnn)\nDim tblLokaleAdressen As New DataTable\ndaFilter.Fill(tblLokaleAdressen)\nFor Each row In tblLokaleAdressen.Rows\n Console.WriteLine(row.Item(\"Vorname\").ToString + \" \" + _ row.Item(\"Nachname\").ToString)\nNext\ntblLokaleAdressen = Nothing\ndaFilter.Dispose()<\/pre>\nQuellcode 8<\/b><\/p>\n
<\/p>\n
<\/b><\/p>\n
Abb. 7: SQL-Text eines UPDATE-Statements<\/b><\/p>\n
.NET führt diese Anweisung für jede Zeile mit geänderten Daten einmal aus. Die Fragezeichen werden dabei durch die Werte der gleichnamigen Felder aus dem DataTable-Objekt ersetzt. <\/p>\n
Das OleDBCommandBuilder-Objekt enthält ähnliche Anweisungen für die DELETE- und die INSERT-Anweisung.<\/p>\n
Daten filtern<\/h2>\n
Ein wichtiger Aspekt beim Abruf von Daten ist die Selektion der benötigten Datensätze. Im Hinblick auf die verwendeten Ressourcen ist es am günstigsten, die Daten direkt bei der Abfrage zu filtern. Hierzu können Sie das SQL-Statement des DataAdapter-Objekts mit einer WHERE-Klausel ausstatten (s. Quellcode 8).<\/p>\n
In diesem Beispiel selektieren Sie spalten- und zeilenweise. Das Abfrageergebnis enthält nur den Vor- und den Nachnamen der Adressen aus dem Postleitzahlengebiet 4. <\/p>\n
Dieses Verfahren hat den Nachteil, dass das Filterkriterium statisch in den SQL-String integriert ist. Wesentlich flexibler ist die Variante, das Filterkriterium als Parameter zu definieren (s. Quellcode 9).<\/p>\n
Die Verwendung eines benannten Parameters hat den Vorteil, dass Ihre SQL-Statements besser lesbar sind. Insbesondere bei komplizierten SQL-Statements oder vielen Parametern helfen Ihnen benannte Parameter, Programmierfehler zu vermeiden.<\/p>\n
strSQL = \"SELECT Vorname, Nachname FROM tblAdressen WHERE PLZ = @PLZ\"\nDim daParamFilter As New OleDbDataAdapter(strSQL, cnn)\ndaParamFilter.SelectCommand.Parameters.Add(\"@PLZ\", OleDbType.VarChar, 50).Value = _ \"79102\"\nDim tblParamAdressen As New DataTable\ndaParamFilter.Fill(tblParamAdressen)\nFor Each row In tblParamAdressen.Rows\n Console.WriteLine(row.Item(\"Vorname\").ToString + \" \" + _ row.Item(\"Nachname\").ToString)\nNext\ntblParamAdressen = Nothing\ndaParamFilter.Dispose()<\/pre>\nQuellcode 9<\/b><\/p>\n
Dim RowsSelected() As DataRow\nRowsSelected = tblAdressen.Select(\"PLZ = ''''79102''''\")\nDim i As Integer\nFor i = 0 To RowsSelected.Length - 1\n Console.WriteLine(RowsSelected(i).Item(\"Vorname\").ToString + \" \" _ + RowsSelected(i).Item(\"Nachname\").ToString)\nNext<\/pre>\nQuellcode 10<\/b><\/p>\n
Wenn Sie die Daten nicht direkt bei der Abfrage selektieren können, benutzen Sie am besten die Select-Methode des DataTable-Objekts.<\/p>\n
Die Methode selektiert die DataRow-Objekte aus einem DataTable-Objekt, die dem angegebenen Filterkriterium entsprechen. Als Ergebnis erhalten Sie ein Array von DataRow-Objekten mit den gefundenen Zeilen (s. Quellcode 10).<\/p>\n
Das DataSet-Objekt<\/h2>\n
Mit dem DataSet-Objekt können Sie mehrere Datentabellen gleichzeitig im Speicher halten. Dies hat den Vorteil, dass Sie mehrere relational verknüpfte Tabellen in einem einzigen Objekt verwalten können. Das folgende Beispiel definiert ein neues DataSet und füllt es mit der Unternehmens- und der Adressentabelle (s. Quellcode 11).<\/p>\n
Im Beispiel fungiert die Unternehmenstabelle als Mastertabelle. Die Adressentabelle enthält das Feld UnternehmenID, mit dem eine Adresse optional einem Masterdatensatz in der Unternehmenstabelle zugeordnet werden kann.<\/p>\n
Eine solche Relation können Sie dem DataSet mit folgenden Anweisungen hinzufügen (s. Quellcode 12).<\/p>\n
Wenn die Relation einmal definiert ist, können Sie nach Bedarf in den Zeilen der Master- und der Detailtabelle blättern. Besonders interessant ist dabei die Möglichkeit, zu einem Datensatz der Mastertabelle eine Liste der Detaildatensätze abzufragen. Die GetChildRows-Methode füllt hierzu ein Array mit den Row-Objekten der Child-Tabelle. Das folgende Beispiel durchläuft alle Datensätze der Unternehmenstabelle und zeigt die jeweils zugeordneten Datensätze der Adressentabelle an (s. Quellcode 13).<\/p>\n
Dim ds As New DataSet\nstrSQL = \"SELECT * FROM tblUnternehmen\"\nDim daParent As New OleDbDataAdapter(strSQL, cnnString)\ndaParent.Fill(ds, \"tblUnternehmen\")\nstrSQL = \"SELECT * FROM tblAdressen\"\nDim daChild As New OleDbDataAdapter(strSQL, cnnString)\ndaChild.Fill(ds, \"tblAdressen\")<\/pre>\nQuellcode 11<\/b><\/p>\n
Dim colParent, colChild As DataColumn\ncolParent = ds.Tables(\"tblUnternehmen\").Columns(\"UnternehmenID\")\ncolChild = ds.Tables(\"tblAdressen\").Columns(\"UnternehmenID\")\nDim relUnternehmenAdressen As New DataRelation(\"relUnternehmenAdressen\", colParent, _ colChild)\nds.Relations.Add(relUnternehmenAdressen)<\/pre>\nQuellcode 12<\/b><\/p>\n
'''' Master- und Childatensätze anzeigen\nDim ChildRows() As DataRow\nDim ParentRow As DataRow\nDim i As Integer\nFor Each ParentRow In ds.Tables(\"tblUnternehmen\").Rows\n Console.WriteLine(\"**** \" + ParentRow.Item(\"Unternehmen\").ToString _ + \"**** \")\n ChildRows = ParentRow.GetChildRows(relUnternehmenAdressen)\n For i = 0 To ChildRows.Length - 1\n Console.WriteLine(ChildRows(i).Item(\"Vorname\").ToString + \" \" + _ ChildRows(i).Item(\"Nachname\").ToString)\n Next\nNext<\/pre>\nQuellcode 13<\/b><\/p>\n
Der obige Beitrag beschreibt die wichtigsten Objekte für den Zugriff auf MDB-Datenbankdateien mit Microsoft .NET. Darüber hinaus können Sie mit ADO.NET auch auf andere Datenquellen wie Textdateien, XML-Dateien, SQL Server-Datenbanken und Oracle-Datenbank zugreifen. Mit ODBC erschließen Sie sich zudem ein nahezu unbegrenztes Potenzial an Datenformaten. Die Daten aller Formate lassen sich in DataTable- und DataSet-Objekte laden und dort gemeinsam verarbeiten.<\/p>\n
Mit diesen Objekten erhalten Sie deshalb einen relativ hohen Grad der Abstraktion. Aufgrund der verbindungslosen Speicherung der Daten sind die Objekte sowohl für Windows- als auch für Web-Anwendungen geeignet.<\/p>\n","protected":false},"excerpt":{"rendered":"
Die in Microsoft Access integrierte Programmiersprache VBA unterstützt den Zugriff auf Access-Datenbanken per DAO und ADO. Auch in Microsoft Visual Basic.NET ist mit ADO.NET eine Technik für den Zugriff auf solche Datenbanken enthalten. Der folgende Beitrag beschreibt die wichtigsten Techniken für den lesenden und schreibenden Zugriff auf die Daten einer Access-Datenbank.<\/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,66052004,44000035],"tags":[],"class_list":["post-55000233","post","type-post","status-publish","format-standard","hentry","category-NET","category-662004","category-66052004","category-Datenzugriff_programmieren"],"yoast_head":"\n
ADO.NET - eine Einführung - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"ADO.NET - eine Einführung\" \/>\n<meta property=\"og:description\" content=\"Die in Microsoft Access integrierte Programmiersprache VBA unterstützt den Zugriff auf Access-Datenbanken per DAO und ADO. Auch in Microsoft Visual Basic.NET ist mit ADO.NET eine Technik für den Zugriff auf solche Datenbanken enthalten. Der folgende Beitrag beschreibt die wichtigsten Techniken für den lesenden und schreibenden Zugriff auf die Daten einer Access-Datenbank.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2023-02-10T14:47:22+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-02-19T08:16:20+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg02.met.vgwort.de\/na\/3018cd3173a248bebd8272050f70e16d\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"18\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"ADO.NET – eine Einführung\",\"datePublished\":\"2023-02-10T14:47:22+00:00\",\"dateModified\":\"2024-02-19T08:16:20+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/\"},\"wordCount\":3216,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/3018cd3173a248bebd8272050f70e16d\",\"articleSection\":[\".NET\",\"2004\",\"5\\\/2004\",\"Datenzugriff programmieren\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/\",\"name\":\"ADO.NET - eine Einführung - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/3018cd3173a248bebd8272050f70e16d\",\"datePublished\":\"2023-02-10T14:47:22+00:00\",\"dateModified\":\"2024-02-19T08:16:20+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/3018cd3173a248bebd8272050f70e16d\",\"contentUrl\":\"http:\\\/\\\/vg02.met.vgwort.de\\\/na\\\/3018cd3173a248bebd8272050f70e16d\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/adonet__eine_einfuehrung\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"ADO.NET – eine Einführung\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"ADO.NET - eine Einführung - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/","og_locale":"de_DE","og_type":"article","og_title":"ADO.NET - eine Einführung","og_description":"Die in Microsoft Access integrierte Programmiersprache VBA unterstützt den Zugriff auf Access-Datenbanken per DAO und ADO. Auch in Microsoft Visual Basic.NET ist mit ADO.NET eine Technik für den Zugriff auf solche Datenbanken enthalten. Der folgende Beitrag beschreibt die wichtigsten Techniken für den lesenden und schreibenden Zugriff auf die Daten einer Access-Datenbank.","og_url":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/","og_site_name":"Access im Unternehmen","article_published_time":"2023-02-10T14:47:22+00:00","article_modified_time":"2024-02-19T08:16:20+00:00","og_image":[{"url":"http:\/\/vg02.met.vgwort.de\/na\/3018cd3173a248bebd8272050f70e16d","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"18\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"ADO.NET – eine Einführung","datePublished":"2023-02-10T14:47:22+00:00","dateModified":"2024-02-19T08:16:20+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/"},"wordCount":3216,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/#primaryimage"},"thumbnailUrl":"http:\/\/vg02.met.vgwort.de\/na\/3018cd3173a248bebd8272050f70e16d","articleSection":[".NET","2004","5\/2004","Datenzugriff programmieren"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/","url":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/","name":"ADO.NET - eine Einführung - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/#primaryimage"},"thumbnailUrl":"http:\/\/vg02.met.vgwort.de\/na\/3018cd3173a248bebd8272050f70e16d","datePublished":"2023-02-10T14:47:22+00:00","dateModified":"2024-02-19T08:16:20+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/#primaryimage","url":"http:\/\/vg02.met.vgwort.de\/na\/3018cd3173a248bebd8272050f70e16d","contentUrl":"http:\/\/vg02.met.vgwort.de\/na\/3018cd3173a248bebd8272050f70e16d"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/adonet__eine_einfuehrung\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"ADO.NET – eine Einführung"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000233","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000233"}],"version-history":[{"count":1,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000233\/revisions"}],"predecessor-version":[{"id":88075291,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000233\/revisions\/88075291"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000233"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000233"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000233"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}