Guida al lettore RSS (Rust su Windows con VS Code)

L'argomento precedente ha introdotto Rust per Windows e la crate di Windows.

Ora proviamo Rust per Windows scrivendo una semplice app console che scarica i titoli dei post di blog da un feed RSS (Really Simple Syndication).

Avvia un prompt dei comandi (cmd.exe) e usa cd per spostarti in una cartella in cui desideri mantenere i progetti Rust.

Usando Cargo, creare un nuovo progetto Rust denominato rss_readere cd nella cartella appena creata:

> cargo new rss_reader
>     Created binary (application) `rss_reader` package
> cd rss_reader

Aprire quindi il progetto rss_reader in VS Code.
```
code .
```
Implementiamo il progetto principale di rss_reader. Prima di tutto, apri il file Cargo.toml alla radice del progetto. Un Cargo.toml file è un file di testo che descrive un progetto Rust, incluse eventuali dipendenze presenti.

Aggiungere una dipendenza dalla windows crate, come illustrato nell'elenco seguente. Le finestre crate sono grandi. Per mantenere veloci i tempi di compilazione, si selezioneranno solo le Foundation_Collections funzionalità e Web_Syndication necessarie per questo codice.
```
# Cargo.toml
...

[dependencies.windows] 
version = "0.43.0"
features = [
    "Foundation_Collections",
    "Web_Syndication",
]
```
Aprire quindi il file di codice sorgente del progetto src/main.rs. Qui troverai il codice predefinito "Hello, world!" di Cargo. Aggiungere la seguente istruzione use all'inizio di main.rs:
```
// src\main.rs
use windows::{
    core::*,
    Foundation::Uri,
    Web::Syndication::SyndicationClient
};

fn main() {
    println!("Hello, world!");
}
```
La dichiarazione uso riduce il percorso ai tipi che useremo. Esiste il tipo Uri menzionato in precedenza.
Per creare un nuovo URI, sostituire la funzione principale di Cargo predefinita con questa:
```
// src\main.rs
...

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

    Ok(())
}
```
Si noti che il tipo restituito della funzione principale di è un Result, da windows::core::. Ciò farà sì che le cose siano più semplici, dato che è comune dover gestire gli errori delle API del sistema operativo. windows::core::Result consente la propagazione degli errori e la gestione concisa degli errori.

È possibile visualizzare l'operatore punto interrogativo alla fine della riga di codice. Per risparmiare sulla digitazione, utilizziamo la logica di propagazione degli errori e di cortocircuito di Rust. Ciò significa che non è necessario eseguire una serie di operazioni manuali di gestione degli errori per questo semplice esempio. Per ulteriori informazioni su questa funzionalità di Rust, vedi l'operatore ? per semplificare la gestione degli errori.

Si noti anche la macro h! dal crate windows. Usiamo quello per costruire un riferimento HSTRING da una stringa letterale Rust. L'API WinRT usa HSTRING ampiamente per i valori delle stringhe.
Per scaricare il feed RSS, creeremo un nuovo SyndicationClient.
```
// src\main.rs
...

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

    Ok(())
}
```
La nuova funzione è un costruttore Rust. Tutti gli oggetti nella crate della finestra seguono la convenzione di Rust e chiamano i loro costruttori new.
Ora possiamo usare il SyndicationClient per recuperare il feed.
```
// 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(())
}
```
Poiché RetrieveFeedAsync è un'API asincrona, usiamo la funzione blocking get per mantenere semplice l'esempio. In alternativa, è possibile usare l'operatore await all'interno di una async funzione per attendere in modo cooperativo i risultati. Un'app più complessa con un'interfaccia utente grafica userà spesso async.

A questo punto è possibile scorrere gli elementi risultanti e stampare solo i titoli. Di seguito sono riportate anche alcune righe di codice aggiuntive per impostare un'intestazione dell'agente utente, perché alcuni feed RSS richiedono questo tipo di codice.

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

A questo punto si conferma che è possibile compilare ed eseguire facendo clic su Esegui>Esegui senza eseguire debug (o premendo CTRL+F5). Se visualizzi messaggi imprevisti, assicurati di aver completato correttamente il tutorial "Hello, world!" (Rust con VS Code).

Sono inoltre disponibili comandi di Debug e di Esegui incorporati nell'editor di testo. In alternativa, da un prompt dei comandi nella cartella rss_reader digitare cargo run, che compilerà e quindi eseguirà il programma.

Nel riquadro terminale di VS Code , è possibile notare che Cargo scarica e compila correttamente il crate windows , memorizzando nella cache i risultati e utilizzandoli per completare le compilazioni successive in meno tempo. Compila quindi l'esempio e lo esegue, visualizzando un elenco di titoli dei post di blog.

È così semplice come programmare Rust per Windows. Sotto le quinte, tuttavia, molto impegno viene dedicato alla costruzione degli strumenti affinché Rust possa analizzare i file .winmd basati su ECMA-335 (Common Language Infrastructure o CLI), e anche rispettare fedelmente l'interfaccia binaria dell'applicazione basata su COM per l'ABI durante l'esecuzione, tenendo conto di sicurezza ed efficienza.

Visualizzazione di una finestra di messaggio

Abbiamo detto che Rust per Windows ti consente di chiamare qualsiasi API Windows (passato, presente e futuro). In questa sezione verranno quindi visualizzate alcune finestre di messaggio di Windows.

Proprio come abbiamo fatto per il progetto RSS, al prompt dei comandi, digita cd per accedere alla cartella con i tuoi progetti Rust.

Creare un nuovo progetto denominato message_box e aprirlo in VS Code:

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

Nel VS Code, apri il Cargo.toml, e aggiungi le dipendenze di Windows per questo progetto:

 # message_box\Cargo.toml
 ...

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

Apri ora il file src/main.rs del progetto e aggiungi le dichiarazioni use con i nuovi namespace (come illustrato di seguito). Aggiungere infine codice per chiamare le funzioni MessageBoxA e MessageBoxW. La documentazione dell'API Di Windows viene scritta principalmente con C/C++, pertanto è utile confrontare la documentazione dell'API con la documentazione per le proiezioni Rust nelle finestre crate: MessageBoxA (Rust) e 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);
    }
}
```
Come si può notare, è necessario usare queste API Win32 in un blocco di unsafe (vedere blocchi Unsafe). Si noti anche le macro s! e il w!, che creano argomenti LPCSTR e LPCWSTR da stringhe letterali Rust UTF-8, proprio come abbiamo creato un HSTRING con la macro h! per rss_reader. Rust supporta Unicode nativamente con stringhe UTF-8, quindi l'uso delle API Windows Unicode con suffisso W (Wide Unicode) è preferibile rispetto alle API ANSI con suffisso A. Questo può essere importante se si usa testo non in inglese nel codice.

Questa volta che si compila ed esegue Rust visualizza due finestre di messaggio di Windows.

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2025-05-03

Condividi tramite

Guida al lettore RSS (Rust su Windows con VS Code)

Visualizzazione di una finestra di messaggio

Elementi correlati

Commenti e suggerimenti

Risorse aggiuntive