Tutorial del lector RSS (Rust para Windows con VS Code)

En el tema anterior se presentó Rust para Windows y crate windows.

Ahora vamos a probar Rust para Windows escribiendo una aplicación de consola sencilla que descarga los títulos de las publicaciones de blog de un canal de sindicación realmente simple (RSS).

Inicie un símbolo del sistema (cmd.exe) y cd en la carpeta donde quiera conservar los proyectos de Rust.
Con Cargo, cree un nuevo proyecto de Rust denominado rss_reader y aplique cd en la carpeta recién creada.
```
> cargo new rss_reader
>     Created binary (application) `rss_reader` package
> cd rss_reader
```
A continuación, abra el proyecto de rss_reader en VS Code.
```
code .
```
Ahora vamos a implementar el proyecto rss_reader principal. En primer lugar, abra el Cargo.toml archivo en la raíz del proyecto. Un Cargo.toml archivo es un archivo de texto que describe un proyecto de Rust, incluidas las dependencias que tiene.

Agregue una dependencia en el crate windows, como se muestra en la lista siguiente. El crate windows es grande. Para mantener los tiempos de compilación rápidos, seleccionaremos solo las Foundation_Collections características y Web_Syndication que necesitamos para este código.
```
# Cargo.toml
...

[dependencies.windows] 
version = "0.62.0"
features = [
    "Foundation_Collections",
    "Web_Syndication",
]
```
Note

El windows crate se actualiza con frecuencia. Compruebe crates.io/crates/windows para obtener la versión más reciente y actualice en consecuencia.
A continuación, abra el archivo de código fuente del proyecto rss_readersrc/main.rs. Allí encontrará el código predeterminado "Hello, world!" de Cargo. Agregue la siguiente instrucción use al principio de main.rs:
```
// src\main.rs
use windows::{
    core::*,
    Foundation::Uri,
    Web::Syndication::SyndicationClient
};

fn main() {
    println!("Hello, world!");
}
```
La declaración use acorta la ruta de acceso a los tipos que se van a usar. Allí está el tipo Uri mencionado anteriormente.
Para crear un nuevo Uri, reemplace la función main predeterminada de Cargo por esta:
```
// src\main.rs
...

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

    Ok(())
}
```
Observe que el tipo de valor devuelto de la función main es un resultado, de windows::core::. Esto hará que las cosas sean más fáciles, ya que es habitual tratar los errores de las API del sistema operativo (SO). windows::core::Result nos ayuda con la propagación de errores y con una administración concisa de los mismos.

Puede ver el operador de signo de interrogación al final de la línea de código. Para ahorrar en escritura, hacemos esto para usar la propagación de errores y la lógica de cortocircuito de Rust. Esto significa que no es necesario realizar un montón de control manual de errores para este ejemplo sencillo. Para obtener más información sobre esta característica de Rust, consulta el operador "?" para facilitar la gestión de errores.

Observe también la macro h! del crate windows. Se usa para construir una referencia a HSTRING a partir de un literal de cadena de Rust. La API de WinRT utiliza extensamente HSTRING para los valores de cadena.
Para descargar la fuente RSS, crearemos un nuevo 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 nueva función es un constructor de Rust. Todos los objetos del crate windows siguen la convención de Rust y asignan un nombre a sus constructores nuevos.
Ahora podemos usar el SyndicationClient para recuperar el 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(())
}
```
Dado que RetrieveFeedAsync es una API asincrónica, usamos la función get de bloqueo para simplificar el ejemplo. Como alternativa, podríamos usar el await operador dentro de una async función para esperar de forma cooperativa los resultados. Una aplicación más compleja con una interfaz gráfica de usuario usará asynccon frecuencia .

Ahora podemos recorrer en iteración los elementos resultantes e imprimir solo los títulos. También verá algunas líneas de código adicionales a continuación para establecer un encabezado de agente de usuario, ya que algunas fuentes RSS requieren eso.

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

Ahora comprobemos que podemos compilar y ejecutar haciendo clic en Ejecutar>Ejecutar sin depurar (o pulsando Ctrl+F5). Si ve algún mensaje inesperado, asegúrese de que ha completado correctamente el tutorial 'Hola, mundo!' (Rust con VS Code) .

También hay comandos Debug y Run insertados en el editor de texto. Como alternativa, desde un símbolo del sistema en la carpeta rss_reader, escriba cargo run, que compilará y, a continuación, ejecutará el programa.

En el panel Terminal de VS Code, puede ver que Cargo descarga y compila correctamente el crate windows, almacena en caché los resultados y los usa para que las compilaciones posteriores se completen en menos tiempo. A continuación, compila el ejemplo y lo ejecuta, mostrando una lista de títulos de entrada de blog.

Eso es tan sencillo como es programar Rust para Windows. Sin embargo, aunque no resulte evidente, se ha puesto gran empeño para crear las herramientas para que Rust pueda analizar archivos .winmd basados en ECMA-335 (Common Language Infrastructure o CLI) y, a la vez, respetar de manera fiel la interfaz binaria de aplicaciones (ABI) basada en COM en tiempo de ejecución, teniendo en cuenta tanto la seguridad como la eficacia.

Mostrar un cuadro de mensaje

Hemos dicho que Rust para Windows te permite llamar a cualquier API de Windows (pasada, presente y futura). Por lo tanto, en esta sección se mostrarán un par de cuadros de mensaje de Windows.

Al igual que hicimos para el proyecto RSS, en el símbolo del sistema cd a la carpeta con los proyectos de Rust.

Cree un proyecto denominado message_box y ábralo en VS Code:

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

En VS Code, abra Cargo.tomly agregue las dependencias de Windows para este proyecto:

 # message_box\Cargo.toml
 ...

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

Abra el archivo del proyecto src/main.rs y agregue las declaraciones use con los nuevos espacios de nombres, tal como se muestra a continuación. Y, por último, agregue código para llamar a las funciones MessageBoxA y MessageBoxW. Los documentos de la API de Windows se escriben principalmente teniendo en cuenta C/C++, por lo que resulta útil comparar los documentos de API con los documentos de las proyecciones de Rust en la caja de windows : MessageBoxA (Rust) y 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);
    }
}
```
Como puede ver, debemos usar estas API de Win32 en un unsafe bloque (consulte Bloques no seguros). ¡Anote también los macros s! y w!, que crean argumentos LPCSTR y LPCWSTR a partir de literales de cadena UTF-8 de Rust; de la misma manera que creamos un HSTRING con el macro h! para rss_reader. Rust es Unicode de forma nativa con cadenas UTF-8, por lo que se prefiere usar las API de Windows Unicode (W-sufijo) anchos sobre las API de ANSI (sufijo A). Esto puede ser importante si usa texto no en inglés en el código.

Esta vez, cuando se compila y se ejecuta, Rust muestra dos cuadros de mensaje de Windows.

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2026-07-10

Tutorial del lector RSS (Rust para Windows con VS Code)

Mostrar un cuadro de mensaje

Relacionado

Comentarios

Recursos adicionales