{"id":55000288,"date":"2021-10-01T00:00:00","date_gmt":"2022-02-15T13:17:10","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=288"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Beispieldaten_generieren_mit_Bogus","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Beispieldaten_generieren_mit_Bogus\/","title":{"rendered":"Beispieldaten generieren mit Bogus"},"content":{"rendered":"

Wenn Sie eine Anwendung entwickeln, können Sie die meisten Funktionen nur testen, wenn die zugrunde liegende Datenbank bereits Beispieldaten enthält. Ausnahmen sind beispielsweise Formulare zum Anlegen neuer Datensätze – hier legen Sie die Beispieldatenbank selbst an. In allen anderen Fällen kann es nicht schaden, ein paar Beispieldatensätze in den jeweiligen Tabellen bereitzustellen. Oft reicht es aus, das Anlegen einiger Elemente wie Kunden oder Produkte hart im Code zu verdrahten. Wenn Sie allerdings flexibel schnell für verschiedene Datenmodelle und Anwendungen Beispieldaten benötigen, reduzieren Sie den Aufwand zum Zusammenstellen der Beispieldaten zwar auf das einmalige Schreiben des Codes. Es macht aber auch keinen Spaß, sich dann Informationen wie Teststraße, Beispielfirma und Co. aus den Fingern zu saugen. Um dies zu automatisieren und gegebenenfalls auch größere Mengen an Beispieldaten zu generieren, gibt es spezielle Tools. Eine davon heißt Bogus – und diese stellen wir in diesem Artikel im Detail vor.<\/b><\/p>\n

Für Menschen wie mich, die immer wieder frische Daten für die Beispiele für die Artikel und Bücher benötigen, ist ein Tool zum automatischen Generieren von Beispielcode natürlich Gold wert. Aber auch Sie können sich vermutlich eine Menge Arbeit sparen, wenn Sie die Tabellen Ihrer Anwendung vor dem Testen schnell mit passenden Beispieldaten füllen können.<\/p>\n

Wie für die meisten Anwendungsfälle, die Sie mit Visual Studio abarbeiten, finden sich auch hier passende Erweiterungen im NuGet-Paket-Manager. Das Paket, das wir in diesem Artikel vorstellen wollen, heißt Bogus und bietet bereits in der kostenlosen Variante sehr viele verschiedene mögliche Generatoren für Daten unterschiedlichster Art an.<\/p>\n

Um zuvor einmal die grundlegende Idee zu skizzieren: Wir gehen davon aus, dass Sie in der zu programmierenden Anwendung beispielsweise eine Tabelle namens Kunden <\/b>verwenden, dessen Einträge im Entity Data Model der Anwendung jeweils in einem Element namens Kunde <\/b>gespeichert werden. Das Tool, in diesem Fall Bogus, soll uns eine Möglichkeit bieten, die Eigenschaften neu erstellter Elemente des Typs Kunde <\/b>mit Werten zu füllen.<\/p>\n

Wenn Kunde also beispielsweise Eigenschaften wie Anrede<\/b>, Vorname<\/b>, Nachname<\/b>, Strasse<\/b>, PLZ <\/b>und Ort <\/b>enthält, dann müsste das Tool Funktionen bereitstellen, mit denen Werte für genau diese Felder erzeugt werden können und die nach dem Zufallsprinzip ausreichend neue Werte liefern.<\/p>\n

Noch spannender wird es an der Stelle, wo wir verknüpfte Tabellen haben – zum Beispiel Kunden <\/b>und Bestellungen<\/b>. Im einem Entity Data Model haben wir dann zwei Klassen namens Kunde <\/b>und Bestellung<\/b>, deren Eigenschaften wir nacheinander füllen müssen. Allerdings müssen wir zuerst die Kunden erstellen und wenn wir in einer Bestellung den Kunden referenzieren, der diese Bestellung aufgegeben haben, müssen wir auf einen der zuvor erstellten Kunden verweisen. Auch diese Möglichkeit bietet das hier verwendete Tool Bogus<\/b>.<\/p>\n

Beispielanwendung<\/h2>\n

Um die Funktionen von Bogus schnell und komfortabel testen zu können, nutzen wir LINQPad5<\/b>. Hier können wir Code schnell eingeben und ausführen, ohne immer direkt ein Projekt erstellen zu müssen. Wenn Sie LINQ-Pad5 <\/b>geöffnet haben, sind zwei Schritte nötig: der Wechsel zu einem passenden Query-Typ, hier VB Program<\/b>, und das Hinzufügen von Bogus zur Query.<\/p>\n

Bogus zur Query hinzufügen<\/h2>\n

Um das Bogus-Paket zur Query hinzuzufügen, klicken Sie mit der rechten Maustaste auf den Registerreiter für die Query. Dort wählen Sie den Eintrag Query Properties… <\/b>aus (siehe Bild 1).<\/p>\n

\"Aufrufen<\/p>\n

Bild 1: Aufrufen der Query-Eigenschaften<\/span><\/b><\/p>\n

Dies öffnet den Dialog Query Properties<\/b>. Hier klicken Sie unten auf die Schaltfläche Add NuGet…<\/b>, was den Dialog LINQPad NuGet Manager <\/b>öffnet. Hier geben Sie im mittleren Bereich den Suchbegriff Bogus <\/b>ein und klicken dann für den obersten Eintrag auf die Schaltfläche Add to Query<\/b> (siehe Bild 2). Schließen Sie den Dialog, finden Sie den Eintrag Bogus <\/b>nun im Dialog Query Properties <\/b>im Bereich Additional Reference <\/b>vor.<\/p>\n

\"Hinzufügen<\/p>\n

Bild 2: Hinzufügen des Pakets Bogus<\/span><\/b><\/p>\n

Beispielkunde erstellen<\/h2>\n

Der Rahmen für die ersten Experimente mit Bogus ist eine einfache Kundenklasse. Diese definieren Sie wie folgt unterhalb der in der LINQPad-Query vorgegebenen Methode Main<\/b>:<\/p>\n

Public Class<\/span> Kunde\r\n     Property Vorname As String<\/span>\r\n     Property Nachname As String<\/span>\r\n     Property Strasse As String<\/span>\r\n     Property PLZ As String<\/span>\r\n     Property Ort As String<\/span>\r\n     Property Land As String<\/span>\r\n     Property EMail As String<\/span>\r\n     Property Telefon As String<\/span>\r\nEnd Class<\/span><\/pre>\n
In der Methode Main<\/b> werden wir gleich die Beispielmethoden aufrufen. Die erste heißt KundeAnlegen<\/b>:<\/p>\n
Sub <\/span>Main\r\n     KundeAnlegen\r\nEnd Sub<\/span><\/pre>\n
Bogus nutzen<\/h2>\n
Die einfachste Möglichkeit, Bogus zu verwenden, ist das Initialisieren einer Objektvariablen auf Basis des Objekts Bogus.Faker <\/b>und das anschließende Erzeugen der verschiedenen Zufallsdaten.<\/p>\n
Das folgende Beispiel erledigt das und gibt so beispielsweise ein zufällig ermitteltes Land aus:<\/p>\n
Public Sub <\/span>AndereBeispiele\r\n     Dim <\/span>objFaker As <\/span>New<\/span> Bogus.Faker()\r\n     Debug.Print<\/span> (objFaker.Address.Country)\r\nEnd Sub<\/span><\/pre>\n
Auf Basis dieses Beispiels könnten Sie imgrunde schon die Eigenschaften von neu erzeugte Objekten füllen. Es gibt jedoch noch praktischere Methoden. Mit der soeben vorgestellten Methode können Sie sich allerdings schon einmal durch die einzelnen Klassen und deren Eigenschaften arbeiten und sich die Möglichkeiten anschauen. Weiter unten finden Sie eine Beschreibung der einzelnen Klassen.<\/p>\n
Objekte mit Bogus füllen<\/h2>\n
Nun schauen wir uns in der Methode KundeAnlegen <\/b>am Beispiel eines neuen Kunden an, wie Sie Bogus nutzen können. Dabei erstellen wir zuerst ein neues Kunde<\/b>-Objekt und ein neues Objekt des Typs Bogus.Faker <\/b>für unsere Klasse Kunde<\/b>:<\/p>\n
Public Sub <\/span>KundeAnlegen\r\n     Dim <\/span>Beispielkunde As <\/span>New<\/span> Kunde\r\n     Dim <\/span>objFaker As <\/span>New<\/span> Bogus.Faker(Of Kunde)<\/pre>\n
Das Faker<\/b>-Objekt ist unser eigentlicher Generator. Für diesen legen wir über die RuleFor<\/b>-Eigenschaft fest, welche Eigenschaft des Zielobjekts mit welcher Eigenschaft des Fakers gefüllt wird. Die RuleFor<\/b>-Definitionen legen wir einfach in einer langen Zeile jeweils durch einen Punkt getrennt hintereinander an – der Übersichtlichkeit halber haben wir hier Zeilenumbrüche eingefügt. Die erste Regel besagt beispielsweise, dass wir die Eigenschaft Vorname <\/b>mit der Eigenschaft Name.FirstName <\/b>des Fakers füllen wollen, die weiteren Regeln legen die Quelle für die übrigen Eigenschaften fest:<\/p>\n
     objFaker.RuleFor(Function(k) k.Vorname, Function(f) f.Name.FirstName) _\r\n         .RuleFor(Function(k) k.Nachname, Function(f) f.Name.LastName) _\r\n         .RuleFor(Function(k) k.Strasse, Function(f) f.Address.StreetAddress) _\r\n         .RuleFor(Function(k) k.PLZ, Function(f) f.Address.ZipCode) _\r\n         .RuleFor(Function(k) k.Ort, Function(f) f.Address.City) _\r\n         .RuleFor(Function(k) k.Land, Function(f) f.Address.Country) _\r\n         .RuleFor(Function(k) k.EMail, Function(f) f.Internet.Email) _\r\n         .RuleFor(Function(k) k.Telefon, Function(f) f.Phone.PhoneNumber) <\/pre>\n
Dabei nutzen wir nicht nur die Name<\/b>-Klasse (für FirstName <\/b>und LastName<\/b>), sondern auch die Address<\/b>-Klasse (für alle Adress-relevanten Daten) sowie die Internet<\/b>-Klasse (für die E-Mail-Adresse aus der Eigenschaft Email<\/b>) und die Phone<\/b>-Klasse (für die Telefonnummer aus PhoneNumber<\/b>). Danach folgt das eigentliche Erstellen. Hier rufen wir die Generate<\/b>-Methode des Faker<\/b>-Objekts auf und schreiben das Ergebnis vom Typ Kunde <\/b>in die Variable Beispielkunde<\/b>:<\/p>\n
     Beispielkunde = objFaker.Generate<\/pre>\n
Die Werte der Eigenschaften des neuen Kunde<\/b>-Objekts schreiben wir danach wie folgt in den Debug-Bereich:<\/p>\n
     Debug.Print<\/span>(\"Vorname: \" & Beispielkunde.Vorname)\r\n     Debug.Print<\/span>(\"Nachname: \" & Beispielkunde.Nachname)\r\n     Debug.Print<\/span>(\"Strasse: \" & Beispielkunde.Strasse)\r\n     Debug.Print<\/span>(\"PLZ: \" & Beispielkunde.PLZ)\r\n     Debug.Print<\/span>(\"Ort: \" & Beispielkunde.Ort)\r\n     Debug.Print<\/span>(\"Land: \" & Beispielkunde.Land)\r\n     Debug.Print<\/span>(\"E-Mail: \" & Beispielkunde.EMail)\r\n     Debug.Print<\/span>(\"Telefon: \" & Beispielkunde.Telefon\r\nEnd Sub<\/span><\/pre>\n
Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Visual Basic Entwickler<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 200 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t
\n\n\t\t\n\t\t