RSS-Reader-Tutorial (Rust für Windows mit VS Code)

2025-05-03

Im vorherigen Thema wurden Rust für Windows und der Windows-Crateeingeführt.

Jetzt probieren wir Rust für Windows aus, indem wir eine einfache Konsolen-App schreiben, die die Titel von Blogbeiträgen aus einem RSS-Feed (Really Simple Syndication) herunterlädt.

Starten Sie eine Eingabeaufforderung (cmd.exe) und wechseln Sie cd in einen Ordner, in dem Sie Ihre Rust-Projekte speichern möchten.
Erstellen Sie mit Cargo ein neues Rust-Projekt mit dem Namen rss_reader, und fügen Sie cd in den neu erstellten Ordner hinzu:
```
> cargo new rss_reader
>     Created binary (application) `rss_reader` package
> cd rss_reader
```
Öffnen Sie dann das rss_reader Projekt in VS Code.
```
code .
```
Lassen Sie uns das Hauptprojekt rss_reader realisieren. Öffnen Sie zunächst die Cargo.toml Datei im Stammverzeichnis des Projekts. Eine Cargo.toml Datei ist eine Textdatei, die ein Rust-Projekt beschreibt, einschließlich aller Abhängigkeiten, die es hat.

Fügen Sie eine Abhängigkeit von dem windows--Crate hinzu, wie in der folgenden Liste gezeigt. Die Fenster Kasten ist groß. Um die Erstellungszeiten kurz zu halten, wählen wir nur die Funktionen Foundation_Collections und Web_Syndication aus, die wir für diesen Code benötigen.
```
# Cargo.toml
...

[dependencies.windows] 
version = "0.43.0"
features = [
    "Foundation_Collections",
    "Web_Syndication",
]
```
Öffnen Sie dann die Quellcodedatei des src/main.rs Projekts. Dort finden Sie den Cargo-Standardcode "Hello, world!". Fügen Sie am Anfang von die folgende main.rs Anweisung hinzu:
```
// src\main.rs
use windows::{
    core::*,
    Foundation::Uri,
    Web::Syndication::SyndicationClient
};

fn main() {
    println!("Hello, world!");
}
```
Die verwenden Deklaration verkürzt den Pfad zu den Typen, die wir verwenden. Es gibt den URI- Typ, den wir zuvor erwähnt haben.
Um einen neuen URI-zu erstellen, ersetzen Sie die Standardfunktion Haupt- von Cargo durch folgendes:
```
// src\main.rs
...

fn main() -> Result<()> {
    let uri = Uri::CreateUri(h!("https://blogs.windows.com/feed"))?;

    Ok(())
}
```
Beachten Sie, dass der Rückgabetyp der Hauptfunktion ein Resultvon windows::core::ist. Das wird die Sache erleichtern, da es häufig vorkommt, dass man mit Fehlern von Betriebssystem-APIs umgeht. windows::core::Result hilft uns bei der Fehlerverteilung und präziser Fehlerbehandlung.

Sie können den Fragezeichenoperator am Ende der Codezeile sehen. Um Aufwand beim Tippen zu sparen, verwenden wir damit die Fehlerweiterleitungs- und Kurzschlusslogik von Rust. Das bedeutet, dass wir für dieses einfache Beispiel nicht eine Reihe manueller Fehlerbehandlungen ausführen müssen. Weitere Informationen zu dieser Funktion von Rust finden Sie unter Der ?-Operator für eine einfachere Fehlerbehandlung.

Beachten Sie auch das h!-Makro aus der Windows--Bibliothek. Wir verwenden das, um einen HSTRING- Verweis aus einem Zeichenfolgenliteral von Rust zu konstruieren. Die WinRT-API verwendet HSTRING umfassend für Zeichenfolgenwerte.
Um den RSS-Feed herunterzuladen, erstellen wir einen neuen SyndicationClient.
```
// src\main.rs
...

fn main() -> windows::core::Result<()> {
    let uri = Uri::CreateUri(h!("https://blogs.windows.com/feed"))?;
    let client = SyndicationClient::new()?;

    Ok(())
}
```
Die neue Funktion ist ein Rust-Konstruktor. Alle Objekte in der windows Crate folgen der Rust-Konvention und nennen ihre Konstruktoren new.
Jetzt können wir den SyndicationClient- verwenden, um den Feed abzurufen.
```
// src\main.rs
...

fn main() -> windows::core::Result<()> {
    let uri = Uri::CreateUri(h!("https://blogs.windows.com/feed"))?;
    let client = SyndicationClient::new()?;
    let feed = client.RetrieveFeedAsync(&uri)?.get()?;

    Ok(())
}
```
Da RetrieveFeedAsync- eine asynchrone API ist, verwenden wir die blockierende get- Funktion, um das Beispiel einfach zu halten. Alternativ könnten wir den await Operator innerhalb einer async Funktion verwenden, um kooperativ auf die Ergebnisse zu warten. Eine komplexere App mit einer grafischen Benutzeroberfläche wird häufig async verwenden.

Jetzt können wir die resultierenden Elemente durchlaufen und nur die Titel drucken. Sie werden außerdem unten einige zusätzliche Codezeilen sehen, um einen User-Agent-Header festzulegen, da einige RSS-Feeds dies erfordern.

// src\main.rs
...

fn main() -> windows::core::Result<()> {
    let uri = Uri::CreateUri(h!("https://blogs.windows.com/feed"))?;
    let client = SyndicationClient::new()?;

    client.SetRequestHeader(
        h!("User-Agent"),
        h!("Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)"),
    )?;

    let feed = client.RetrieveFeedAsync(&uri)?.get()?;

    for item in feed.Items()? {
        println!("{}", item.Title()?.Text()?);
    }

    Ok(())
}

Lassen Sie uns nun bestätigen, dass wir kompilieren und ausführen können, indem wir auf Ausführen>Ohne Debugging ausführen klicken (oder STRG+F5drücken). Wenn unerwartete Nachrichten angezeigt werden, stellen Sie sicher, dass Sie das Hello, world! Tutorial (Rust mit VS Code)erfolgreich abgeschlossen haben.

Außerdem gibt es die Befehle Debuggen- und Ausführen-, die im Text-Editor eingebettet sind. Geben Sie alternativ über eine Eingabeaufforderung im Ordner rss_readercargo runein, die erstellt und dann das Programm ausführt.

Im Bereich "VS Code Terminal" können Sie sehen, dass Cargo das Windows--Crate erfolgreich herunterlädt und kompiliert, die Ergebnisse zwischenspeichert und dann verwendet, um nachfolgende Builds in kürzerer Zeit abzuschließen. Anschließend wird das Beispiel erstellt und ausgeführt, wobei eine Liste von Blogbeitragstiteln angezeigt wird.

Das ist so einfach wie das Programmieren von Rust für Windows. Unter der Haube geht jedoch viel Liebe in die Entwicklung der Werkzeuge ein, damit Rust sowohl .winmd Dateien basierend auf ECMA-335 (Common Language Infrastructure, oder CLI) analysieren kann, und auch die COM-basierte Anwendungs-Binärschnittstelle (ABI) zur Laufzeit mit Sicherheit und Effizienz berücksichtigen.

Anzeigen eines Meldungsfelds

Wir haben gesagt, dass Rust für Windows jede Windows-API aufrufen kann (Vergangenheit, Gegenwart und Zukunft). In diesem Abschnitt werden also einige Windows-Meldungsfelder angezeigt.

Genau wie für das RSS-Projekt cd an der Eingabeaufforderung in den Ordner mit Ihren Rust-Projekten.

Erstellen Sie ein neues Projekt mit dem Namen message_box, und öffnen Sie es in VS Code:

> cargo new message_box
>     Created binary (application) `message_box` package
> cd message_box
> code .

Öffnen Sie in VS Code die Cargo.toml, und fügen Sie die Windows-Abhängigkeiten für dieses Projekt hinzu:

 # message_box\Cargo.toml
 ...

 [dependencies.windows]
 version = "0.43.0"
 features = [
     "Win32_Foundation",
     "Win32_UI_WindowsAndMessaging",
 ]

Öffnen Sie nun die src/main.rs-Datei des Projekts und fügen Sie die use-Deklarationen mit den neuen „Namespaces“ hinzu (siehe unten). Fügen Sie schließlich Code hinzu, um die funktionen MessageBoxA und MessageBoxW aufzurufen. Die Windows-API-Dokumente werden hauptsächlich mit C/C++ geschrieben, daher ist es nützlich, die API-Dokumente mit den Dokumenten für die Rust-Projektionen in den Fenstern Kasten zu vergleichen: MessageBoxA (Rust) und MessageBoxW (Rust).
```
// src\main.rs
use windows::{
    core::*,
    Win32::UI::WindowsAndMessaging::*
};

fn main() {
    unsafe {
        MessageBoxA(None, s!("Ansi"), s!("World"), MB_OK);
        MessageBoxW(None, w!("Wide"), w!("World"), MB_OK);
    }
}
```
Wie Sie sehen können, müssen wir diese Win32-APIs in einem unsafe Block verwenden (siehe unsichere Blöcke). Beachten Sie auch die Makros s! und w!, die LPCSTR- und LPCWSTR-Argumente aus Rust UTF-8-Zeichenfolgenliteralien erstellen, ähnlich wie wir ein HSTRING mit dem Makro h! für rss_readererstellt haben. Rust unterstützt nativ Unicode mit UTF-8-Zeichenfolgen, sodass die Verwendung der weiten Unicode-APIs (W-Suffix) gegenüber den ANSI-APIs (A-Suffix) bevorzugt wird. Dies kann wichtig sein, wenn Sie nicht englischen Text in Ihrem Code verwenden.

Dieses Mal, wenn Sie erstellen und ausführen, zeigt Rust zwei Windows-Meldungsfelder an.

Freigeben über

RSS-Reader-Tutorial (Rust für Windows mit VS Code)

Anzeigen eines Meldungsfelds

Verwandte Themen

Zusätzliche Ressourcen