RFID Chips mit Visual Basic .NET und dem Arduino Mikrocontroller auslesen

Wer in VB.NET Daten aus einem RFID-Chip auslesen möchte, trifft unter normalen Umständen vermutlich auf die handelsüblichen Geräte. Ruckzuck an den PC angeschlossen sind Sie auch schon startklar, uns die ausgelesenen Daten als Tastatur-Input bereitzustellen. Gleichzeitig liegt genau hier das Problem, jedoch gleich mehr dazu. Im heutigen Beitrag beschäftigen wir uns also mit einem RFID-Scanner der Marke Eigenbau und schauen uns die Verarbeitung mit VB.NET an.

Zu den bekannten Einsatzgebieten der kleinen RFID-Sensoren zählen unter anderem: Zugangs- und Zugriffskontrollen wie z. B. Ticketsysteme und Türen, aber ebenso bei unseren tierischen Freunden und sogar im Ausweis finden Sie Ihre Anwendung. Selbst beim Einkauf können wir mit der RFID-Technologie kontaktlose Bezahlvorgänge durchführen und somit unseren Alltag erleichtern.

💡 Achtung: In diesem Beitrag geht es in erster Linie um die Verarbeitung der RFID-Daten seitens VB.NET. Ich werde in einem zukünftigen Beitrag noch die Seite des Mikrocontrollers (Arduino Nano, Mega, whatever) erläutern. Hier beschäftigen wir uns ein wenig mit den Aspekten wie Handhabung und Sicherheit. Ich verwende in diesem Beitrag Affiliate-Links, womit Du mich vollkommen kostenlos bei einem Kauf über die Links unterstützen kannst.

VB.NET RFID Reader aus dem Handel = meist „Tastatur-a-like only“

Kommen wir nochmal genauer auf das Problem mit der angesprochenen Tastatur-Emulation (wenn das der exakt korrekte Ausdruck ist..) zurück. Wenn wir mit solchen Geräten, bzw. Sensoren wie einem RFID-Scanner arbeiten möchten, dann natürlich so flexibel wie möglich. Man stellt sich also vor, man startet seine Anwendung, lässt Sie in Ruhe laufen und wenn man loslegen will, kommt ein Kollege und möchte sich „eben“ im System anmelden.

Dies funktioniert mit den gängigen Geräten im Discount-Bereich häufig nicht, da Diese zwangsweise eine fokussierte Oberfläche (TextBox, etc.) benötigen. Das ist freilich nicht gerade cool, wenn wir eine Bestellung bearbeiten und zig Daten neu eingeben müssten, nachdem unser Kollege fertig ist. Schöner wäre es hingegen, wenn unser Kollege seinen Chip einscannt, eine kleine Maske kommt und er seine 2–3 Eingaben so erledigen könnte. Anschließend könnten wir dann mit unserer Arbeit fortfahren und wir wären durch.

Sicherlich gibt es vermutlich auch andere Varianten, Welche dann zig andere Funktionen unterstützen, aber hier bewegen wir uns dann auch zumeist im vergleichsweise teureren Preis-Segment. Leider bieten die handelsüblichen Geräte also häufig nur eine Art „nix Halbes und nix Ganzes“-Lösung. Das Gerät emuliert häufig einfach nur eine Art Tastatur, Welche dann die einzelnen Daten-Bestandteile runterschreibt und häufig mit einem „Enter“ bestätigt.

Was benötigen wir für den VB.NET RFID Reader

Bedenke den blauen Hinweis oben, dass wir in diesem Beitrag vorerst nur die VB.NET Seite der Medaille betrachten. Trotzdem möchte ich hier eben noch einmal die verwendeten Dinge auflisten, alles Weitere wird dann in einem zukünftigen Beitrag ergänzend erscheinen.

Wir benötigen also:

• Einen Mikrocontroller wie z. B. den Arduino Nano in meinem Fall
• Die Arduino IDE (am häufigsten verwendet)
• Ein RFID Kit (häufig bestehend aus Sensor, Pins und Chipkarten/Anhänger)
• Ausreichend Jumper-Kabel (je nach Setup – hier 7 male to female)
• 1 Mini-USB Kabel zur Verbindung des Arduinos zum PC (eigentlich immer beim Arduino dabei..)

Nachdem wir nun von den Hardware-Komponenten erstmal startklar sind, widmen wir uns nach der Verbindung endlich dem Visual Basic NET Code.

Den RFID Scanner mit unserem PC verbinden

Ebenso einfach wie der oben beschriebene Weg mit den handelsüblichen RFID Scanner-Geräten, verfahren wir auch mit unserem Eigenbau. Verbinde den Arduino mithilfe eines Mini-USB Kabel mit einem USB-Port Deiner Wahl. Es sollte dann ein normales „Pling-Plong“-Geräusch kommen, Welches wie üblich das Anschließen eines neuen Gerätes signalisiert.

Verbindungsprobleme

Natürlich kann auch hier das ein oder andere Problem auf Dich zukommen, so traf es auch mich – Thema Treiber.. Um den typischen CH340 Chip erkennbar und zum Laufen zu bringen, installierst Du den für Dein System passenden Treiber. Danach wirst Du vermutlich zu einem Neustart Deines PCs aufgefordert, Welchen Du auch – um weitere Fehlerquellen zu vermeiden – durchführen solltest.

💡 Achtung: Bei der Treiber-Seite handelt es sich um einen chinesischen Anbieter. Achte auf das für dich passende Paket und verwende ggf. die z. B. in Chrome vorhandene Übersetzungs-Funktion. Grundsätzlich ist das dicke blaue Download-Icon aber nicht zu übersehen. Der „341SER.zip“-Treiber sollte auch für die 340er Variante funktionieren. Gerne würde ich Dir den Treiber ebenfalls zum Download anbieten, aber ich möchte vermeiden, dass Du nachher mit einem veralteten Treiber arbeitest.

Öffne dann einfach die „SETUP.exe“ im „CH341SER“-Ordner und klicke auf „install“:

Starte anschließend Deinen PC wie gesagt am besten neu, damit Du keine eventuellen Installations-, bzw. Erkennungsprobleme hast. Danach sollte der CH340 Chip ganz normal als COM-Port im Gerätemanager auftauchen (natürlich nur wenn tatsächlich physisch verbunden – Captain Obvious..):

Code – RFID-Daten über VB.NET auslesen

Kommen wir nun zum vermutlich heißt ersehnten VB.NET Code zum Auslesen der jeweiligen RFID-Daten. Im Mittelpunkt aller Dinge steht hier die SerialPort-Klasse, Welche Du ggf. noch via NuGet-Paket installieren musst. Suche dazu am besten im NuGet-Paketmanager nach „System.IO.Ports“, oder verwende diesen Link, dort drin befindet sich die Klasse. Nachdem wir jetzt über die erforderlichen Mittel für die Kommunikation via COM-Ports besitzen, können wir starten.

Lege z. B. eine .NET 6 Windows Forms App an und gehe wie gewohnt mit F7 in den Code hinter der Form. Zuerst legen wir (je nach Belieben/gewünschten Einschränkungen) eine Eigenschaft namens „Connection“ an, Welche unsere SerialPort-Verbindung widerspiegeln wird.

Public Property Connection As SerialPort

Als nächstes fügen wir noch ein „Dictionary“ für eine Zuweisung von Uids (Strings – die Ids der gescannten Chips) zu Nutzern (User-Klasse) hinzu. Beachte hierbei, dass ich mit einer generischen Variante, also einem Interface arbeite, alternativ kannst Du das große „i“ auch weglassen. Die User-Klasse erstellen wir gleich und dient nur zur Veranschaulichung.

Public Property UidsToUser As IDictionary(Of String, User)

Vorbereiten der Verbindung

Erstelle als Nächstes einen Konstruktor für die Form, indem Du „Sub New“ innerhalb der „Form1“-Klasse tippst und mit „Enter“ bestätigst. Dann sollte Visual Studio Dir ein grobes Skelett für den Konstruktor generieren, diesen passen wir wie folgt an:

    Sub New()
        InitializeComponent()
        Connection = New SerialPort("COM3", 9600, Parity.None, 8, StopBits.One)
        AddHandler Connection.DataReceived, AddressOf Connection_DataReceived
    End Sub

Zuerst lassen wir die von Haus aus kommende „InitializeComponent“-Methode unangetastet, da unsere eventuellen Form-Steuerelemente sonst nicht funktionieren würden. Danach instanziieren wir eine neue Instanz der Klasse „SerialPort“ mit einigen Werten.

• COM3 – steht für den für die Kommunikation zu wählenden COM-Port. In meinem Fall steckt mein Arduino am COM-Port Nr. 3.
• 9600 – ist die sogenannte Baudrate und regelt die „Kommunikationsgeschwindigkeit“ zwischen Arduino und PC. Achte hier darauf, dass Du den gleichen Wert wie in Deinem Arduino Sketch unter „Serial.Begin(<der Wert>)“ wählst.

Dann stellen wir noch gewisse andere Dinge wie die Parität, die Daten-Bits und die Stop-Bits ein. (Ich erspare Dir jede einzelne Erklärung hier..).

Im letzten Konstruktor-Schritt bezüglich der SerialPort-Verbindung fügen wir auch noch einen Ereignishandler für das „DataReceived“-Ereignis hinzu.

Verbindung starten

Danach können wir einen weiteren Handler generieren, hierbei handelt es sich um den Ereignishandler für das „Form Load“-Ereignis. Darin werden wir dann die Verbindung zum Arduino (über den SerialPort) öffnen, ansonsten können wir natürlich nicht kommunizieren 😉.

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        Connection.Open()
    End Sub

Auf Daten reagieren/lauschen

Nun müssen wir den oben zugewiesenen (aber bisher nicht existenten) Ereignishandler für das „DataReceived“-Ereignis erstellen. Das geht erstmal ganz einfach wie folgt:

    Private Sub Connection_DataReceived(sender As Object, e As SerialDataReceivedEventArgs)
        Dim text = Connection.ReadLine().TrimStart().TrimEnd()
        If text.StartsWith("RFID:") Then
            Dim uid = text.Split(":")(1)
            Invoke(Sub() OnUidScanned(uid))
        End If
    End Sub

💡 Achtung: Ich habe seitens des Arduino-Codes sichergestellt, dass wir mit einem Zeilenumbruch arbeiten/kommunizieren. Daher kann ich hier mit dem „ReadLine“-Befehl arbeiten. Beachte allerdings bei Deinen geplanten Projekten, dass das „DataReceived“-Ereignis (wie der Name schon sagt) lediglich sagt: „Ey, hier sind Daten“ – das heißt aber nicht, dass ALLE Daten da sind, die Du Dir vorstellst. Da wir hier aber mit einer kleinen Datenmenge a la „RFID:DieUid“ arbeiten, werden wir hier aller Voraussicht nach kein Problem bekommen. Wenn Du allerdings ellenlange Texte hin und her schiebst, könnte es zu einem Problem werden – aber auch dazu in einem anderen Beitrag mehr..

Nun lesen wir mit „ReadLine“ die Daten ein und „säubern“ Diese anschließend durch Verkettung von „TrimStart“ und „TrimEnd“. Das verhindert unnötige und unerwartete Leerzeichen, kann aber natürlich auch durch saubere Programmierung am Arduino verhindert werden..

Nun vor-verarbeiten

Grundsätzlich haben wir den Text, Welcher vom Arduino kommt endlich vorliegen und können Ihn verarbeiten. Beachte, dass ich hier ein kleines „Protokoll“ einhalte, auch wenn es nur praktisch gesehen aus einem Teil besteht. Ich halte mich an meine Regel, dass ich beim erfolgreichen Einlesen eines RFID-Chips den String „RFID:“ gefolgt von der Uid-Zeichenfolge und einem Zeilenumbruch durch den SerialPort jage.

Ergo muss ich mich natürlich an der Gegenstelle (VB.NET) daran halten und die Daten dementsprechend auslesen und verarbeiten. Das mache ich dann im nächsten Schritt, indem ich prüfe, ob die eingelesenen Daten mit einem „RFID:“ beginnen. Ich splitte also den String anhand des Doppelpunktes und nehme mir den zweiten Teil des Strings als Uid.

Daten an die UI delegieren

Anders als gedacht sollte man hier normalerweise nun nicht mit einer Art „ich update mal jetzt direkt die UI a la Label1.Text = …“ arbeiten. Das liegt daran, dass das Ereignis vom SerialPort (und somit unser Handler) meines Wissens nach auf einem anderen Thread als die UI ausgeführt wird. Von dort aus also nun auf die grafische Oberfläche zuzugreifen sollte aller Wahrscheinlichkeit nach einen „Cross Thread bla blupp“-Fehler auslösen.

Um dies zu vermeiden, verwende ich die „Invoke“-Methode der Form in Kombination mit einem inline definierten Delegaten („Sub() <etc>..“). Dieser Delegat hat einen zugrunde liegenden Aufruf namens „OnUidScanned“ – mit dem passenden String-Parameter. Alternativ könntest Du hier auch mit einem „BeginInvoke“-Aufruf arbeiten, dies lässt den Aufrufer nicht auf den Abschluss des Codes warten.

Reine Erkennung von Uids fertig – und nun?

An dieser Stelle haben wir unser Grundgerüst, was das Auslesen und „parsen“ der Uids der Chips betrifft fertig. Nun wirst Du Dich hoffentlich fragen – ja cool, und was nun? Nur Geduld junger Padawan, es geht direkt weiter. Als Nächstes definieren wir (in .NET-Manier) eine typische Ereignis-Methode namens „On…“. Diese kann bei Bedarf in Sub-Klassen überschrieben werden und dient als Basis für unser eigenes Ereignis.

Erstelle nun am Ende der Datei (da lege ich die Ereignisse eigentlich immer ab) ein Ereignis wie das Folgende. Beachte dabei, dass man normalerweise eine eigene von EventArgs abgeleitete Klasse für die Ereignisinformationen verwenden sollte, darauf habe ich hier verzichtet. Unser Ereignis beinhaltet nur die Uid-Information, also einen simplen String.

Public Event UidScanned As EventHandler(Of String)

Die passende „On“-Methode würde also so aussehen:

    Protected Overridable Sub OnUidScanned(uid As String)
        RaiseEvent UidScanned(Me, uid)
    End Sub

Zu guter Letzt verknüpfen wir nun unser eigens erstelltes Ereignis via Handles-Klausel mit einer passenden Methode als Handler:

    Private Sub Me_UidScanned(sender As Object, uid As String) Handles Me.UidScanned
        Dim user As User = Nothing
        UidsToUser.TryGetValue(uid, user)
        If user Is Nothing Then
            MessageBox.Show("Login failed!")
            Return
        End If
        MessageBox.Show($"Hey {user.Name}!")
    End Sub

Hier initialisieren wir zuerst eine leere Variable namens „User“, Welche anschließend durch die „TryGetValue“-Funktion der generischen Dictionary Klasseninstanz befüllt werden sollte. Wenn kein zur Uid passender Nutzer ermittelt werden konnte, wird hier eine kleine „Login failed!“-Meldung ausgegeben. Ansonsten zeigen wir testweise den Namen des jeweils ermittelten Nutzers an.

💡 Achtung: Hier noch der Hinweis, dass es sich hierbei keinesfalls um einen „production ready“ Code handelt. Das Beispiel dient lediglich zur Veranschaulichung des Empfangs von seriellen Sensordaten via SerialPort. Jeder mit einigermaßen vorhandenen Disassembler-Kenntnissen würde in wenigen Sekunden an die jeweiligen Chip-Uids kommen. Normalerweise sollte das Programm nur als Schnittstelle dienen, also die Daten einlesen und an eine passende (Web-) Schnittstelle zur Verarbeitung weiterleiten. Wenn sicher über Https übertragen, könnte die Schnittstelle also anhand der Uid einen passenden Nutzer aus der Datenbank laden und einen Zugriff ermöglichen. Auch wenn ich diesen Satz hasse: „..aber das würde den Rahmen sprengen“ / „The princess is in another castle“ – wenn Du mich verstehst 😛..

Die User-Klasse

Bevor ich es vergesse, hier noch die verwendete, simple User-Klasse:

Public Class User

    Public Property Name As String

    Sub New(name As String)
        Me.Name = name
    End Sub

    Public Overrides Function ToString() As String
        Return Name
    End Function

End Class

Weitere Links

• Arduino RFID Scanner
• Virtuelle COM Ports emulieren mit com0com

Downloads

Wie immer findest Du hier am Schluss den vollständigen Download des (VB.NET) Codes. Ggf. ergänze ich der Vollständigkeit halber trotzdem noch den Arduino-Code, ansonsten wird Dieser später in dem getrennten Arduino-Teil kommen.

Der Beitrag 🔑 VB.NET RFID Scanner – Chips mit dem Arduino Mikrocontroller auslesen erschien zuerst auf Robert Skibbe.

Wie Du einen NodeJS Http Server erstellen kannst, erfährst Du im heutigen Beitrag.

Ich verzichte der Einfachheit halber und aufgrund der meiner Meinung nach sinnvollen Trennung auf weitere Frameworks.

Für den Bau eines NodeJS Http Servers werden wir also nur die bereits vorhandenen Bordmittel von Node verwenden.

Grundprinzipien eines (NodeJS) Http Servers

Bevor wir in den Code und Weiteres starten würde ich sagen, dass wir uns erstmal den Basics des Webs widmen.

Vielleicht ist Dir das Grundprinzip von Webservern bereits bekannt, dann bist Du natürlich herzlich eingeladen diesen Abschnitt zu überspringen.

Für alle Anderen und die somit eventuellen Neulinge unter den Besuchern, schauen wir uns aber den Ablauf eines Webservers nochmal an.

Das Grundprinzip lässt sich auf viele Bereich übertragen, also nicht nur auf das simple „Serven“ (Bereitstellen) einer Datei auf Anfrage.

Wenn Du Dir das Bild anschaust, siehst Du eine (oder mehrere) typische Situatione(n).

Ablauf einer Anfrage

Links befinden sich die verwendeten Geräte, wie z. B. Laptops & Desktop PCs, Smartphones und Tablets.

Diese rufen z. B. in Ihrem Browser eine bestimmte Website/Adresse auf, Sie senden also eine Anfrage an den Server.

Danach schaut der Server nach seiner entsprechenden Logik, um die jeweilige Anfrage zu beantworten.

Dabei sendet „er“ verschiedene Daten in seiner Antwort wie z. B. den Kopf, oder den Body.

Der Inhalt der Antwort hängt natürlich unter Anderem stark von der Gestaltung des jeweiligen „Endpunktes“ und der allgemeinen Server-Infrastruktur ab.

Handelt es sich dabei um eine Datei sieht die Antwort anders aus, als wenn man nur über eine Schnittstelle diverse Kunden abrufen möchte.

Das simpelste Beispiel

Ich denke es ist an der Zeit, für ein wirklich (wirklich) simples Beispiel eines Node Http Servers.

Schauen wir uns erstmal an, was wir aus der Standard-Bibliothek von Node (Module) verwenden können.

Wer sucht wird relativ schnell fündig und stößt auf das gute alte „Http“-Modul – wer hätte es gedacht.

Das Http-Modul

Um das „Http“-Modul zu „importieren“ und verwenden zu können, legen wir wie üblich eine Konstante mit jeweiligem Namen an.

Des Weiteren brauchen wir noch die für Node Programme typische „require„-Funktion, welche das Modul letztendlich importiert und als Rückgabewert zurückgibt.

Solche Module können wir natürlich auch selbst schreiben, allerdings ist das ein Thema für einen späteren Beitrag!

Legen wir also nun die Konstante an und verwenden Diese anschließend:

const http = require('http')

Natürlich verwende ich hier eine Konstante, statt einer normalen Variable (var) oder „scoped“ Variable (let), da sich der dort drin stehende Wert nicht verändern wird/soll!

Der Request-Handler

Danach erstellen wir einen Request-Handler, Welcher jeweils einen Request (eine Anfrage an den Server) verarbeiten wird.

Dieser Handler ist letztendlich nichts anderes als eine kleine Funktion, Welche 2 Parameter mitgeliefert bekommt – der Request und die Response.

Damit bekommen wir die Möglichkeit Daten vom Request zu lesen, bzw. Daten in die Response zu schreiben.

const requestHandler = function (req, res) {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.write("NodeJS Http Server")
  res.end()
}

Server erstellen und ausführen

Im letzten Schritt des einfachen Beispiels müssen wir nur noch einen „Server“ mit Hilfe der „createServer„-Funktion des „Http“-Moduls erstellen.

Danach können wir dem Server einfach nur noch sagen: „Hör‘ zu!“ und schon läuft das Ding!

Wir legen zuerst zwei Konstanten fest, Welche eine kleine Art Konfiguration widerspiegeln.

Dabei sagen wir dem Programm, auf welchen Port bzw. auf welchen Host–Namen es lauschen soll:

const port = 8000
const host = 'localhost'

Nun erstellen wir den Server indem wir einfach wie angekündigt die „createServer“-Funktion des „Http“-Moduls aufrufen.

Dann rufen wir nur noch die „listen„-Funktion auf und schön „hört“ unser Server auf ankommende Anfragen.

Um eine Art Status auszugeben, geben wir der „listen“-Funktion noch ein anonymes Callback mit, Welches bei Start des Servers aufgerufen wird.

Hier könnten wir natürlich auch ähnlich wie mit dem „Request-Handler“ verfahren und eine benannte Funktion, statt einer Anonymen verwenden..

const server = http.createServer(requestHandler)
server.listen(port, host, function () {
  console.log(`Listening for requests on https://${host}:${port}`)
})

Nun kannst Du die Anwendung z. B. in Visual Studio Code über die Konsole ausführen (oder Du verwendest die normale Windows/Mac Konsole/Terminal).

Öffne in Visual Studio Code ein Terminal mit dem Hotkey „Strg+Shift+ö“, oder gehe oben über’s Menü.

Dann musst Du den obigen Code nur noch in eine JavaScript-Datei, z. B. „index.js“ stecken und mit „node index.js“ (geht auch ohne „.js“) ausführen.

Wenn Du dann die konfigurierte Adresse „https://localhost:8000“ besuchst, dürfest Du folgende Ausgabe sehen:

Fazit

Nun haben wir das simple Beispiel abgeschlossen, jedoch kommen in Zukunft noch weitere Problematiken auf uns zu.

Diese kommen unter Anderem dann, wenn man mit einzelnen Routen/Endpunkten und auch z. B. einer Authentifizierung arbeiten möchte.

Mit dem aktuellen Stand könnten wir also keine wirklich sinnvolle, bzw. eher vielfältige Applikation bauen – zumindest nicht so easy..

Das aktuelle Skript arbeitet praktisch als „Catch-All-Route„, es arbeitet also jeden GET-Request bisher gleich ab.

Egal ob wir „<adresse>/kunden“, oder „<adresse>/dashboard“ aufrufen, es kommt immer das Gleiche als Antwort.

Das liegt natürlich daran, dass wir in dem obigen Skript in keiner Weise zwischen verschiedenen Endpunkten zu unterscheiden.

Simpler NodeJS Http Server Code

const http = require('http')
const requestHandler = function (req, res) {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.write('NodeJS Http Server')
  res.end()
}
const port = 8000
const host = 'localhost'
const server = http.createServer(requestHandler)
server.listen(port, host, function () {
  console.log(`Listening for requests on https://${host}:${port}`)
})

Erweitertes NodeJS Http Server Beispiel im Selbstversuch

Nachdem wir nun oben schon einige Fallstricke feststellen konnten, schauen wir uns im nächsten Abschnitt mal einen kleinen Selbstversuch an.

Wir schreiben uns eine eigene kleine Server–Klasse, mit dessen Hilfe wir verschiedene Request-Arten und Routen registrieren können.

Wie Dir vielleicht bekannt ist, gibt es nicht nur die oben verwendete Http „GET“-Methode, sondern z. B. noch „POST“, „PUT“, „DELETE“ und mehr.

Ein Beispiel wäre ein „GET„-Request an den „/kunden“-Endpunkt, Welcher z. B. eine Suche signalisiert und eventuell noch Query-Parameter zur Filterung a la „?name=Max“ entgegennehmen kann.

Wenn man nun allerdings ein „POST“-Request an den „/kunden“-Endpunkt schickt, könnte man durch die Angabe passender Daten z. B. einen Kunden erstellen.

Los geht’s – die jetzt benötigten Module

Bei dem erweiterten Beispiel-Server benötigen wir im Vergleich zu vorhin einige zusätzliche Module.

Wir möchten natürlich so viel Arbeit wie nur möglich an die Core-Module von NodeJS abgeben.

Darunter fällt zum Beispiel das Verarbeiten, also das Parsen des Url-Strings, bestehend aus Endpunkt und Query–Parameter.

const http = require('http'),
  url = require('url'),
  querystring = require('querystring')

Die Server-Klasse

Im Optimalfall stellt man sich die Konfiguration des Servers meiner Meinung nach so aktuell am besten vor:

- Server instanziieren
- Routen definieren
- Server lauschen lassen und Handler die Arbeit machen lassen

Daher werde ich den Server nach Möglichkeit genau so versuchen in kurzer Zeit zu bauen – damit es nicht den Rahmen sprengt.

Selbstverständlich ist Deine eigene Kreativität gerne gesehen und keine Grenzen in Sicht, „do your thing“ sag ich mal!

Definieren wir also im ersten Schritt eine simple JavaScript-Klasse mit unserem gewünschten „Skelett“-Aufbau:

class Server {
  constructor () {
    // doin' some constructional things
  }
  get () {
    // registering a GET route..
  }
  post () {
    // registering a POST route..
  }
  start () {
    // starting the server making it listening to requests
  }
}

Der Konstruktor

Im Konstruktor des Servers übergeben wir die Haupt-Konfiguration, wie den Hostname und den Port.

Ggf. könnte man es auch hier mit einem „options“-Objekt gestalten, allerdings ist das für’s Erste nicht notwendig.

Meistens bietet es sich aber tatsächlich an, da die Konfigurationsmöglichkeiten häufig von Zeit zu Zeit wachsen und man natürlich sowas wie 7 Konstruktor-Parameter vermeiden sollte.

Zuerst kümmern wir uns um Auflistung, Welche später die einzelnen registrierten Routen enthalten wird.

Ein Workaround

Ich habe hier bewusst eine anonyme Funktion mit „Arrow-Function“-Deklaration gewählt, um den „This-Scope“ des Konstruktors zu behalten.

So komme ich kinderleicht an das „_routes“ Feld/Eigenschaft – bau‘ dies gern nach Belieben um..

Würde ich hingegen eine weitere Methode in der Klasse hinzufügen, würde ich innerhalb der Methode den Scope des „http“-Moduls haben (und somit nicht an die Routes kommen..).

Nachdem die „createServer„-Funktion ihr Ding macht, nehmen wir noch Standardwerte für die Konfiguration (host, port) auf und setzen Sie ansonsten wie übergeben.

Vorgehensweise

Das Callback der „createServer“-Funktion loggt im ersten Schritt die besuchte Url inkl. Route, damit wir verfolgen können was passiert.

Danach verarbeiten wir mit einer der oben angesprochenen Utility-Module die Request–Url.

Somit können wir dann kinderleicht an den Pfad kommen (z. B. „/customers“) und müssen hier nicht nach dem Query-String schauen.

Dieser kommt zu einem späteren Zeitpunkt noch bei z. B. der Filterung zum Einsatz.

Ansonsten machen wir das, was viele Server machen, wenn Sie eine Url nicht finden können.

Sie melden einen 404-Fehler und wir verlassen dann den Durchlauf mit einem „Early Return„!

Falls die Route jedoch gefunden wird, sich also eine zum Pfad und zur Request-Methode passende Route in unserer Auflistung befindet, ziehen wir Diese.

Zum Schluss rufen wir dann den dafür registrierten Handler der Route auf und übergeben das Request- & Response-Objekt als Parameter.

So können die Handler entscheiden, was Sie mit den dem jeweiligen Objekt machen und der zentralen Stelle oben obliegt einzig und allein die Delegation – schön!

// ..
constructor(host, port) {
    const routes = []
    this._routes = routes
    this._server = http.createServer((req, res) => {
      console.log(`[${req.method}] ${req.url}`)
      const requestUrl = url.parse(req.url)
      const route = routes.find(x => x.path === requestUrl.pathname && x.method === req.method)
      if (!route) {
        res.writeHead(404, { 'Content-Type': 'application/json' })
        res.write('Route not found')
        res.end()
        return
      }
      route.handler(req, res)
    })
    this._host = host || 'localhost'
    this._port = port || 8000
  }
// ..

Ein paar Hilfsmethoden

Normalerweise bin ich kein Fan von komplexen Abfang-Szenarien in Beispiel-Codes, allerdings dürfte das hier relativ überschaubar sein, daher..

Wir definieren 3 Methoden, Welche die Überprüfung der notwendigen Argumente/Parameter bei einer Routen-Registrierung übernehmen.

Man hat ja schließlich keine Lust (und es ist schlechter Coding-Stil), alles 5 mal zu schreiben – duplicated Code, bah!

_checkPath-Methode

Nun gibt es also die „_checkPath„-Methode, Welche einfach nur prüft, ob das übergebene Argument „ok“ ist, also nicht „leer“ und vom Typ String.

Zusätzlich prüft die Methode noch, ob schonmal eine gleiche Route registriert wurde (unabhängig vom Handler..).

_checkHandler-Methode

Die „_checkHandler“-Methode prüft auch ob überhaupt etwas übergeben wurde und zusätzlich, ob es sich dabei auch um eine gewünschte Funktion handelt.

_registerRoute-Methode

Als nächstes kommt das Routen-Helferlein zum Einsatz, Welches uns – wer hätte es gedacht.. – bei der Registrierung einer Route unterstützt.

Auch hier gilt wieder die Vermeidung von duplicated Code, etc..

Es wird ein neues Route-Objekt mit Hilfe der angegebenen Parameter erstellt und der Auflistung hinzugefügt.

  _checkPath(path, method) {
    if (!path || typeof path !== 'string') {
      throw new Error('No or invalid path specified')
    }
    const existentRoute = this._routes.find(x => x.path === path && x.method === method)
    if (existentRoute) {
      throw new Error(`Route already registered [${method}] ${path}`)
    }
  }
  _checkHandler(handler) {
    if (!handler || typeof handler !== 'function') {
      throw new Error('No or invalid handler specified')
    }
  }
  _registerRoute(path, method, handler) {
    const route = {
      path,
      method,
      handler,
    }
    this._routes.push(route)
  }

Routen registrieren

Im Folgenden Code werden zwei Möglichkeiten einer Routen-Registrierung definiert:

• GET-Routen
• POST-Routen

  get(path, handler) {
    this._checkPath(path, 'GET')
    this._checkHandler(handler)
    this._registerRoute(path, 'GET', handler)
  }
  post(path, handler) {
    this._checkPath(path, 'POST')
    this._checkHandler(handler)
    this._registerRoute(path, 'POST', handler)
  }

Dabei wird bis auf die Request-Methode nicht wirklich etwas anderes gemacht, könnte man ggf. auch anders gestalten, aber cmon..

Den Server starten

Um den Server zu starten, müssen wir auf das klasseninterne Feld namens „_server“ zugreifen und dessen „listen„-Methode aufrufen.

Ggf. könnte man hier noch mit irgendwelchen Zustands-Flags für einen noch zu implementierenden Stop realisieren.

Kommen wir nun zu einer Beispiel-Konfiguration und einer Art Kunden-API.

Dazu erstelle ich eine (nicht persistente, nur im Server-Memory existierende) Kunden-Auflistung.

Als nächstes instanziiere ich wie oben geplant eine neue Server–Instanz.

Im Anschluss werden die Routen registriert und der Server durch die „start“-Methode gestartet.

Die Such-Route für die Kunden

Die erste zu registrierende Route wäre die Such-Route für die Kunden (bzw. die Schnittstelle..).

Pro Anfrage entsteht im ersten Schritt ein neues Array mit dem Inhalt der ursprünglichen „customers“-Auflistung.

Dann führen wir ein paar Prüfungen durch, ob es wirklich eine Suche ist, also ob wirklich Suchparameter übergeben wurden.

Falls ja filtern wie die „responseCustomers“ und weisen der gleichen Variable das neue Ergebnis zu.

So könnte man Schritt für Schritt natürlich weitere Such-Möglichkeiten hinzufügen.

Zum Schluss geben wir die Daten JSON-konform an den aufrufenden Client aus – fertig!

Gerne darfst Du Dich daran versuchen, die fehlende POST-Route zu bauen *zwinker*.

const customers = [
  {
    company: 'Nice Company ltd.'
  },
  {
    company: 'Another Company'
  },
]
const server = new Server()
server.get('/customers', (req, res) => {
  let responseCustomers = [...customers]
  const shouldFilter = req.url.includes('?') && req.url.includes('=')
  if (shouldFilter) {
    const requestUrl = url.parse(req.url)
    const query = querystring.parse(requestUrl.query)
    const hasNameFilter = 'name' in query
    if (hasNameFilter) {
      const nameToFilter = (query['name'] || '').toLowerCase()
      if (nameToFilter) {
        responseCustomers = responseCustomers.filter(x => x.company.toLowerCase().includes(nameToFilter))
      }
    }
  }
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.write(JSON.stringify(responseCustomers))
  res.end()
})
server.post('/customers', (req, res) => {
  // to be done..
})
server.start()

Erweiterter NodeJS Http Server Code

const http = require('http'),
  url = require('url'),
  querystring = require('querystring')

class Server {
  constructor(host, port) {
    this._routes = []
    this._server = http.createServer((req, res) => {
      console.log(`[${req.method}] ${req.url}`)
      const requestUrl = url.parse(req.url)
      const route = this._routes.find(x => x.path === requestUrl.pathname && x.method === req.method)
      if (!route) {
        res.writeHead(404, { 'Content-Type': 'application/json' })
        res.write('Route not found')
        res.end()
        return
      }
      route.handler(req, res)
    })
    this._host = host || 'localhost'
    this._port = port || 8000
  }
  _checkPath(path, method) {
    if (!path || typeof path !== 'string') {
      throw new Error('No or invalid path specified')
    }
    const existentRoute = this._routes.find(x => x.path === path && x.method === method)
    if (existentRoute) {
      throw new Error(`Route already registered [${method}] ${path}`)
    }
  }
  _checkHandler(handler) {
    if (!handler || typeof handler !== 'function') {
      throw new Error('No or invalid handler specified')
    }
  }
  _registerRoute(path, method, handler) {
    const route = {
      path,
      method,
      handler,
    }
    this._routes.push(route)
  }
  get(path, handler) {
    this._checkPath(path, 'GET')
    this._checkHandler(handler)
    this._registerRoute(path, 'GET', handler)
  }
  post(path, handler) {
    this._checkPath(path, 'POST')
    this._checkHandler(handler)
    this._registerRoute(path, 'POST', handler)
  }
  start() {
    this._server.listen(this._port, this._host, () => {
      console.log(`Listening for requests on https://${this._host}:${this._port}`)
    })
  }
}

const customers = [
  {
    company: 'Nice Company ltd.'
  },
  {
    company: 'Another Company'
  },
]
const server = new Server()
server.get('/customers', (req, res) => {
  let responseCustomers = [...customers]
  const shouldFilter = req.url.includes('?') && req.url.includes('=')
  if (shouldFilter) {
    const requestUrl = url.parse(req.url)
    const query = querystring.parse(requestUrl.query)
    const hasNameFilter = 'name' in query
    if (hasNameFilter) {
      const nameToFilter = (query['name'] || '').toLowerCase()
      if (nameToFilter) {
        responseCustomers = responseCustomers.filter(x => x.company.toLowerCase().includes(nameToFilter))
      }
    }
  }
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.write(JSON.stringify(responseCustomers))
  res.end()
})
server.post('/customers', (req, res) => {

})
server.start()

Du willst mehr!?

Wenn Du mehr willst, sprich Deine Anwendung wirklich komplex gestalten möchtest, kommst Du nicht um das non plus ultra Framework herum.

Dabei handelt es sich um das in Node-Kreisen sehr bekannte ExpressJS Framework.

Neben gewisse Basis-Funktionen wie die einfache Definition von Routen unterstützt ExpressJS auch noch ein Konzept namens „Middlewares„.

Hierüber werde ich allerdings noch in einem getrennten Beitrag schreiben, da es sonst zu viel wird!

Downloads

Weiterführende Links

• NodeJS Verzeichnisse mit readdirSync auslesen
• NodeJS QRCode Scanner erstellen

Der Beitrag Wie man einen NodeJS Http Server erstellt erschien zuerst auf Robert Skibbe.

VB NET Web API – Web API Konsum von Grund auf erklärt

Heute erwartet Dich ein ganz besonderer und von vielen Abonnenten gewünschter Beitrag – die Implementierung einer VB NET Web API.

Es handelt sich genauer genommen um die Erstellung eines Clients, Welcher gewünschte Daten aus einer Web-Schnittstelle abrufen kann.

Die Web-API arbeitet dabei nach dem üblichen Standard, Sie gibt JSON-Daten zurück, Welche wir dann noch clientseitig verarbeiten müssen.

Letztendlich ist der Client natürlich nichts anderes als eine VB NET Klasse, bzw. eher gesagt eine Instanz davon.

Auf YouTube ansehen – VB NET Web API

Falls Du die visuelle Darstellung, bzw. Erklärung des Beitrages bevorzugst, kannst Du natürlich auch das dementsprechende Video anschauen.

Ursprung und Idee zum Beitrag – VB NET Web API

Den ursprünglichen Anreiz zum Video habe ich – wie fast immer – durch den eigenen Bedarf dazu gehabt.

Ich baue mir aktuell ein kleines Tool, Welches mir bei meiner Arbeit mit dem Staking von Kryptowährungen helfen soll.

Hier zeige ich Dir mal einen kleinen Ausschnitt, beachte jedoch, dass das Tool hier nicht weiter aufgegriffen wird:

Bisher musst ich bei Bedarf immer die einzelnen Werte und Positionen selbst errechnen, nun habe ich dafür letztendlich ein Mini-Tool gebaut.

Bewusst in der unteren, rechten Ecke positioniert, sollte es als eine Art Widget im Hintergrund funktionieren.

Bei Bedarf sollte es mir dann die gesammelten/verarbeiteten Informationen aufbereitet darstellen.

Gedanken zum Start

Bei den initialen Gedanken bezüglich des Projektstarts, kann man natürlich einiges einbeziehen.

Ich spreche hier unter anderem von Konzepten wie z. B. die Dependency-Injection, bzw. auch kurz DI genannt.

Als nächstes sollte man sich vermutlich über die restliche Infrastruktur der App Gedanken machen.

Hast Du eventuell das MVVM-Entwurfsmuster für Deine Anwendung eingeplant, oder möchtest Du „quick and dirty“ durchstarten?

In meinem Beitrag über das MVVM-Entwurfsmuster kannst Du mehr darüber erfahren und detailliert nachlesen.

Möchtest Du eventuell grafisch ansprechender arbeiten und ein GUI-Framework wie Mahapps-Metro verwenden?

Dann schaue Dir ggf. folgende Beiträge über Mahapps Metro an: Mahapps Metro Projekt aufsetzen.

Wegfallendes & Veränderungen

Viele Entwickler arbeiten bei einem Projekt zuerst einmal an einem „Minimum Viable Product“, kurz MVP.

Die Welt der Programmierung befindet sich in einem permanenten Wandel und nicht anders geht es Deinem Projekt.

Man möchte Kunden, Investoren, oder auch einfach Vorgesetzten ein schnelles und praxisnahes Beispiel des Projektes vorzeigen können.

Oftmals resultiert dies aus bestehendem Projektdruck, anderen wartenden Projekten, ungeduldigen Kunden, usw.

Da es sich hierbei allerdings um ein privates Projekt handelt, habe ich mich für eine hybride, bzw. einfache Lösung entschieden.

Ich habe daher als Basis ein kleines Interface erstellt, wovon sich dann Implementierungen ergeben können.

Man weiß nie, welche Webseiten, bzw. Schnittstellen irgendwann ihren Dienst quittieren.

Ebenso weiß man häufig nicht, inwiefern sich Preismodelle verändern, da sich auch kostenlose Modelle der Wirtschaftlichkeit anpassen müssen.

Besonders ehemals kostenlose „Subsciption-Plans“ werden irgendwann kostenpflichtig und bestehende Pläne werden teurer.

Wenn solche Veränderungen eintreten muss bestehende Software im Optimalfall natürlich gut gebaut sein.

Sie muss über eine gute Infrastruktur und Planung verfolgen, um auf eventuelle Änderungen reagieren zu können.

Dabei sollte Sie effizient und einfach umgestellt werden können und erfolgte Änderungen sollten einfach getestet werden können.

Vorbereitungen für die VB NET Web API

Um dieses Tutorial erfolgreich abschließen zu können, musst Du vorher noch einige Vorbereitungen treffen.

Du brauchst im ersten Schritt einen Account für den verwenden Web-Service namens „exchangeratesapi„.

Besuche dafür einfach die Website namens exchangeratesapi.io und erstelle Dir einen kostenlosen Account im „Free Subscription Plan“.

Der kostenlose Plan von exchangeratesapi.io bietet Dir die Möglichkeit 250 Anfragen im Monat kostenlos zu nutzen.

Wenn Du die Registrierung abgeschlossen und Deinen API-Key erhalten hast, können wir fortfahren.

Los geht’s

Hier starten wir mit der Basis des Codes und setzen die ersten Überlegungen um.

Wie oben schon erwähnt wird es ein Interface als kleine Basis geben:

Public Interface IExchangeRateService

    Function GetExchangeRateAsync(baseCurrency As String, targetCurrency As String) As Task(Of Double)

End Interface

Dieses stellt in der absoluten „easy-to-go“-Version nur eine einzige Funktion bereit – „GetExchangeRateAsync“.

Die Funktion soll uns den Wechselkurs der jeweiligen Basis-Währung in die angegebene Ziel–Währung liefern.

Wie Du in der Deklaration erkennen kannst, übergeben wir die beiden Währungen als Parameter vom Typ String.

Des Weiteren gibt die Funktion keinen simplen Double-Wert, sondern eine Task mit einem generischen Parameter vom Typ Double zurück.

Ich bevorzuge die asynchrone Arbeitsweise, daher wird die Funktion beispielhaft wie folgt aufgerufen:

Private Async Task LoadExampleDataAsync()
    Dim exchangeRate As Double = Await theService.GetExchangeRateAsync("EUR", "USD")
End Sub

Auch bei der Bezeichnung der Variante sollte man natürlich auf die „Asynchronität“ eingehen.

In der VB NET Welt hat es sich eingebürgert, asynchrone Funktionalitäten mit einem „Async„-Postfix zu kennzeichnen.

Möchte man stattdessen die synchrone Variante verwenden, kann man dafür natürlich auch einfach folgenden Code verwenden:

Private LoadExampleDataSync()
    Dim exchangeRate As Double = theService.GetExchangeRateAsync("EUR", "USD").Wait()
End Sub

Die oben genannte Schnittstelle wird dann von jeweiligen ExchangeRateServices implementiert – vorerst jedoch nur von Einem.

Konkrete Implementierung des Services

Mit dem Status quo gibt es nur eine „Service-Möglichkeit„, also eine konkrete Implementierung des Interfaces.

Dabei handelt es sich um die Web-Dienstleistung der oben genannten Seite, Welche uns als Daten-Lieferant dient.

Selbstverständlich könnten wir auch genauso gut mehrere Anbieter heraussuchen und Diese dann in eigenen Services implementieren.

Im folgenden Bild versuche ich diese Gegebenheit ein wenig besser darzustellen:

Klasse erstellen – Für ExchangeRatesApi.io

Erstelle also im nächsten Schritt eine eigene Klasse, in der wir dann beginnen, den Web-Dienst und unser Interface zu implementieren.

Die Bezeichnung bleibt hier natürlich Dir überlassen, man könnte hier den Hersteller des Web-Dienstes in irgendeiner Form einbringen.

Damit würde man ggf. klarer darstellen, dass es sich um die konkrete Implementierung für diese eine Website handelt.

Der Einfachheit halber und mangels anderer Implementierungen belasse ich es bei einem simplen Namen.

Implementiere anschließend das oben gezeigte Interface und Du solltest den gleich folgenden Stand haben.

Tippe dazu einfach „Implements“ in die nächstfolgende Zeile nach dem Klassennamen und gebe den Namen des Interfaces ein.

Danach kannst Du das gewünschte Interface ggf. schon durch Autokorrektur bestätigen.

Public Class ExchangeRateService
    Implements IExchangeRateService

    Public Function GetExchangeRateAsync(baseCurrency As String, targetCurrency As String) As Task(Of Double)
       
    End Function

End Class

Mit dem S aus „SOLID“ im Kopf

Mit dem „Single Responsibility“-Prinzip, Welches sich bei dem Akronym „SOLID“ hinter dem Buchstaben „S“ verbirgt im Kopf, arbeiten wir weiter an der Klasse.

Die Bedeutung des Prinzips ist letztendlich grob gesagt, dass eine Klasse jeweils nur einen Zweck haben sollte.

Inwiefern viele Entwickler diesen Interpretations-Raum ausschöpfen, oder regulieren, mag erstmal dahingestellt sein.

In unserem Fall hat die Klasse ja z. B. einen API-Key, Welchen Sie verwenden muss, um bei der Web-Schnittstelle authentifiziert zu werden.

Diesen API-Key zu laden, ist allerdings eigentlich nicht die Aufgabe der Klasse selbst, sondern eher einer „Configuration“-like Klasse.

Die „Configuration„-Klasse könnte natürlich auch wieder ein Interface mit „Get“- und „Set“-Methoden implementieren.

Man könnte die Konfiguration im ersten Schritt durch die NET Settings realisieren, danach vielleicht auf Datenbank-, oder gar auf Web-Ebene.

So würde alles schön sauber, separat und wart-, bzw. testbar sein – schön!

Basis-Daten festlegen

Statt der eigenen Konfigurations-Klasse verwenden wir der Einfachheit halber einfach konstante Strings.

Diese definieren dann die benötigten Daten, wie z. B. den API-Schlüssel und die Basis-URL an Welche die Anfragen gesendet werden müssen.

Die Daten selbst verwenden wir dann später, um korrekt formatierte/aufgebaute Anfragen zu erstellen.

Public Const API_KEY As String = "<myApiKey>"
Public Const BASE_URL As String = "https://api.exchangeratesapi.io/v1"

Ein Singleton, Welcher keiner ist – lol

In Vielen verschiedenen Sprachen sollte man Singletons für Zugriffe auf das Web, also durch GET-, POST-, etc. Methoden erstellen.

Es macht keinen Sinn, für jede einzelne Anfrage einen weiteren „HttpClient“ zu erzeugen, sondern eher den Selben erneut zu benutzen.

Soweit ich mich erinnern kann, steht das sogar in der Dokumentation zum Client drin.

Als ich damals mit Java für die Android-Entwicklung gearbeitet habe, war es dort übrigens auch so.

Mittlerweile hat Google glaube ich selbst die Steuerung übernommen, damit man dies praktisch nicht mehr selbst realisieren muss.

Schnell und einfach habe ich hier einfach folgenden Code verwendet:

Imports System.Net.Http

Public Class Http
  
  Public Shared <ReadOnly> Client As HttpClient = New HttpClient()

End Class

Dieser Code sorgt zwar nicht dafür, dass der Client nicht einfach neu gesetzt werden könnte, macht aber denke ich den Part der Wiederverwendung klar.

Setze ggf. einfach einen Readonly-Modifizierer vor den Namen des Clients.

Den Request zusammenbauen – VB NET Web API

Wir können natürlich nicht einfach irgendwelche Anfragen an irgendwelche URLs schicken, sondern müssen uns irgendwo an den korrekten Aufbau halten.

Die oben definierte Basis-URL dient schonmal wie der Name sagt als Basis für das Ganze.

Im nächsten Schritt müssen wir in der Dokumentation herausfinden, welchen sogenannten Endpunkt wir verwenden müssen.

In unserem Fall ist der korrekte Endpunkt der „/latest„-Endpunkt, Welcher natürlich noch zusätzliche Daten übermittelt bekommen möchte.

Unsere Funktion muss also nun einen GET-Request an den genannten Endpunkt senden.

Aus der Dokumentation geht hervor, dass jeder (gesicherte) Endpunkt unseren API-Key in Form eines Query–Parameters übergeben bekommen möchte.

Des Weiteren braucht der Endpunkt die Information, welche Basis-Währung verwendet werden soll.

Standardmäßig kann man im Free-Plan leider nur Euro verwenden, ich werde die Implementierung des Services natürlich trotzdem korrekt gestalten.

Behalte allerdings deshalb im Kopf, dass Du nur „EUR“ als Basis-Währung übermitteln kannst und Du sonst vermutlich einen Fehler bekommen wirst.

Alternativ könntest Du den Parameter auch eventuell weglassen und die Web-Schnittstelle würde so automatisch „EUR“ ziehen.

Gleich findest Du einen möglichen Aufruf, bzw. eine mögliche Verwendung der bekannten Aspekte.

Zuerst wandle ich die übergebenen Währungen (wie Sie üblich benötigt werden) in Großbuchstaben um (eur -> EUR).

Query-Parameter

Danach mache ich mir den Rückgabewert der ParseQueryString-Funktion der HttpUtility-Klasse zu Nutze.

Daraus bekommen wir eine Art NameValueCollection, ich sage deshalb „Art“, weil es wohl eine davon erbende Variante sein muss.

In Visual Studio selbst, sagt die Dokumentation leider im Tooltip dazu nicht mehr.

Vielleicht übersehe ich auch etwas, aber probiere mal die manuelle Erstellung einer „NameValueCollection“.

Füge anschließend 2-3 Einträge hinzu und gebe Diese dann als String aus und Du wirst einen Unterschied feststellen.

Dim myNVC = new NameValueCollection()
myNVC.Add("entry1", "value1")
myNVC.Add("entry2", "value2")
myNVC.Add("entry3", "value3")
' "normal"
Dim str = myNVC.ToString()
' or with Interpolation
' Dim str = $"{myNVC}"

Im obigen Beispiel bekommst Du folgendes Ergebnis (wenn Du es ausgibst..):

Man bekommt also praktisch nur den vollständigen Pfad der Klasse inkl. Namespace zurück.

Wenn Du Dir allerdings den „ToString“-Wert des folgenden Beispiels anschaust, wird die Situation klarer:

Dim API_KEY = "BLA"
Dim baseCurrency = "EUR"
Dim targetCurrency = "USD"

Dim query = HttpUtility.ParseQueryString(String.Empty)
query.Add("access_key", API_KEY)
query.Add("base", baseCurrency)
query.Add("symbols", targetCurrency)

Dim str = query.ToString()
Console.WriteLine(str)
Console.ReadKey()

Hier bekommen wir nun die einzelnen Schlüssel- und Wert-Paare wie wir Sie für die URL benötigen zurück.

Die von der „NameValueCollection“ erbende Klasse, Welche wir vermutlich von „HttpUtility.ParseQueryString“ zurückbekommen, wird also die „ToString„-Funktion überschreiben.

Somit sieht also unser erster API aufrufender Code so aus:

Public Function GetExchangeRateAsync(baseCurrency As String, targetCurrency As String) As Task(Of Double)
    baseCurrency = baseCurrency.ToUpper()
    targetCurrency = targetCurrency.ToUpper()

    Dim query = HttpUtility.ParseQueryString(String.Empty)
    query.Add("access_key", API_KEY)
    query.Add("base", baseCurrency)
    query.Add("symbols", targetCurrency)

    Dim apiUrl = $"{BASE_URL}/latest?{query}"
    Dim response = Await Http.Client.GetAsync(apiUrl)
    Dim responseContent = Await response.Content.ReadAsStringAsync()

    ' parsing..

    Return 0
End Function

Setze Dir gerne mal einen Haltepunkt auf den „responseContent“ und schaue Dir das Ergebnis an:

{"success":true,"timestamp":1632925144,"base":"EUR","date":"2021-09-29","rates":{"JPY":129.884571}}

API-Antwort verarbeiten – VB NET Web API

Einige werden das obige Format, Welches als Antwort von der API kommt vermutlich bereits kennen und verstehen.

Für andere noch nicht so in der Entwicklung tief verankerte Personen, ist es ggf. ein kryptisches Gebilde.

Bei dem kryptischen Text handelt es sich aber um nichts Geringeres, als die „JavaScript Object Notation“ – kurz JSON.

Sie sieht im Vergleich zum ebenfalls sehr bekannten, aber zugegebenermaßen bereits in die Jahre gekommenen XML-Standard kryptischer aus.

Allerdings ist JSON wesentlich kompakter und für das geschulte Auge auch nicht wesentlich schwieriger zu lesen.

JSON in Objekt umwandeln

Um nun mit unserer Arbeit an der API fortfahren zu können, müssen wir den obigen JSON-String in ein NET-Objekt umwandeln.

Nur so ermöglichen wir uns eine einfache und saubere Arbeit damit, denn wer möchte hier schon manuelle Arbeit mit Funktionen wie z. B. Substring, etc. leisten.

Für die Umwandlung selbst benötigen wir im ersten Schritt erstmal eine Klasse, Welche das in JSON formulierte Objekt auf NET-Ebene widerspiegelt.

Dazu könnten wir einerseits händisch loslegen und die einzelnen Eigenschaften definieren:

Public Class ApiResponse

  Public Property success As Boolean

  Public Property timestamp As Integer

  ' ...

End Class

Oder uns andererseits durch moderne Hilfsmittel in Visual Studio helfen lassen.

Visual Studio besitzt die Funktionalität, einen JSON-String gar automatisiert in passende Klassen umzuwandeln:

JSON String mit Visual Studio in NET Objekt umwandeln

Auch wenn es mit dem aktuellen Stand schon funktionieren würde, den String in ein Objekt (mit Sub-Objekten) umzuwandeln.

Leider kann die API ja mit dynamischen „symbols“ aufgerufen werden, weshalb ggf. unterschiedliche und nie fixe „Properties“ in dem „Rate“-Objekt zurückkommen.

Wenn Dich das nicht weiter stört, könntest Du natürlich die „Rate„-Klasse so ausbauen, dass sämtliche Währungen dort drinnen vertreten wären.

Ich persönlich fände das allerdings nicht so prickelnd, daher bauen wir die „RootObject„-Klasse noch ein wenig um und lassen die „Rates„-Klasse verschwinden.

JSON Parser installieren

Als nächstes installieren wir das bekannte Newtonsoft Json NuGet-Paket, um eine einfache Handhabung mit JSON-Objekten zu erhalten.

Danach passen wir die „RootObject„-Klasse an, indem wir Sie zuerst einmal sinnvoller benennen, also etwa „ExchangeRatesApiResponse„.

Anschließend ändern wir den Rückgabetyp der „rates„-Eigenschaft in „JObject“ um, Welches es uns die Arbeit erleichtert.

Nun können wir die „responseContent„-Variable, worin unser JSON-String steckt endlich umwandeln.

Im gleichen Schritt können wir auch noch die „exchangeRate“, also den Wechselkurs, typisiert aus der „rates„-Eigenschaft ziehen.

Die Umwandlung selbst – VB NET Web API

Dazu rufe ich im ersten Schritt die „DeserializeObject„-Funktion der „JsonConvert„-Klasse auf, Welche wir uns mit dem NuGet-Package installiert haben.

Dabei übergebe ich den generischen Parameter „ExchangeRatesApiResponse“, Welcher unseren Ziel-Datentyp für die „Antwort-Klasse“ widerspiegelt.

Schon haben wir den letztendlichen Wechselkurs vorliegen!

Dim apiResponse = JsonConvert.DeserializeObject(Of ExchangeRatesApiResponse)(responseContent)
Dim exchangeRate = apiResponse.rates.Value(Of Double)(targetCurrency)

Ein beispielhafter Aufruf unseres Services innerhalb einer Konsolenanwendung könnte nun final so aussehen:

Module Program

    Sub Main(args As String())
        Dim service = New ExchangeRateService()
        Dim exchangeRate = service.GetExchangeRateAsync("EUR", "JPY").Wait()
        ' do something with exchangeRate..
    End Sub

End Module

Weiterführende Links

• VB NET MouseClick simulieren – mit AutoIt3
• VB NET ImageSearch – Bilder in Spielen, Desktop und Co. suchen

Downloads

Hier findest Du wie immer die zugehörigen Downloads zum Beitrag.

Der Beitrag VB NET Web API – Währungskurs Service Konsum von Grund auf erklärt erschien zuerst auf Robert Skibbe.