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

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 windows crate, seperti yang ditunjukkan pada daftar di bawah ini. Peti jendela berukuran besar. Untuk menjaga waktu build tetap cepat, kita hanya akan memilih fitur Foundation_Collections 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. Di sana Anda akan menemukan kode default Kargo "Halo, dunia!". Tambahkan berikut menggunakan pernyataan ke awal main.rs:
```
// src\main.rs
use windows::{
    core::*,
    Foundation::Uri,
    Web::Syndication::SyndicationClient
};

fn main() {
    println!("Hello, world!");
}
```
Deklarasi oleh memperpendek jalur ke tipe-tipe 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 tipe pengembalian dari fungsi utama adalah Result, dari windows::core::. Itu akan membuat segalanya lebih mudah, karena umumnya sering muncul 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 Windows crate. Kami menggunakan itu 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 jendela peti mengikuti konvensi Rust dan konstruktornya diberi nama 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 pemblokiran get 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 yang tidak terduga, pastikan Anda telah berhasil menyelesaikan Halo, dunia! tutorial (Rust dengan Visual Studio 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 VS Code, Anda dapat melihat bahwa Cargo berhasil mengunduh dan mengompilasi crate windows , menyimpan hasilnya dalam cache, dan menggunakannya untuk menyelesaikan build berikutnya dalam waktu yang lebih singkat. Kemudian membangun sampel, dan menjalankannya, menampilkan daftar judul posting blog.

Itu semudah itu untuk memprogram Rust untuk Windows. Namun, di balik layar, banyak usaha dan perhatian dicurahkan dalam membangun alat sehingga Rust dapat mengurai sintaks file .winmd berdasarkan ECMA-335 (Common Language Infrastructure, atau CLI), dan juga dengan tepat mengikuti 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 perintah cd sampai ke folder 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++ dalam pikiran, jadi berguna untuk membandingkan dokumen API dengan dokumen untuk proyeksi Rust di jendela peti: 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 ! dan w! makro, yang membuat LPCSTR dan argumen LPCWSTR dari literal string Rust UTF-8; sama seperti kami membuat HSTRING dengan h! makro untuk rss_reader. Rust secara asli mendukung Unicode dengan string UTF-8, jadi sering menggunakan wide Unicode API Windows (akhiran W) lebih disukai daripada ANSI API (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.

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2025-05-03

Bagikan melalui

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

Memperlihatkan kotak pesan

Terkait

Saran dan Komentar

Sumber Daya Tambahan: