以下是关于windows-win库的完整示例代码，基于您提供的内容整理：

use windows_win::{
    raw_window::{
        Window,
        WindowBuilder,
        WindowHandler,
        Message,
        WindowEvent
    },
    message::{
        WM_CLOSE,
        WM_DESTROY
    }
};

// 自定义窗口处理程序
struct MyWindowHandler;

impl WindowHandler for MyWindowHandler {
    // 处理窗口消息
    fn handle_message(&mut self, window: &Window, message: Message) -> Option<isize> {
        match message {
            // 处理关闭消息
            Message::Raw(WM_CLOSE) => {
                println!("Window closing");
                window.destroy();
                Some(0)
            },
            // 处理销毁消息
            Message::Raw(WM_DESTROY) => {
                println!("Window destroyed");
                // 退出消息循环
                window.post_quit_message(0);
                Some(0)
            },
            _ => None
        }
    }

    // 处理窗口事件
    fn handle_event(&mut self, _window: &Window, _event: WindowEvent) {}
}

fn main() {
    // 创建窗口构建器
    let mut builder = WindowBuilder::new();
    
    // 设置窗口属性
    builder
        .set_title("My Rust Window")
        .set_size(400, 300)
        .set_position(100, 100);
    
    // 创建窗口并运行消息循环
    match builder.build::<MyWindowHandler>() {
        Ok(window) => {
            println!("Window created successfully");
            window.run_message_loop();
        },
        Err(e) => {
            eprintln!("Failed to create window: {:?}", e);
        }
    }
}

代码说明

首先导入必要的模块和类型
定义自定义的WindowHandler实现来处理窗口消息和事件
在main函数中：
- 创建WindowBuilder来配置窗口
- 设置窗口标题、大小和位置
- 构建窗口并运行消息循环

这个示例创建了一个简单的Windows窗口，可以处理关闭和销毁消息。当用户点击关闭按钮时，窗口会正确关闭并退出应用程序。

bupafengyu 1楼

Rust Windows系统API绑定库windows-rs使用指南

介绍

windows-rs是微软官方提供的Rust语言Windows API绑定库，它允许Rust开发者直接调用Windows系统API，实现原生Windows平台功能开发与系统交互。这个库提供了对Win32、COM和WinRT API的全面支持。

安装

在Cargo.toml中添加依赖：

[dependencies]
windows = { version = "0.51", features = [
    "Win32_Foundation",
    "Win32_System_Threading",
    "Win32_UI_WindowsAndMessaging",
] }

注意需要根据你要使用的API选择相应的feature。

基本使用方法

1. 创建窗口示例

use windows::{
    Win32::UI::WindowsAndMessaging::*,
    Win32::Foundation::*,
};

fn main() -> windows::core::Result<()> {
    unsafe {
        let instance = GetModuleHandleA(None)?;
        let window_class = s!("SampleWindowClass");

        let wc = WNDCLASSA {
            hInstance: instance,
            lpszClassName: window_class,
            lpfnWndProc: Some(wndproc),
            ..Default::default()
        };

        RegisterClassA(&wc);

        CreateWindowExA(
            WINDOW_EX_STYLE::default(),
            window_class,
            s!("Rust Windows Example"),
            WS_OVERLAPPEDWINDOW,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            None,
            None,
            instance,
            None,
        );

        let mut message = MSG::default();
        while GetMessageA(&mut message, None, 0, 0).into() {
            TranslateMessage(&message);
            DispatchMessageA(&message);
        }

        Ok(())
    }
}

extern "system" fn wndproc(
    hwnd: HWND,
    msg: u32,
    wparam: WPARAM,
    lparam: LPARAM,
) -> LRESULT {
    unsafe {
        match msg {
            WM_DESTROY => {
                PostQuitMessage(0);
                LRESULT(0)
            }
            _ => DefWindowProcA(hwnd, msg, wparam, lparam),
        }
    }
}

2. 文件操作示例

use windows::{
    Win32::Storage::FileSystem::*,
    Win32::Foundation::*,
};

fn read_file() -> windows::core::Result<()> {
    unsafe {
        let file = CreateFileA(
            s!("C:\\example.txt"),
            GENERIC_READ,
            FILE_SHARE_READ,
            None,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,
            None,
        )?;

        let mut buffer = [0u8; 1024];
        let mut bytes read = 0;

        ReadFile(
            file,
            buffer.as_mut_ptr() as _,
            buffer.len() as u32,
            Some(&mut bytes_read),
            None,
        )?;

        CloseHandle(file)?;

        println!("Read {} bytes: {:?}", bytes_read, &buffer[..bytes_read as usize]);

        Ok(())
    }
}

3. 进程和线程管理

use windows::{
    Win32::System::Threading::*,
    Win32::Foundation::*,
};

fn create_process() -> windows::core::Result<()> {
    unsafe {
        let mut startup_info = STARTUPINFOA::default();
        let mut process_info = PROCESS_INFORMATION::default();

        CreateProcessA(
            None,
            s!("notepad.exe"),
            None,
            None,
            false,
            CREATE_NEW_CONSOLE,
            None,
            None,
            &mut startup_info,
            &mut process_info,
        )?;

        println!("Process created with ID: {}", process_info.dwProcessId);

        WaitForSingleObject(process_info.hProcess, 5000);
        CloseHandle(process_info.hProcess);
        CloseHandle(process_info.hThread);

        Ok(())
    }
}

高级功能

COM组件调用

use windows::{
    Win32::System::Com::*,
    Win32::System::Ole::*,
    Win32::UI::Shell::*,
};

fn com_example() -> windows::core::Result<()> {
    unsafe {
        CoInitializeEx(None, COINIT_MULTITHREADED)?;

        let shell: ISShellLinkW = CoCreateInstance(
            &ShellLink,
            None,
            CLSCTX_INPROC_SERVER,
        )?;

        // 使用COM接口...
        
        CoUninitialize();
        Ok(())
    }
}

最佳实践

安全处理：尽可能使用unsafe块隔离Windows API调用
错误处理：使用?操作符处理返回的Result
资源管理：确保及时释放句柄和资源
特征选择：只启用你需要的模块以减少编译时间和二进制大小

注意事项

Windows API调用大多标记为unsafe，需要特别注意内存安全
不同Windows版本API可用性不同，需要做好兼容性处理
某些API需要特定的权限才能调用成功

windows-rs库提供了全面的Windows API访问能力，使得Rust开发者能够在Windows平台上实现系统级功能开发。

Rust Windows系统API绑定库windows-win的使用，实现原生Windows平台功能开发与系统交互