![\"Verbindungseigenschaften](\"..\/fileadmin\/_temp_\/2022_04\/pic_1381_001.png\")
<\/p>\n
Bild 1: Verbindungseigenschaften für die Datenbank<\/span><\/b><\/p>\n Bild 2: Die verfügbaren Tabellen<\/span><\/b><\/p>\n Wir wollen immer, wenn wir die Anwendung ausprobieren, einen frischen Satz von Daten bereitstellen. Eventuell bei einem vorherigen Test geänderte, hinzugefügte oder gelöschte Daten wollen wir wieder in den Urzustand versetzen – damit ermöglichen wir auch das automatisierte Testen von Teilen der Anwendung. Zum Löschen der Daten verwenden wir die Prozedur aus Listing 1. Diese rufen wir von der automatisch beim Hinzufügen der Query bereitgestellten Methode Main aus auf:<\/p>\n Listing 1: Löschen der Daten<\/span><\/b><\/p>\n Die Prozedur DatenLoeschen <\/b>definiert das UserQuery<\/b>-Objekt, über das wir auf die einzelnen Tabellen der Datenbank zugreifen können. Hier rufen wir für jede Tabelle einmal die Execute<\/b>-Methode auf und übergeben jeweils eine DELETE<\/b>-Abfrage, mit der wir die Daten der jeweiligen Tabelle löschen. Dies erledigen wir gleich für alle Tabellen der Datenbank, und zwar in einer Reihenfolge, in der zuerst die Daten aus den Tabellen gelöscht werden, die über Fremdschlüsselfelder mit anderen Tabellen verknüpft sind. Die Tabelle tblBestellpositionen <\/b>ist gleich über zwei Fremdschlüsselfelder mit den Tabellen tblBestellungen <\/b>und tblProdukte <\/b>verknüpft, sodass wir diese zuerst leeren.<\/p>\n Danach folgt die Tabelle tblBestellungen<\/b>, die mit der Tabelle tblKunden <\/b>verknüpft ist. Die Tabelle tblKunden <\/b>ist wiederum mit den Datensätzen der Tabelle tblAnreden <\/b>verknüpft und wird als nächstes gelöscht. Die Tabelle tblProdukte <\/b>greift auf Daten aus den Tabellen tblEinheiten <\/b>und tblMehrwertsteuersaetze <\/b>zu und muss folglich vor diesen Tabellen geleert werden. Wenn wir für die Beziehungen die Löschweitergabe definiert hätten, könnten wir die Löschvorgänge andersherum steuern und würden auch weniger DELETE<\/b>-Anweisungen brauchen, weil ja die Inhalte verknüpfter Tabellen direkt mit gelöscht werden.<\/p>\n Anschließend beginnen wir damit, einige der Tabellen erneut zu füllen. Am einfachsten geht das mit den Tabellen, für die wir keine Zufallsdaten generieren müssen, sondern die wir direkt mit den gewünschten Daten füllen.<\/p>\n Da wäre als Erstes die Tabelle tblAnreden<\/b>, die wir mit den bekannten Anreden füllen. Die dazu notwendige Prozedur finden Sie in Listing 2.<\/p>\n Listing 2: Anlegen der Anreden<\/span><\/b><\/p>\n Auf ähnliche Weise füllen wir die Tabelle tblEinheiten<\/b>, und zwar mit der Prozedur EinheitenAnlegen <\/b>(siehe Listing 3). <\/p>\n Listing 3: Anlegen der Einheiten<\/span><\/b><\/p>\n Und auch die Tabelle tblMehrwertsteuersaetze<\/b> füllen wir nach diesem Schema (siehe Listing 4).<\/p>\n Listing 4: Anlegen der Mehrwertsteuersätze<\/span><\/b><\/p>\n Damit geht es nun an die wirklich interessanten Daten – nämlich die, welche wir mit dem Zufallsgenerator erstellen lassen. In welcher Reihenfolge gehen wir mit den übrigen Tabellen nun vor? Wir beginnen mit den Tabellen, die nur mit den bisher gefüllten Tabellen verknüpft sind. Hier bieten sich zunächst die Tabellen tblProdukte <\/b>und tblKunden <\/b>an.<\/p>\n Als Nächstes wollen wir also die Tabelle tblProdukte <\/b>mit einigen Datensätzen füllen. Wir hätten gern 100 verschiedene Produkte, also fügen wir schon einmal den Aufruf der noch zu definierenden Prozedur ProdukteAnlegen <\/b>mit dem Wert 100 <\/b>als Parameter zur Methode Main <\/b>hinzu:<\/p>\n Die dadurch aufgerufene Prozedur finden Sie in Listing 5. Hier finden wir als Erstes den Parameter intMenge <\/b>vor, dem wir die Anzahl der zu erzeugenden Produkte übergeben.<\/p>\n Listing 5: Zufallsgesteuertes Anlegen von Produkten<\/span><\/b><\/p>\n Die Prozedur greift über die Tabelle tblProdukte <\/b>auf den DataContext <\/b>der Datenbankverbindung zu. Mit einer Lambda-Funktion (eine Erläuterung würde den Rahmen sprengen) definieren wir die Regeln für das Anlegen der Beispieldaten. Als Produktbezeichnung wählen wir die Eigenschaft ProduktName <\/b>der Klasse Commerce<\/b>. Für den Preis nutzen wir die Eigenschaft Price <\/b>der gleichen Klasse und geben hier den kleinsten und den größten möglichen Preis an sowie die Anzahl der Nachkommastellen. Wir erhalten hiermit Preise zwischen 10 und 100 EUR mit zwei Nachkommastellen.<\/p>\n Dann folgen die interessanten Elemente, nämlich die zufällige Auswahl von Einträgen der Tabelle tblEinheiten<\/b>. Dies erreichen wir mit der Funktion PickRandom<\/b>, der wir den Typ der Klasse mit den gewünschten Daten übergeben und für die wir anschließend einen Verweis auf die zu verwendende Auflistung tblEinheiten <\/b>übergeben. Von dem jeweils gewählten Element möchten wir dem Feld Einheit <\/b>des neuen Produkts die Eigenschaft ID <\/b>der Tabelle tblEinheiten <\/b>zuweisen.<\/p>\n Anschließend durchläuft die Prozedur eine For…Next<\/b>-Schleife über die mit dem Parameter intMenge <\/b>angegebene Anzahl von Elementen. Darin erstellen wir mit der Generate<\/b>-Methode des Faker<\/b>-Objekts ein neues Element und weisen seiner Eigenschaft ID <\/b>den Wert der Laufvariablen zu. Anschließend geben wir zur Prüfung noch ein paar Eigenschaften aus, bevor wir das Element mit der Insert<\/b>-Methode zur Tabelle tblProdukte <\/b>hinzufügen.<\/p>\n <\/p>\n Nun wollen wir den Code ausprobieren, um die Produkte hinzuzufügen. Dazu ist es wie immer wichtig, dass die Datenbank geschlossen ist. Anderenfalls kann LINQPad nicht schreibend auf die enthaltenen Tabellen zugreifen.<\/p>\n Beim Aufrufen der Methode Main <\/b>beispielsweise mit der Taste F5 <\/b>erhalten wir jedoch den Fehler aus Bild 3. Allerdings tritt dieser Fehler nicht immer auf, und er passiert meist nach einer scheinbar willkürlich angelegten Anzahl von Produktdatensätzen. <\/p>\n Bild 3: Fehlermeldung beim Hinzufügen von Produkten<\/span><\/b><\/p>\n Die Fehlermeldung weist darauf hin, dass ein eindeutiger Schlüssel verletzt wurde, also dass wir versuchen, einen bereits vorhandenen Wert nochmals in ein Feld mit einem eindeutigen Index einzufügen. Leider erhalten wir keinen Hinweis, um welches Feld es sich handelt. Also können wir nur selbst nachsehen und müssten dazu eigentlich die Datenbank öffnen – was nach sich ziehen würde, dass wir auch den Zugriff auf die Datenbank via LINQPad unterbrechen müssen, was am zuverlässigsten geschieht, indem wir LINQPad schließen.<\/p>\n Allerdings haben wir bereits eine Debug.Print<\/b>-Anweisung hinterlegt, welche die ID und den Produktnamen des anzulegenden Datensatzes ausgibt. Hier finden wir schnell heraus, dass es nicht an der ID liegt, sondern am Produktnamen – Bogus liefert schlicht keine eindeutigen Produktnamen und so kommt es früher oder später (oder auch mal gar nicht) dazu, dass ein Produktname doppelt angelegt wird.<\/p>\n Die performanteste Möglichkeit, dies zu umgehen, ist das Ignorieren des Fehlers und das erneute Schreiben eines Produktdatensatzes im Fehlerfall. Dazu fügen wir eine Try…Catch<\/b>-Anweisung zur Schleife hinzu, die wie in Listing 6 aussieht. Wir fügen die Insert<\/b>-Methode in den Try<\/b>-Block ein. Tritt hier ein Fehler auf, wird der Catch<\/b>-Block ausgeführt.<\/p>\n Listing 6: Erweiterung um eine Fehlerbehandlung<\/span><\/b><\/p>\n In diesem Block geben wir, nur zur Information, die Fehlermeldung im Direktbereich von LINQPad aus. Außerdem setzen wir i <\/b>um 1 <\/b>zurück, damit die Prozedur einen neuen Anlauf starten kann, einen eindeutigen Produktnamen zu finden.<\/p>\n Wir könnten an dieser Stelle auch jeweils prüfen, ob der neu ermittelte Produktname bereits vorhanden ist, aber dies würde mit wachsender Anzahl vorhandener Produkte immer mehr Zeit in Anspruch nehmen. Die Methode mit Try…Catch <\/b>scheint die performantere Möglichkeit zu sein.<\/p>\n Schließen wir nun LINQPad und öffnen wir die Tabelle tblProdukte <\/b>der Datenbank, finden wir die gewünschten 100 Datensätze in der Tabelle tblProdukte<\/b> vor (siehe Bild 4).<\/p>\n Bild 4: Die Tabelle tblProdukte mit Beispieldaten<\/span><\/b><\/p>\n Als Nächstes folgen die Kundendaten. Auch für diese legen wir eine neue Prozedur an, die wir diesmal KundenAnlegen <\/b>nennen (siehe Listing 7). Auch diese Prozedur erhält einen Parameter, der wieder intMenge<\/b> heißt und die Anzahl der zu erstellenden Kundendatensätze entgegennimmt.<\/p>\n Listing 7: Anlegen von Kundendaten<\/span><\/b><\/p>\n Diesmal haben wir keine Probleme wegen der Verletzung eindeutiger Indizes zu erwarten, da in der Tabelle tblKunden <\/b>neben dem Primärschlüsselfeld ID<\/b> keine Felder mit eindeutigem Schlüssel versehen sind. Man könnte sich überlegen, ob man eines für die Firma vorsieht, aber es kann durchaus sein, dass es mehrere Kunden mit der gleichen Firmenadresse gibt. Und da es selbst mehrere Michael Müller in der gleichen Firma geben kann (die Firma muss nur groß genug sein), lassen wir den eindeutigen Index einfach weg.<\/p>\n Wir legen wieder mithilfe der Lambda-Funktion Function(f, k) <\/b>eine Vorlage an, mit der wir in der anschließenden For…Next<\/b>-Schleife die Datensätze der Tabelle tblKunden <\/b>füllen.<\/p>\n Damit wir die Anrede und den Vornamen passend zum jeweiligen Geschlecht ermitteln können, definieren wir die folgende Enumeration:<\/p>\n So ermitteln wir in der Vorlage als Erstes mit PickRandom(Of Gender) <\/b>einen der beiden Werte dieser Enumeration und speichern diesen in der Variablen intGender<\/b>. Dann ermitteln wir die Kundennummer, die sich aus der Summe aus 99000000 <\/b>und dem Index i <\/b>zusammensetzt – für den ersten Kunden also beispielsweise 99000001<\/b>.<\/p>\n Danach ermitteln wir den Namen der Firma <\/b>über die Eigenschaft CompanyName <\/b>der Klasse Company<\/b>.<\/p>\n Erst dann kommen wir zur Anrede und zum Vornamen. Wir wissen, dass die beiden Datensätze Herr <\/b>und Frau <\/b>in der Tabelle tblAnreden <\/b>die Werte 1 <\/b>und 2 <\/b>als Primärschlüsselwert verwenden. Daher können wir den Wert des Fremdschlüsselfeldes AnredeID <\/b>mit intGender + 1 <\/b>füllen.<\/p>\n Den Vornamen ermitteln wir mit der Eigenschaft FirstName <\/b>der Klasse Name<\/b>, der wir intGender <\/b>übergeben, also einen der Werte der Enumeration Gender<\/b>. Die Eigenschaft liefert entsprechend einen männlichen oder einen weiblichen Namen zurück.<\/p>\n Den Nachnamen ermitteln wir mit Name.LastName<\/b>, die Adressdaten mit Address.StreetAddress<\/b>, Address.ZipCode <\/b>und Address.City<\/b>. Schließlich stellen wir das Feld LandID <\/b>für alle Datensätze auf den statischen Wert 1 <\/b>ein (für Deutschland<\/b>).<\/p>\n Von der Umsatzsteuer-Identifikationsnummer wissen wir, dass diese für deutsche Unternehmen mit DE beginnen und aus neun weiteren Ziffern bestehen. Also nehmen wir DE <\/b>als statischen Teil und fügen dann eine Zufallszahl zwischen 100.000.000 <\/b>und 999.999.999 <\/b>hinzu, sodass beispielsweise DE123456789 herauskommt.<\/p>\n Die E-Mail liefert hingegen die Eigenschaft Email <\/b>der Klasse Internet<\/b>. Damit sind auch alle Felder definiert und wir können uns dem eigentlichen Erstellen zuwenden. In der Schleife erstellen wir mit der Generate<\/b>-Methode jeweils ein neues Element und weisen diesem für das Primärschlüsselfeld ID <\/b>den Wert der Zählervariablen i <\/b>der Schleife zu. Schließlich fügen wir den neuen Kunden mit der Insert-Methode zur Tabelle tblKunden <\/b>hinzu. Die Tabelle sieht nach dem Hinzufügen von 100 Kunden wie in Bild 5 aus.<\/p>\n Bild 5: Frisch erstellte Kundendatensätze<\/span><\/b><\/p>\n Damit gehen wir direkt zur Tabelle tblBestellungen <\/b>über. Hier nutzen wir wieder den Parameter intMenge<\/b>, um die Anzahl der anzulegenden Bestellungen einzustellen (siehe Listing 8).<\/p>\n Listing 8: Anlegen von Bestelldaten <\/span><\/b><\/p>\n Der Aufruf in der Methode Main <\/b>lautet diesmal:<\/p>\n Beim Zusammenstellen der Vorlage für das Erstellen der Bestellungen ermitteln wir zunächst mit f.PickRandom(Of tblKunden)(tblKunden).ID <\/b>zufällig einen Kunden und weisen diesen dem Fremdschlüsselfeld KundeID <\/b>zu.<\/p>\n Die Bestellnummer entspricht der Summe von 11.000.000 <\/b>plus i<\/b>, also beispielsweise 11000123<\/b>. Das Bestelldatum ermitteln wir mit der Past<\/b>-Eigenschaft der Date<\/b>-Klasse, wobei wir zufällig Werte im Zeitraum von vor einem Jahr bis heute ermitteln.<\/p>\n Danach ermitteln wir für die Boolean<\/b>-Variable bolNichtStorniert<\/b>, ob die aktuelle Bestellung als storniert eingetragen werden soll. Dazu nutzen wir den Ausdruck f.Random.Bool(0.85)<\/b>, der zu 85% den Wert True <\/b>liefert. Wurde die Bestellung nicht storniert, legen wir das Rechnungsdatum fest (zwischen 1 <\/b>und 10 <\/b>Tage nach dem Bestelldatum) sowie das Zahlungsziel (21 Tage nach dem Rechnungsdatum). Hier nutzen wir die DateAdd<\/b>-Methode der Klasse DateAndTime <\/b>des Namespaces Microsoft.VisualBasic<\/b>.<\/p>\n Ein paar Kunden bezahlen ihre Rechnung nicht, also legen wir nur für die Rechnungen, die bezahlt wurden, einen Wert im Feld BezahltAm <\/b>fest.<\/p>\n Hat bolNichtStorniert <\/b>den Wert False<\/b>, legen wir einen Wert für das Feld StorniertAm <\/b>fest.<\/p>\n Schließlich tragen wir die Datensätze auf Basis dieser Vorlage mit der Generate<\/b>-Methode in die Tabelle tblBestellungen <\/b>ein. Die Tabelle tblBestellungen<\/b> sieht anschließend wie in Bild 6 aus.<\/p>\n Bild 6: Neue Bestellungen, die teilweise storniert oder nicht bezahlt wurden<\/span><\/b><\/p>\n Schließlich fehlen nur noch die Bestellpositionen (siehe Listing 9). Die Prozedur BestellpositionenAnlegen <\/b>erwartet die folgenden Parameter:<\/p>\n Listing 9: Anlegen von Bestellpositionen<\/span><\/b><\/p>\n In der Lambda-Funktion zum Definieren der Vorlage für einen Datensatz der Tabelle tblBestellpositionen <\/b>ermitteln wir zunächst zufällig einen Datensatz aus der Tabelle tblProdukte<\/b>.<\/p>\n Das Produkt referenzieren wir dabei noch mit der Variablen objProdukt<\/b>, da wir noch auf weitere Eigenschaften dieses Datensatzes zugreifen wollen. Hier lesen wir zunächst den Wert des Primärschlüsselfeldes ID <\/b>aus und tragen diesen für das Fremdschlüsselwertfeld ProduktID <\/b>ein. Für das Feld Menge <\/b>tragen wir einen Wert zwischen intMengeMin <\/b>und intMengeMax <\/b>ein, den wir mit der Funktion Int <\/b>der Klasse Random <\/b>ermitteln.<\/p>\n Den Einzelpreis fügen einfach aus dem Produkt in das Feld Einzelpreis <\/b>ein. Etwas komplizierter ist der Mehrwertsteuersatz. Dieser ist über das Fremdschlüsselfeld MehrwertsteuersatzID <\/b>festgelegt worden und wir müssen den dazugehörigen Mehrwertsteuersatz auslesen. Also ermitteln wir erst einmal den Fremdschlüsselwert aus dem Feld MehrwertsteuersatzID <\/b>aus und speichern ihn in der Variablen lngMehrwertsteuersatzID<\/b>. Diesen nutzen wir dazu, das Element aus der Tabelle tblMehrwertsteuersaetze<\/b> zu ermitteln und mit der Variable objMehrwertsteuersatz <\/b>zu referenzieren. Daraus lesen wir den Wert des Feldes Mehrwertsteuersatz <\/b>aus und tragen ihn in das Feld Mehrwertsteuersatz <\/b>der Bestellposition ein. Für die Einheit tragen wir einfach den Wert des Feldes EinheitID <\/b>in das gleichnamige Feld der Bestellposition ein.<\/p>\n Spannend wird das Feld Rabatt<\/b>. Da keine Werte für dieses Feld in irgendeiner Tabelle vorliegen, nutzen wir die Funktion PickRandomParam <\/b>aus. Diese ermöglicht es, mehrere Werte anzugeben, aus denen zufällig einer ausgewählt wird. Unsere Parameterliste lautet 0,0,0,0,0,5,5,10,15. Alle Werte werden mit der gleichen Wahrscheinlichkeit ausgewählt. Da wir beispielsweise fünf Mal den Wert 0 <\/b>angegeben haben und vier andere Werte, wird mit einer Wahrscheinlichkeit von 5\/9 <\/b>der Wert 0 <\/b>gewählt.<\/p>\n Schließlich tragen wir in intPositionen <\/b>noch die Anzahl der Positionen für die jeweilige Bestellung ein. Die minimale und maximale Anzahl übergeben wir mit den Parametern intPositionenMin <\/b>und intPositionenMax<\/b>.<\/p>\n Danach folgt die erste von zwei For…Next<\/b>-Schleifen, mit der wir die Werte von 1 <\/b>bis zur Anzahl der für die Tabelle tblBestellungen <\/b>angelegten Datensätze durchlaufen – in diesem Fall also 300<\/b>. Die Schleife enthält neben einer weiteren For…Next<\/b>-Schleife nur eine Anweisung, in der wir mithilfe von objFaker.Generate <\/b>die Variable intPositionen <\/b>füllen. Diese nutzen wir für die zweite For…Next<\/b>-Schleife, die von 1 <\/b>bis zur Anzahl der Positionen dieser Bestellung aus intPositionen <\/b>läuft. Hier rufen wir ![\"Die](\"..\/fileadmin\/_temp_\/2022_04\/pic_1381_002.png\")
<\/p>\nVorhandene Daten löschen<\/h2>\n
Public Sub <\/span>DatenLoeschen\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n objUserQuery = tblAnreden.DataContext\r\n objUserQuery.Execute(\"DELETE FROM tblBestellpositionen\")\r\n objUserQuery.Execute(\"DELETE FROM tblBestellungen\")\r\n objUserQuery.Execute(\"DELETE FROM tblKunden\")\r\n objUserQuery.Execute(\"DELETE FROM tblProdukte\")\r\n objUserQuery.Execute(\"DELETE FROM tblAnreden\")\r\n objUserQuery.Execute(\"DELETE FROM tblEinheiten\")\r\n objUserQuery.Execute(\"DELETE FROM tblMehrwertsteuersaetze\")\r\nEnd Sub<\/span><\/pre>\nSub <\/span>Main\r\n DatenLoeschen\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>AnredenAnlegen\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n objUserQuery = tblAnreden.DataContext\r\n objUserQuery.Insert(New<\/span> tblAnreden With<\/span> {.ID = 1, .Anredebezeichnung = \"Herr\"})\r\n objUserQuery.Insert(New<\/span> tblAnreden With<\/span> {.ID = 2, .Anredebezeichnung = \"Frau\"})\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>EinheitenAnlegen\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n objUserQuery = tblEinheiten.DataContext\r\n objUserQuery.Insert(New<\/span> tblEinheiten With<\/span> {.ID = 1, .Einheitbezeichnung = \"Stück\"})\r\n objUserQuery.Insert(New<\/span> tblEinheiten With<\/span> {.ID = 2, .Einheitbezeichnung = \"Stunde\"})\r\n objUserQuery.Insert(New<\/span> tblEinheiten With<\/span> {.ID = 3, .Einheitbezeichnung = \"Pauschal\"})\r\n objUserQuery.Insert(New<\/span> tblEinheiten With<\/span> {.ID = 4, .Einheitbezeichnung = \"Kilo\"})\r\n objUserQuery.Insert(New<\/span> tblEinheiten With<\/span> {.ID = 5, .Einheitbezeichnung = \"Liter\"})\r\n objUserQuery.Insert(New<\/span> tblEinheiten With<\/span> {.ID = 6, .Einheitbezeichnung = \"Meter\"})\r\n objUserQuery.Insert(New<\/span> tblEinheiten With<\/span> {.ID = 7, .Einheitbezeichnung = \"Abonnement\"})\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>MehrwertsteuersaetzeAnlegen\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n objUserQuery = tblMehrwertsteuersaetze.DataContext\r\n objUserQuery.Insert(New<\/span> tblMehrwertsteuersaetze With<\/span> {.ID = 1, .Mehrwertsteuersatzbezeichnung = _\r\n \"Ermäßigter Mehrwertsteuersatz\", .Mehrwertsteuersatzwert = 0,07})\r\n objUserQuery.Insert(New<\/span> tblMehrwertsteuersaetze With<\/span> {.ID = 2, .Mehrwertsteuersatzbezeichnung = _\r\n \"Regelsteuersatz\", .Mehrwertsteuersatzwert = 0,19})\r\nEnd Sub<\/span><\/pre>\nProdukte per Zufallsgenerator füllen<\/h2>\n
Sub <\/span>Main\r\n DatenLoeschen\r\n AnredenAnlegen\r\n MehrwertsteuersaetzeAnlegen\r\n EinheitenAnlegen\r\n ProdukteAnlegen(100)\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>ProdukteAnlegen(intMenge As <\/span>Int32)\r\n Dim <\/span>Beispielprodukt As <\/span>New<\/span> tblProdukte\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n Dim <\/span>i As <\/span>Int32\r\n objUserQuery = tblProdukte.DataContext\r\n Dim <\/span>objFaker As <\/span>New<\/span> Bogus.Faker(Of tblProdukte)(\"de\")\r\n objFaker.Rules(Function(f, p)\r\n p.Produktbezeichnung = f.Commerce.ProductName\r\n p.Einzelpreis = f.Commerce.Price(10, 100, 2)\r\n p.EinheitID = f.PickRandom(Of tblEinheiten)(tblEinheiten).ID\r\n p.MehrwertsteuersatzID = f.PickRandom(Of tblMehrwertsteuersaetze)(tblMehrwertsteuersaetze).ID\r\n End Function)\r\n For i = 1 To intMenge\r\n Beispielprodukt = objFaker.Generate\r\n Beispielprodukt.ID = i\r\n Debug.Print<\/span>(\"ID: \" & i & \" \" & Beispielprodukt.ID.ToString & \" \" & Beispielprodukt.Produktbezeichnung)\r\n objUserQuery.Insert(Beispielprodukt)\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\nFehlermeldung beim Hinzufügen von Produkten<\/h2>\n
![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2022_04\/pic_1381_003.png\")
<\/p>\nFehlerbehandlung mit Try…Catch<\/h2>\n
For i = 1 To intMenge\r\n Beispielprodukt = objFaker.Generate\r\n Beispielprodukt.ID = i\r\n Debug.Print<\/span>(\"ID: \" & i & \" \" & Beispielprodukt.ID.ToString & \" \" & Beispielprodukt.Produktbezeichnung)\r\n Try\r\n objUserQuery.Insert(Beispielprodukt)\r\n Catch e As <\/span>Exception\r\n Debug.Print<\/span>(\"Fehler: \" & e.Message) \r\n i = i - 1\r\n End Try\r\nNext<\/span><\/pre>\nErgebnis in der Tabelle tblProdukte prüfen<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2022_04\/pic_1381_004.png\")
<\/p>\nKundendaten anlegen<\/h2>\n
Public Sub <\/span>KundenAnlegen(intMenge As <\/span>Int32)\r\n Dim <\/span>Beispielkunde As <\/span>New<\/span> tblKunden\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n Dim <\/span>i As <\/span>Int32\r\n Dim <\/span>intGender As <\/span>int32\r\n objUserQuery = tblKunden.DataContext\r\n Dim <\/span>objFaker As <\/span>New<\/span> Bogus.Faker(Of tblKunden)(\"de\")\r\n objFaker.Rules(Function(f, k)\r\n intGender = f.PickRandom(Of Gender)\r\n k.kundennummer = 99000000 + i\r\n k.Firma = f.Company.CompanyName\r\n k.AnredeID = intGender + 1\r\n k.Vorname = f.Name.FirstName(intGender)\r\n k.Nachname = f.Name.LastName()\r\n k.Strasse = f.Address.StreetAddress\r\n k.PLZ = f.Address.ZipCode\r\n k.Ort = f.Address.City\r\n k.LandID = 1\r\n k.UstIDNr = \"DE\" & f.Random.Number(100000000, 999999999)\r\n k.EMail = f.Internet.Email\r\n End Function)\r\n For i = 1 To intMenge\r\n Beispielkunde = objFaker.Generate\r\n Beispielkunde.ID = i\r\n objUserQuery.Insert(Beispielkunde)\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic <\/span>Enum Gender\r\n Male = 0\r\n Female = 1\r\nEnd Enum<\/pre>\nWeitere Adressdaten<\/h2>\n
Umsatzsteuer-Identifikationsnummer per Zufall<\/h2>\n
![\"Frisch](\"..\/fileadmin\/_temp_\/2022_04\/pic_1381_005.png\")
<\/p>\nBestellungen anlegen<\/h2>\n
Public Sub <\/span>BestellungenAnlegen(intMenge As <\/span>Int32)\r\n Dim <\/span>Beispielbestellung As <\/span>New<\/span> tblBestellungen\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n Dim <\/span>i As <\/span>Int32\r\n Dim <\/span>bolNichtStorniert As Boolean<\/span>\r\n Dim <\/span>bolBezahlt As Boolean<\/span>\r\n objUserQuery = tblBestellungen.DataContext\r\n Dim <\/span>objFaker As <\/span>New<\/span> Bogus.Faker(Of tblBestellungen)(\"de\")\r\n objFaker.Rules(Function(f, b)\r\n b.KundeID = f.PickRandom(Of tblKunden)(tblKunden).ID\r\n b.Bestellnummer = 11000000 + i\r\n b.BestelltAm = f.Date.Past(1, DateTime.Now)\r\n bolNichtStorniert = f.Random.Bool(0.85)\r\n If <\/span>bolNichtStorniert Then<\/span>\r\n b.RechnungAm = Microsoft.VisualBasic.DateAndTime.DateAdd(\"d\", f.Random.Number(1, 10), b.BestelltAm)\r\n b.Zahlungsziel = Microsoft.VisualBasic.DateAndTime.DateAdd(\"d\", 21, b.RechnungAm)\r\n bolBezahlt = f.Random.Bool(0.9)\r\n If <\/span>bolBezahlt Then<\/span>\r\n b.BezahltAm = Microsoft.VisualBasic.DateAndTime.DateAdd(\"d\", f.Random.Number(1, 10), b.RechnungAm)\r\n End if\r\n Else<\/span>\r\n b.StorniertAm = Microsoft.VisualBasic.DateAndTime.DateAdd(\"d\", f.Random.Number(1, 10), b.BestelltAm)\r\n End If<\/span>\r\n End Function)\r\n For i = 1 To intMenge\r\n Beispielbestellung = objFaker.Generate\r\n Beispielbestellung.ID = i\r\n objUserQuery.Insert(Beispielbestellung)\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\nBestellungenAnlegen(300)<\/pre>\n
![\"Neue](\"..\/fileadmin\/_temp_\/2022_04\/pic_1381_006.png\")
<\/p>\nBestellpositionen hinzufügen<\/h2>\n
Public Sub <\/span>BestellpositionenAnlegen(intPositionenMin As <\/span>Int32, intPositionenMax As <\/span>Int32, intMengeMin As <\/span>Int32, _\r\n intMengeMax As <\/span>int32)\r\n Dim <\/span>Beispielbestellposition As <\/span>New<\/span> tblBestellpositionen\r\n Dim <\/span>objUserQuery As <\/span>UserQuery\r\n Dim <\/span>objProdukt AS tblProdukte\r\n Dim <\/span>lngMehrwertsteuersatzID As <\/span>int32\r\n Dim <\/span>objMehrwertsteuersatz As <\/span>tblMehrwertsteuersaetze\r\n Dim <\/span>i As <\/span>Int32\r\n Dim <\/span>j As <\/span>int32\r\n Dim <\/span>k As <\/span>int32\r\n Dim <\/span>intPositionen As <\/span>Int32\r\n objUserQuery = tblBestellpositionen.DataContext\r\n Dim <\/span>objFaker As <\/span>New<\/span> Bogus.Faker(Of tblBestellpositionen)(\"de\")\r\n objFaker.Rules(Function(f, b)\r\n objProdukt = f.PickRandom(Of tblProdukte)(tblProdukte)\r\n b.ProduktID = objProdukt.ID\r\n b.Menge = f.Random.Int(intMengeMin, intMengeMax)\r\n b.Einzelpreis = objProdukt.Einzelpreis\r\n lngMehrwertsteuersatzID = objProdukt.MehrwertsteuersatzID\r\n objMehrwertsteuersatz = tblMehrwertsteuersaetze.First(Function(m) m.ID = lngMehrwertsteuersatzID)\r\n b.Mehrwertsteuersatz = objMehrwertsteuersatz.Mehrwertsteuersatzwert\r\n b.EinheitID = objProdukt.EinheitID\r\n b.Rabatt = f.PickRandomParam(0,0,0,0,0,5,5,10,15)\r\n intPositionen = f.Random.Int(intPositionenMin, intPositionenMax)\r\n End Function)\r\n For i = 1 To tblBestellungen.Count\r\n Beispielbestellposition = objFaker.Generate\r\n For j = 1 To intPositionen\r\n Beispielbestellposition = objFaker.Generate\r\n k = k + 1\r\n Beispielbestellposition.ID = k\r\n Beispielbestellposition.BestellungID = tblBestellungen.ElementAt(i-1).ID\r\n Try\r\n objUserQuery.Insert(Beispielbestellposition)\r\n Catch\r\n k = k - 1\r\n j = j - 1\r\n End Try\r\n Next<\/span> j\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\n\n