RSS-olvasó oktatóanyag (Rust for Windows with VS Code)

Az előző témakör bemutatta a Rust for Windows és a windows crate.

Most próbáljuk ki a Rust for Windowst egy egyszerű konzolalkalmazás megírásával, amely letölti a blogbejegyzések címét egy Igazán egyszerű hírcsatorna (RSS) hírcsatornából.

Nyisson meg egy parancssort (cmd.exe), és navigáljon cd arra a mappába, ahol a Rust-projekteket szeretné tárolni.
A Cargo használatával hozz létre egy rss_reader nevű Rust projektet, és menj az újonnan létrehozott mappába:
```
> cargo new rss_reader
>     Created binary (application) `rss_reader` package
> cd rss_reader
```
Ezután nyissa meg a rss_reader projektet a VS Code-ban.
```
code .
```
Valósítsuk meg az rss_reader fő projektet. Először nyissa meg a Cargo.toml fájlt a projekt gyökerénél. A Cargo.toml fájlok olyan szöveges fájlok, amelyek egy Rust-projektet írnak le, beleértve az esetleges függőségeket is.

Adjon hozzá függőséget a windows láda számára, ahogy az az alábbi felsorolásban is látható. A ablak láda nagy. A buildidő gyorsaságának fenntartása érdekében csak azokat a Foundation_Collections és Web_Syndication funkciókat választjuk ki, amelyekre szükségünk van ehhez a kódhoz.
```
# Cargo.toml
...

[dependencies.windows] 
version = "0.43.0"
features = [
    "Foundation_Collections",
    "Web_Syndication",
]
```
Ezután nyissa meg a rss_reader projekt forráskódfájlját src/main.rs . Itt megtalálja a Cargo alapértelmezett "Hello, world!" kódját. Adja hozzá a következő utasítást a main.rselejéhez:
```
// src\main.rs
use windows::{
    core::*,
    Foundation::Uri,
    Web::Syndication::SyndicationClient
};

fn main() {
    println!("Hello, world!");
}
```
A használati deklaráció lerövidíti a használni kívánt típusok elérési útját. Létezik a korábban említett Uri típus.
Új Urilétrehozásához helyettesítse a Cargo alapértelmezett fő függvényét ezzel:
```
// src\main.rs
...

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

    Ok(())
}
```
Figyelje meg, hogy a fő függvény visszatérési típusa a Result, a windows::core::névtérből. Ez megkönnyíti a dolgokat, mivel gyakori az operációs rendszer (OS) API-k hibáinak kezelése. windows::core::Result segít a hibák propagálásában és a hibák tömör kezelésében.

A kérdőjel operátor a kódsor végén látható. Az írás megkönnyítése érdekében használjuk a Rust hibapropagálási és rövidzárértelműsítési logikáját. Ez azt jelenti, hogy nem kell manuális hibakezelést végeznünk ehhez az egyszerű példához. További információ Rust ezen funkciójáról: A ? operátor a könnyebb hibakezeléshez.

Vegye észre a h! makrót a windows ládából. Ezzel létrehozunk egy HSTRING-hivatkozást egy Rust karakterlánc-literálból. A WinRT API HSTRING széles körben használja a karakterlánc értékekhez.
Az RSS-hírcsatorna letöltéséhez létrehozunk egy új SyndicationClientet.
```
// src\main.rs
...

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

    Ok(())
}
```
Az új függvény egy rust konstruktor. A windows láda összes objektuma a Rust konvenciót követi, és a konstruktorainak újnevet ad.
Most már a SyndicationClient használatával lekérhetjük a hírcsatornát.
```
// 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(())
}
```
Mivel a RetrieveFeedAsync egy aszinkron API, a blokkoló get függvényt használjuk a példa egyszerűségéhez. Másik lehetőségként használhatjuk a await függvényen belüli operátort async , hogy együttműködően várjunk az eredményekre. A grafikus felhasználói felülettel rendelkező összetettebb alkalmazásokat gyakran használják async.

Most már iterálhatjuk az eredményként kapott elemeket, és nyomtassuk ki csak a címeket. Az alábbiakban néhány további kódsort is látni fog a felhasználói ügynök fejlécének beállításához, mivel egyes RSS-hírcsatornák megkövetelik ezt.

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

Most ellenőrizzük, hogy tudunk-e építeni és futtatni azáltal, hogy rákattintunk a Futtatás>Futtatás hibakeresés nélkül (vagy a Ctrl+F5billentyűkombináció lenyomásával). Ha váratlan üzeneteket lát, győződjön meg arról, hogy sikeresen elvégezte a Hello, world! oktatóanyagot (Rust with VS Code).

Emellett a szövegszerkesztőbe beágyazva találhatók a Hibakeresés és a Futtatás parancsok. Alternatív megoldásként, a rss_reader mappában nyisson meg egy parancssort, és írja be a cargo run parancsot, amely létrehozza, majd futtatja a programot.

A VS Code Terminál panelen láthatja, hogy a Cargo sikeresen letölti és lefordítja a windows csomagot, gyorsítótárazva az eredményeket, hogy a későbbi build-ek kevesebb idő alatt készüljenek el. Ezután létrehozza a mintát, és futtatja azt, megjelenítve a blogbejegyzések címeinek listáját.

Ez olyan egyszerű, mint a Rust programozása Windowsra. A motorháztető alatt azonban sok szeretet kerül az eszközkészítésbe, hogy a Rust képes legyen elemezni a .winmd fájlokat a ECMA-335 (Common Language Infrastructure, vagy CLI) alapján, és a COM-alapú alkalmazás bináris felületét (ABI) is hűen betartsa futásidőben, szem előtt tartva mind a biztonságot, mind a hatékonyságot.

Üzenetmező megjelenítése

Azt mondtuk, hogy a Rust for Windows lehetővé teszi bármely Windows API meghívását (múlt, jelen és jövő). Ebben a szakaszban tehát megjelenítünk néhány Windows-üzenetmezőt.

Az RSS-projektnél alkalmazott módszerhez hasonlóan a parancssorban írja be a "cd" parancsot a Rust-projektek mappájához való navigáláshoz.

Hozzon létre egy új projektet message_box néven, és nyissa meg a VS Code-ban:

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

A VS Code-ban nyissa meg a Cargo.toml-t, és adja hozzá ehhez a projekthez a Windows-függőségeket.

 # message_box\Cargo.toml
 ...

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

Most nyissa meg a projekt fájlját src/main.rs , és adja hozzá a use deklarációkat az új névterekhez (az alább látható módon). Végül adjon hozzá kódot a MessageBoxA és a MessageBoxW függvény meghívásához. A Windows API-dokumentumokat elsősorban C/C++ programozási környezet számára írták, így hasznos lehet összehasonlítani az API-dokumentumokat a Windows Rust-vetületekhez tartozó dokumentumokkal a windows csomagban: MessageBoxA (Rust) és 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);
    }
}
```
Mint látható, ezeket a Win32 API-kat egy unsafe blokkban kell használnunk (lásd : Nem biztonságos blokkok). Jegyezze meg a s! és a w! makrókat, amelyek LPCSTR és LPCWSTR argumentumokat hoznak létre Rust UTF-8 sztringkonstansokból, ahogyan létrehoztunk egy HSTRING-t a h! makróval az rss_readerszámára. A Rust natív módon támogatja az Unicode-ot UTF-8 sztringekkel, ezért a széles Unicode (W-utótag) Windows API-k használata előnyösebb, mint az ANSI (A-utótag) API-ké. Ez akkor lehet fontos, ha nem angol nyelvű szöveget használ a kódban.

A buildeléskor és futtatáskor a Rust két Windows-üzenetmezőt jelenít meg.

Visszacsatolás

Hasznos volt ez az oldal?

Last updated on 2025-05-03

Megosztás:

RSS-olvasó oktatóanyag (Rust for Windows with VS Code)

Üzenetmező megjelenítése

Kapcsolódó tartalmak

Visszacsatolás

További források