Tutorial pembaca RSS (Rust untuk Windows dengan Visual Studio Code)

Artikel
08/25/2023

Topik sebelumnya memperkenalkan Rust untuk Windows, dan peti jendela.

Sekarang mari kita coba Rust untuk Windows dengan menulis aplikasi konsol sederhana yang mengunduh judul posting blog dari umpan Really Simple Syndication (RSS).

Luncurkan perintah (cmd.exe), dan cd ke folder tempat Anda ingin menyimpan proyek Rust Anda.

Menggunakan Cargo, buat proyek Rust baru bernama rss_reader, dan cd ke folder yang baru dibuat:

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

Kemudian buka proyek rss_reader di Visual Studio Code.
```
code .
```
Mari kita terapkan proyek rss_reader utama. Pertama, buka Cargo.toml file di akar proyek. File Cargo.toml adalah file teks yang menjelaskan proyek Rust, termasuk dependensi apa pun yang dimilikinya.

Tambahkan dependensi pada peti jendela , seperti yang ditunjukkan pada daftar di bawah ini. Peti jendela besar. Untuk menjaga waktu build tetap cepat, kita hanya akan memilih Foundation_Collections fitur dan Web_Syndication yang kita butuhkan untuk kode ini.
```
# Cargo.toml
...

[dependencies.windows] 
version = "0.43.0"
features = [
    "Foundation_Collections",
    "Web_Syndication",
]
```
Kemudian, buka file kode sumber proyek src/main.rs rss_reader. Di sana Anda akan menemukan kode default Kargo "Halo, dunia!". Tambahkan pernyataan penggunaan berikut ke awal main.rs:
```
// src\main.rs
use windows::{
    core::*,
    Foundation::Uri,
    Web::Syndication::SyndicationClient
};

fn main() {
    println!("Hello, world!");
}
```
Deklarasi penggunaan mempersingkat jalur ke jenis yang akan kita gunakan. Ada jenis Uri yang kami sebutkan sebelumnya.
Untuk membuat Uri baru, ganti fungsi utama default Cargo dengan ini:
```
// src\main.rs
...

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

    Ok(())
}
```
Perhatikan bahwa jenis pengembalian fungsi utama adalah Hasil, dari windows::core::. Itu akan membuat segalanya lebih mudah, karena umumnya untuk menangani kesalahan dari API sistem operasi (OS). windows::core::Result membantu kami dengan penyebaran kesalahan, dan penanganan kesalahan ringkas.

Anda dapat melihat operator tanda tanya di akhir baris kode. Untuk menghemat pengetikan, kami melakukannya untuk menggunakan logika penyebaran kesalahan dan sirkuit pendek Rust. Itu berarti kita tidak perlu melakukan banyak penanganan kesalahan manual untuk contoh sederhana ini. Untuk informasi selengkapnya tentang fitur Rust ini, lihat Operator ? untuk penanganan kesalahan yang lebih mudah.

Perhatikan juga makro h! dari peti jendela . Kami menggunakannya untuk membangun referensi HSTRING dari literal string Rust. WINRT API menggunakan HSTRING secara ekstensif untuk nilai string.

Untuk mengunduh umpan RSS, kita akan membuat SyndicationClient baru.

// src\main.rs
...

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

    Ok(())
}

Fungsi baru adalah konstruktor Rust. Semua objek di peti jendela mengikuti konvensi Rust dan beri nama konstruktornya baru.

Sekarang kita dapat menggunakan SyndicationClient untuk mengambil umpan.
```
// 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(())
}
```
Karena RetrieveFeedAsync adalah API asinkron, kami menggunakan fungsi get pemblokiran untuk menjaga contoh tetap sederhana. Atau, kita dapat menggunakan await operator dalam async fungsi untuk secara kooperatif menunggu hasilnya. Aplikasi yang lebih kompleks dengan antarmuka pengguna grafis akan sering menggunakan async.

Sekarang kita dapat melakukan iterasi atas item yang dihasilkan, dan mari kita cetak judul saja. Anda juga akan melihat beberapa baris kode tambahan di bawah ini untuk mengatur header agen pengguna, karena beberapa umpan RSS memerlukannya.

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

Sekarang mari kita konfirmasi bahwa kita dapat membangun dan menjalankan dengan mengklik Jalankan>Tanpa Debugging (atau menekan Ctrl+F5). Jika Anda melihat pesan tak terduga, pastikan Anda telah berhasil menyelesaikan tutorial Hello, world! (Rust with VS Code).

Ada juga perintah Debug dan Jalankan yang disematkan di dalam editor teks. Atau, dari prompt perintah di rss_reader folder, ketik cargo run, yang akan membangun lalu menjalankan program.

Di panel Terminal Visual Studio Code, Anda dapat melihat bahwa Kargo berhasil mengunduh dan mengkompilasi peti jendela, menyimpan cache hasilnya, dan menggunakannya untuk membuat build berikutnya selesai dalam waktu yang lebih singkat. Kemudian membangun sampel, dan menjalankannya, menampilkan daftar judul posting blog.

Itu sesering itu untuk memprogram Rust untuk Windows. Namun, di bawah tenda, banyak cinta masuk ke dalam membangun alat sehingga Rust dapat mengurai .winmd file berdasarkan ECMA-335 (Infrastruktur Bahasa Umum, atau CLI), dan juga dengan setia menghormati antarmuka biner aplikasi berbasis COM (ABI) pada run-time dengan mempertimbangkan keamanan dan efisiensi.

Memperlihatkan kotak pesan

Kami memang mengatakan bahwa Rust untuk Windows memungkinkan Anda memanggil WINDOWS API apa pun (masa lalu, saat ini, dan masa depan). Jadi di bagian ini kita akan menampilkan beberapa kotak pesan Windows.

Sama seperti yang kami lakukan untuk proyek RSS, pada prompt cd perintah ke folder dengan proyek Rust Anda.

Buat proyek baru bernama message_box, dan buka di Visual Studio Code:

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

Di Visual Studio Code, buka Cargo.toml, dan tambahkan dependensi Windows untuk proyek ini:

 # message_box\Cargo.toml
 ...

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

Sekarang buka file proyek src/main.rs , dan tambahkan use deklarasi dengan namespace baru (seperti yang ditunjukkan di bawah). Dan akhirnya tambahkan kode untuk memanggil fungsi MessageBoxA dan MessageBoxW. Dokumen WINDOWS API terutama ditulis dengan C/C++, jadi berguna untuk membandingkan dokumen API dengan dokumen untuk proyeksi Rust di peti jendela : MessageBoxA (Rust) dan 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);
    }
}
```
Seperti yang Anda lihat, kita harus menggunakan API Win32 ini dalam unsafe blok (lihat Blok tidak aman). Perhatikan juga makro s! dan w! , yang membuat argumen LPCSTR dan LPCWSTR dari literal string Rust UTF-8; sama seperti kami membuat HSTRING dengan makro h! untuk rss_reader. Rust secara asli Unicode dengan string UTF-8, jadi menggunakan API Windows Unicode (W-akhiran) lebar lebih disukai daripada API ANSI (Akhiran A). Ini bisa menjadi penting jika Anda menggunakan teks non-bahasa Inggris dalam kode Anda.

Kali ini saat Anda membuat dan menjalankan, Rust menampilkan dua kotak pesan Windows.

Share via

Tutorial pembaca RSS (Rust untuk Windows dengan Visual Studio Code)

Memperlihatkan kotak pesan

Saran dan Komentar

Sumber Daya Tambahan:

Share via

Tutorial pembaca RSS (Rust untuk Windows dengan Visual Studio Code)

Memperlihatkan kotak pesan

Terkait

Saran dan Komentar

Sumber Daya Tambahan: