RSS-läsare handledning (Rust för Windows med VS Code)

Föregående avsnitt introducerade Rust för Windows och Windows-paketet.

Nu ska vi prova Rust for Windows genom att skriva en enkel konsolapp som laddar ned rubrikerna för blogginlägg från ett RSS-flöde (Really Simple Syndication).

Starta en kommandotolk (cmd.exe) och cd till en mapp där du vill behålla dina Rust-projekt.
Med Hjälp av Cargo skapar du ett nytt Rust-projekt med namnet rss_reader och cd till den nyligen skapade mappen:
```
> cargo new rss_reader
>     Created binary (application) `rss_reader` package
> cd rss_reader
```
Öppna sedan projektet rss_reader i VS Code.
```
code .
```
Nu ska vi implementera huvudprojektet rss_reader . Öppna först filen Cargo.toml i roten av projektet. En Cargo.toml fil är en textfil som beskriver ett Rust-projekt, inklusive eventuella beroenden som den har.

Lägg till ett beroende på Windows crate, som visas i listan nedan. Den fönsterlådan är stor. För att hålla byggtiden snabb väljer vi bara de Foundation_Collections funktioner och Web_Syndication funktioner som vi behöver för den här koden.
```
# Cargo.toml
...

[dependencies.windows] 
version = "0.43.0"
features = [
    "Foundation_Collections",
    "Web_Syndication",
]
```
Öppna sedan rss_reader-projektets källkodsfil.src/main.rs Där hittar du cargo-standardkoden "Hello, world!". Lägg till följande använd-instruktion i början av main.rs:
```
// src\main.rs
use windows::{
    core::*,
    Foundation::Uri,
    Web::Syndication::SyndicationClient
};

fn main() {
    println!("Hello, world!");
}
```
Användning av-deklarationen i förkortar sökvägen till de typer som vi kommer att använda. Det finns Uri- typ som vi nämnde tidigare.
Om du vill skapa en ny Uri-ersätter du Cargos standardfunktion main med detta:
```
// src\main.rs
...

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

    Ok(())
}
```
Observera att returtypen för funktionen main är en Result, från windows::core::. Det gör det enklare eftersom det är vanligt att hantera fel från OPERATIVSYSTEM-API:er (OS). windows::core::Result hjälper oss med felspridning och koncis felhantering.

Du kan se frågeteckenoperatorn i slutet av kodraden. För att spara in på skrivande använder vi Rusts felhantering och brytlogik. Det innebär att vi inte behöver utföra en massa manuell felhantering för det här enkla exemplet. För mer information om den här funktionen i Rust, se operatorn ? för enklare felhantering.

Observera också h! makro från Windows paket. Vi använder det för att konstruera en HSTRING--referens från en Rust-strängsliteral. WinRT API använder HSTRING i stor utsträckning för strängvärden.
För att ladda ned RSS-flödet skapar vi en ny SyndicationClient.
```
// src\main.rs
...

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

    Ok(())
}
```
Funktionen är en ny Rust-konstruktor för . Alla objekt i fönster låda följer Rust-konventionen och namnger sina konstruktorer nya.
Nu kan vi använda SyndicationClient för att hämta feeden.
```
// 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(())
}
```
Eftersom RetrieveFeedAsync är ett asynkront API använder vi funktionen blocking get för att hålla exemplet enkelt. Alternativt kan vi använda operatorn await i en async funktion för att tillsammans vänta på resultaten. En mer komplex app med ett grafiskt användargränssnitt använder asyncofta .

Nu kan vi iterera över de resulterande objekten och nu ska vi skriva ut bara rubrikerna. Du ser också några extra kodrader nedan för att ange ett användaragenthuvud, eftersom vissa RSS-feeds kräver det.

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

Nu ska vi bekräfta att vi kan skapa och köra genom att klicka på Kör>kör utan felsökning (eller trycka på Ctrl +F5). Om du ser oväntade meddelanden kontrollerar du att du har slutfört självstudiekursen Hello, world! (Rust med VS Code).

Det finns också Debug och Kör inbäddade i textredigeraren. Alternativt, från mappen rss_reader i en kommandotolk, skriv cargo run, vilket kommer att bygga och sedan köra programmet.

Nere i VS Code Terminal-fönstret kan du se att Cargo framgångsrikt laddar ned och kompilerar windows-paketet, cachelagrar resultaten och använder dem för att slutföra efterföljande byggen på kortare tid. Det skapar sedan exemplet och kör det och visar en lista över blogginläggstitlar.

Det är så enkelt som det är att programmera Rust för Windows. Under motorhuven går dock mycket kärlek till att bygga verktygen så att Rust både kan parsa .winmd-filer baserade på ECMA-335 (Common Language Infrastructure eller CLI), och även troget upprätthålla det COM-baserade binära gränssnittet (ABI) vid körning med både säkerhet och effektivitet i åtanke.

Visar en meddelanderuta

Vi sa att Rust för Windows låter dig anropa alla Windows-API:er (tidigare, nuvarande och framtida). Så i det här avsnittet visar vi ett par Windows-meddelanderutor.

Precis som vi gjorde för RSS-projektet i kommandotolken cd till mappen med dina Rust-projekt.

Skapa ett nytt projekt med namnet message_box och öppna det i VS Code:

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

I VS Code, öppna Cargo.toml och lägg till Windows-beroenden för det här projektet.

 # message_box\Cargo.toml
 ...

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

Öppna nu projektets src/main.rs fil och lägg till use deklarationerna med de nya namnrymderna (se nedan). Och slutligen lägga till kod för att anropa funktionerna MessageBoxA och MessageBoxW . Windows API-dokumentationerna är huvudsakligen skrivna med C/C++ i åtanke, så det är användbart att jämföra API-dokumenten med dokumentationen för Rust-projektionerna i windows-paketet: MessageBoxA (Rust) och 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);
    }
}
```
Som du ser måste vi använda dessa Win32-API:er i ett unsafe block (se Osäkra block). Observera även s! och w! makron som skapar LPCSTR-- och LPCWSTR- argument från Strängliteraler för Rust UTF-8; ungefär som vi skapade en HSTRING med h! makro för rss_reader. Rust är inbyggt Unicode med UTF-8-strängar, så att använda de breda Unicode-API:erna (W-suffix) i Windows rekommenderas framför API:erna för ANSI (A-suffix). Detta kan vara viktigt om du använder text som inte är engelsk i koden.

Den här gången när du skapar och kör visar Rust två Windows-meddelanderutor.

Feedback

Var den här sidan till hjälp?

Last updated on 2025-05-05

Dela via

RSS-läsare handledning (Rust för Windows med VS Code)

Visar en meddelanderuta

Relaterade ämnen

Feedback

Ytterligare resurser