Einen Postman-Klon bauen: Klassenbibliotheksdesign für API-Aufrufe

Einführung und Einrichtung

Tim beginnt, indem er das Ziel dieser Lektion erklärt: die Erstellung der Geschäftslogik und der Datenzugriffsschicht, um API-Aufrufe in der Anwendung zu ermöglichen. Er betont, dass dies ein MVP ist – eine funktionsfähige Version, die später erweitert werden kann.

Bevor er in den Code eintaucht, weist Tim darauf hin, dass der Kurs darauf ausgelegt ist, portfoliofreundlich zu sein, obwohl er davor warnt, das Projekt direkt zu kopieren. Stattdessen ermutigt er Entwickler, es als Inspiration zu nutzen, um einzigartige Projekte zu erstellen, die Fähigkeiten in C#, API-Interaktion und UI-Design demonstrieren.

Erstellen der API-Zugriffsklasse

Tim führt uns durch das Öffnen der Klassenbibliothek und beginnt mit einem sauberen Blatt. Er löscht die Standardklasse Class1 und erstellt eine neue Klasse mit dem Namen APIAccess. Dies wird alle API-Interaktionen abwickeln.

Er erklärt seinen Ansatz zur Methodengestaltung: beginnend mit öffentlichen void-Methoden, Parametern wie string url hinzufügend und sie dann schrittweise zu asynchronen Aufgaben verfeinernd, die echte API-Anfragen bearbeiten können.

public class APIAccess
{
    private readonly HttpClient client = new();

    public async Task<string> CallApiAsync(string url)
    {
        var response = await client.GetAsync(url);
        if (response.IsSuccessStatusCode)
        {
            return await response.Content.ReadAsStringAsync();
        }
        return $"Fehler: {response.StatusCode}";
    }
}

Tim betont, eine einzelne HTTP-Client-Instanz zu erstellen, um zu vermeiden, dass sie bei jedem Aufruf neu initialisiert wird, was die Leistung verbessert.

Umgang mit API-Antworten

Sobald der HTTP-Client eingerichtet ist, zeigt Tim, wie man die Antwort aus dem API-Aufruf abruft. Er weist auf die Wichtigkeit hin, eine Task anstelle von async void zurückzugeben, außer bei Ereignis-Handlern.

Zum Demonstrieren verwendet Tim eine Beispiel-API von JSON Placeholder, die gefälschte Daten wie Beiträge, Kommentare und To-Dos bereitstellt. Er fügt die API-URL in das HTML des UI-Formulars ein und verwendet das Feld results.Text, um die Antwort HTML oder JSON anzuzeigen.

results.Text = await api.CallApiAsync(apiText.Text);

Tim merkt an, dass die rohe JSON-Ausgabe computerlesbar, aber nicht nutzerfreundlich ist, was zum nächsten Schritt führt: der Formatierung von JSON.

Formatierung der JSON-Ausgabe

Tim zeigt, wie man die Antwort JSON lesbarer macht, indem man JsonSerializer verwendet:

var jsonElement = JsonSerializer.Deserialize<JsonElement>(responseJson);
var prettyJson = JsonSerializer.Serialize(jsonElement, new JsonSerializerOptions { WriteIndented = true });

Dies ermöglicht es Entwicklern, hübsches JSON in der UI anzuzeigen, das leichter in JSON-Text-Editoren zu lesen ist oder beim Testen von Endpunkten. Tim fügt auch eine Option hinzu, zwischen rohem und formatiertem Output umzuschalten, um Flexibilität zu bieten, je nachdem, ob die Daten in der UI angezeigt oder programmgesteuert verarbeitet werden sollen.

Planung für zukünftige Verbesserungen

Auch wenn das MVP nur GET-Anfragen unterstützt, demonstriert Tim, wie man für andere HTTP-Aktionen wie POST, PATCH, PUT und DELETE plant. Er erstellt ein Enum namens HTTPAction mit einem Standardwert von GET und bereitet den Code darauf vor, zu skalieren, ohne bestehende Methoden umzuschreiben.

public enum HTTPAction
{
    GET
}

Dieser zukunftsorientierte Entwurf ist eine gute Praxis für Entwickler, die ihren eigenen Postman-Klon bauen wollen, der wartbar und erweiterbar ist.

URL-Validierung

Tim stellt eine URL-Validierungsmethode vor, um sicherzustellen, dass Benutzer nur gültige HTTPS-Endpunkte bereitstellen:

public bool IsValidURL(string url)
{
    if (string.IsNullOrWhiteSpace(url)) return false;
    return Uri.TryCreate(url, UriKind.Absolute, out Uri uriResult) && uriResult.Scheme == Uri.UriSchemeHttps;
}

Er erklärt die Wichtigkeit, Benutzereingaben niemals zu vertrauen und sie bei Bedarf mehrfach zu validieren. Dies stellt sicher, dass die Anwendung nicht aufgrund ungültiger URLs abstürzt und verhindert, dass Fehlermeldungen den Arbeitsablauf stören.

Integration des API-Zugriffs mit der UI

Sobald die Validierung an Ort und Stelle ist, zeigt Tim, wie man den API-Zugriff mit dem Dashboard-UI integriert:

1. Instanziieren der APIAccess-Klasse.

2. Validierung der URL.

3. Anzeige des Antwort-JSON im Ergebnistext-Editor.

4. Zeigen aussagekräftiger Fehlermeldungen für ungültige oder fehlgeschlagene Anfragen.

if (!api.IsValidURL(apiText.Text))
{
    systemStatus.Text = "Ungültige URL";
    results.Text = string.Empty;
    return;
}
results.Text = await api.CallApiAsync(apiText.Text);

Tim betont die Wichtigkeit eines sauberen UI-Designs, das jede Anfrage mit einem leeren Ergebnisbereich startet und den Systemstatus basierend auf Erfolg oder Misserfolg aktualisiert.

Verwendung von Schnittstellen für Dependency Injection und Unit Testing

Tim führt IAPIAccess ein, eine Schnittstelle für APIAccess. Dies ist eine Best Practice für Unit Testing und die Vorbereitung des Codes für Dependency Injection:

public interface IAPIAccess
{
    Task<string> CallApiAsync(string url);
    bool IsValidURL(string url);
}

Indem gegen eine Schnittstelle anstatt der konkreten Klasse programmiert wird, können Entwickler Implementierungen für Tests austauschen oder die API-Logik aktualisieren, ohne die UI oder anderen abhängigen Code zu ändern. Tim betont, dass dies für das MVP leicht übertrieben ist, aber für zukünftige Anwendungsverbesserungen wertvoll ist.

Testen und Ausführen der Anwendung

Mit allen Teilen an Ort und Stelle führt Tim die Anwendung auf Windows aus, fügt die JSON Placeholder URL ein und zeigt erfolgreich die formatierte JSON-Antwort an. Er zeigt, wie ungültige URLs korrekt abgelehnt werden, wodurch sichergestellt wird, dass die App robust bleibt, auch bei Benutzereingabefehlern.

Dies bildet einen funktionalen Postman-Klon, der in der Lage ist, GET-Anfragen zu stellen, Eingaben zu validieren und Antworten in einem benutzerfreundlichen Format anzuzeigen.

Nächste Schritte: Portfolio- und GitHub-Integration

Tim schließt die Lektion ab, indem er die Wichtigkeit betont, dieses Projekt in ein Portfolio-fähiges Element zu verwandeln. Er schlägt vor:

• Erstellen eines GitHub-Repositories für das Projekt.

• Hinzufügen eines klaren README, das die Anwendung erklärt.

• Einschließen einer herunterladbaren ausführbaren Datei, die andere testen können.

• Hervorheben der UI und Funktionen in Screenshots oder GIFs.

• Dokumentation des Prozesses, der Einrichtung und der Code-Struktur.

Er warnt davor, einfach seinen Code zu kopieren und als eigenen hochzuladen. Stattdessen sollten Entwickler diese Lektionen nutzen, um ihren eigenen Postman-Klon oder eine ähnliche App zu erstellen, die den persönlichen Stil und die Fähigkeiten widerspiegelt.

Indem dieser Ansatz befolgt wird, zeigen Entwickler nicht nur ihre Programmierfähigkeit, sondern auch die Fähigkeit, ein Softwareprojekt zu erkunden, zu aktualisieren und zu warten, was für potenzielle Arbeitgeber von unschätzbarem Wert ist.

Abschluss

Tim Coreys Video bietet eine umfassende Anleitung zum Aufbau eines Postman-Klons von Grund auf. Von der Einrichtung einer Klassenbibliothek über die Handhabung von API-Aufrufen, das Formatieren von JSON-Antworten, die Validierung von Eingaben bis hin zur Vorbereitung des Projekts für zukünftige Verbesserungen mit Schnittstellen und Dependency Injection deckt diese Lektion einen vollständigen Anwendungsentwicklungsprozess ab.

Durch die Befolgung dieses Ansatzes können Entwickler einen MVP-Postman-Klon mit einfachem C# aufbauen, UI-Elemente zur Anzeige von Antwort-HTML oder JSON integrieren und ein GitHub-Projekt für die Vorführung im Portfolio vorbereiten. Diese schrittweise Methodik lehrt nicht nur Code, sondern betont auch Planung, Prozess und Design Thinking, was entscheidende Fähigkeiten für professionelle Softwareentwickler sind.