RSS-lezer zelfstudie (Rust voor Windows met VS Code)

In het vorige onderwerp zijn Rust voor Windows en de windows crategeïntroduceerd.

Nu gaan we Rust voor Windows uitproberen door een eenvoudige console-app te schrijven waarmee de titels van blogberichten worden gedownload van een RSS-feed (Really Simple Syndication).

Start een opdrachtprompt (cmd.exe) en cd naar een map waarin u uw Rust-projecten wilt behouden.
Maak met Cargo een nieuw Rust-project met de naam rss_reader, en plaats cd in de zojuist aangemaakte map.
```
> cargo new rss_reader
>     Created binary (application) `rss_reader` package
> cd rss_reader
```
Open vervolgens het rss_reader project in VS Code.
```
code .
```
Laten we het hoofdproject rss_reader implementeren. Open eerst het Cargo.toml bestand in de hoofdmap van het project. Een Cargo.toml-bestand is een tekstbestand dat een Rust-project beschrijft, inclusief eventuele afhankelijkheden die het heeft.

Voeg een afhankelijkheid toe aan de vensters krat, zoals wordt weergegeven in de onderstaande lijst. De raam krat is groot. Om de buildtijden snel te houden, selecteren we alleen de Foundation_Collections en Web_Syndication functies die we nodig hebben voor deze code.
```
# Cargo.toml
...

[dependencies.windows] 
version = "0.43.0"
features = [
    "Foundation_Collections",
    "Web_Syndication",
]
```
Open vervolgens het broncodebestand van het src/main.rs project. Daar vindt u de Cargo-standaardcode 'Hallo wereld!'. Voeg de volgende instructie toe aan het begin van main.rs:
```
// src\main.rs
use windows::{
    core::*,
    Foundation::Uri,
    Web::Syndication::SyndicationClient
};

fn main() {
    println!("Hello, world!");
}
```
De gebruiksverklaring verkort het pad naar de typen die we gaan gebruiken. Er is de URI type dat we eerder hebben genoemd.
Als u een nieuwe Uriwilt maken, vervangt u de standaard Cargo-functie hoofd- door deze:
```
// src\main.rs
...

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

    Ok(())
}
```
Let op dat het retourtype van de hoofdfunctie een Resultis, van windows::core::. Dit maakt het eenvoudiger, omdat het gebruikelijk is om fouten van besturingssysteem-API's (OS) af te handelen. windows::core::Result helpt ons bij het doorgeven van fouten en beknopte foutafhandeling.

U kunt de vraagtekenoperator aan het einde van de coderegel zien. Om het typen te besparen, doen we dat door de logica voor foutdoorgifte en kortsluitlogica van Rust te gebruiken. Dat betekent dat we voor dit eenvoudige voorbeeld geen handmatige foutafhandeling hoeven uit te voeren. Zie voor meer informatie over deze functie van Rust, de ? operator voor eenvoudigere foutafhandeling.

Let ook op de h! macro uit het Windows pakket. We gebruiken dit om een HSTRING- verwijzing te maken op basis van een letterlijke tekenreeks van Rust. De WinRT-API maakt gebruik van HSTRING- uitgebreid voor tekenreekswaarden.
Als u de RSS-feed wilt downloaden, maken we een nieuwe SyndicationClient-.
```
// src\main.rs
...

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

    Ok(())
}
```
De nieuwe functie is een Rust-constructor. Alle objecten in de vensters crate volgen de Rust-conventie en noemen hun constructors new.
Nu kunnen we de SyndicationClient gebruiken om de feed op te halen.
```
// 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(())
}
```
Omdat RetrieveFeedAsync- een asynchrone API is, gebruiken we de blokkerende functie om het voorbeeld eenvoudig te houden. U kunt ook de operator await binnen een async functie gebruiken om gezamenlijk te wachten op de resultaten. Een complexere app met een grafische gebruikersinterface gebruikt vaak async.

Nu kunnen we de resulterende items herhalen en gaan we alleen de titels afdrukken. U ziet ook een paar extra regels code hieronder om een header van de gebruikersagent in te stellen, omdat voor sommige RSS-feeds dat is vereist.

// 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(())
}

Laten we nu controleren of we kunnen bouwen en uitvoeren door te klikken op Uitvoeren>Uitvoeren zonder foutopsporing (of door op Ctrl+F5te drukken). Als u onverwachte berichten ziet, controleert u of u met succes de zelfstudie "Hallo, wereld!" (Rust met VS Code)hebt voltooid.

Er zijn ook Debug-opdrachten en Run-opdrachten ingebed in de teksteditor. U kunt ook vanaf een opdrachtprompt in de map rss_readercargo runtypen, waarmee het programma wordt gebouwd en uitgevoerd.

In het VS Code-terminalpaneel kunt u zien dat Cargo met succes de "windows" crate downloadt en compileert, de resultaten in de cache opslaat en deze gebruikt om latere builds sneller te voltooien. Vervolgens wordt het voorbeeld gebouwd en uitgevoerd, waarbij een lijst met blogposttitels wordt weergegeven.

Dat is net zo eenvoudig als het programmeren van Rust voor Windows. Onder de motorkap wordt echter veel zorg besteed aan het bouwen van de tooling, zodat Rust zowel .winmd-bestanden kan parseren op basis van ECMA-335 (Common Language Infrastructure of CLI) en ook de op COM gebaseerde binaire interface (ABI) tijdens de uitvoering kan naleven, met zowel veiligheid als efficiëntie als prioriteiten.

Een berichtvak weergeven

We hebben gezegd dat Met Rust voor Windows elke Windows-API (verleden, heden en toekomst) kan worden aangeroepen. In deze sectie laten we dus een aantal Windows-berichtvakken zien.

Net als bij het RSS-project, cd bij de opdrachtprompt de map met uw Rust-projecten.

Maak een nieuw project met de naam message_boxen open het in VS Code:

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

Open in VS Code de Cargo.tomlen voeg de Windows-afhankelijkheden voor dit project toe:

 # message_box\Cargo.toml
 ...

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

Open nu het src/main.rs-bestand van het project en voeg de use declaraties toe met de nieuwe naamruimten (zoals hieronder wordt weergegeven). Voeg ten slotte code toe om de functies MessageBoxA en MessageBoxW aan te roepen. De Windows API-documenten zijn voornamelijk geschreven met C/C++ in gedachten, dus het is handig om de API-documenten te vergelijken met de documenten voor de Rust-projecties in de windows crate: MessageBoxA (Rust) en 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);
    }
}
```
Zoals u kunt zien, moeten we deze Win32-API's gebruiken in een unsafe blok (zie Onveilige blokken). Let ook op de s! en w! macro's, die LPCSTR en LPCWSTR argumenten maken van Rust UTF-8 stringliteraal; net zoals we een HSTRING hebben gemaakt met de h! macro voor rss_reader. Rust is van nature Unicode met UTF-8-tekenreeksen, dus heeft het de voorkeur om de brede Unicode (met W-achtervoegsel) Windows-API's te gebruiken boven de ANSI-API's (met A-achtervoegsel). Dit kan belangrijk zijn als u niet-Engelse tekst in uw code gebruikt.

Deze keer wanneer u bouwt en uitvoert, worden in Rust twee Berichtvakken van Windows weergegeven.

Feedback

Is deze pagina nuttig?

Last updated on 2025-05-03

Delen via

RSS-lezer zelfstudie (Rust voor Windows met VS Code)

Een berichtvak weergeven

Aanverwant

Feedback

Aanvullende resources