# Tauri 高级事件系统 ## 事件基础知识 ### 后端 → 前端事件 **基本事件发射**：使用 tauri::Window; #[tauri::命令] 异步 fn start_download( 网址：字符串，窗户：窗户， ) -> 结果<(), 字符串> { window.emit("下载已开始", url) .map_err(|e| e.to_string())?; // 执行下载... window.emit("下载完成", "成功") .map_err(|e| e.to_string()) } **前端监听器**：从'@tauri-apps/api/event'导入{listen, UnlistenFn}； const unlisten = wait Listen('下载已开始', (event) => { console.log('下载开始：', event.payload); }); // 完成后清理不听(); ## 结构化事件负载 ### 使用 Serde 键入事件 **后端**：使用 serde::序列化； #[派生（序列化，克隆）] 结构进度事件{ 当前：使用，总计：使用，百分比：f64，消息：字符串， speed_mbps：选项， } #[tauri::命令] 异步 fn download_file( 网址：字符串，窗户：窗户， ) -> 结果<(), 字符串> { 让total_size = get_file_size(&url).await?; 对于 0..total_size 中的块 { // 下载块... 让进度 = ProgressEvent { 当前：块，总计：总大小，百分比：（块为 f64 / 总大小为 f64）* 100.0，消息：格式！（“正在下载... {}/{}”，块，total_size）， speed_mbps：一些（calculate_speed（））， }; window.emit("下载进度", 进度) .map_err(|e| e.to_string())?; } 好的(()) } **前端**：接口进度事件{ 当前：数量；总计：数量；百分比：数量；消息：字符串； speed_mbps？：数字； } const unlisten =等待listen('下载进度', (event) => { const { 当前、总计、百分比、消息、speed_mbps } = event.payload; 更新进度条（百分比）；更新状态（消息）；如果（速度_mbps）{ 更新速度（speed_mbps）； } }); ### 复杂事件有效负载 #[派生（序列化，克隆）] #[serde(标签 = "类型", 内容 = "数据")] 枚举应用程序事件{ UserLoggedIn { user_id: 字符串, 用户名: 字符串 }, UserLoggedOut { user_id: 字符串 }, DataSynced { items_count: usize, 时间戳: String }, ErrorOccurred { 代码：字符串，消息：字符串，可恢复：bool }， } #[tauri::命令] 异步 fn Perform_login( 用户名：字符串，密码：字符串，窗户：窗户， ) -> 结果 <字符串, 字符串> { 让用户 = 验证（&用户名，&密码）.await？； // 发出结构化事件 window.emit("app-event", AppEvent::UserLoggedIn { user_id: user.id.clone(), 用户名：user.username.clone(), }).map_err(|e| e.to_string())?; 好的(用户.id) } **前端**：输入应用程序事件 = | { 类型：'用户登录'；数据：{ user_id：字符串；用户名：字符串 } } | { 类型：'UserLoggedOut';数据：{ user_id：字符串 } } | { 类型： '数据同步';数据：{ items_count：数量；时间戳：字符串 } } | { type: '发生错误';数据：{ 代码：字符串；消息：字符串；可恢复：布尔值 } }; 听 ('应用程序事件', (事件) => { const appEvent = event.payload; 开关（appEvent.type）{ 案例“用户登录”： handleLogin(appEvent.data.user_id, appEvent.data.username); 打破；案例“用户注销”： handleLogout(appEvent.data.user_id); 打破；案例“数据同步”： showSyncSuccess(appEvent.data.items_count); 打破；案例“发生错误”：处理错误（appEvent.data）；打破； } }); ## 流数据模式 ### 实时数据流 #[tauri::命令] 异步 fn 流传感器数据（传感器_id：字符串，窗户：窗户， ) -> 结果<(), 字符串> { 让 mut 间隔 = tokio::time::interval(Duration::from_millis(100)); 对于 _ 在 0..100 { 间隔.tick().await; 让read = read_sensor(&sensor_id).await?; window.emit("传感器读数", 读数) .map_err(|e| e.to_string())?; } window.emit（“传感器流结束”，sensor_id） .map_err(|e| e.to_string()) } **使用 React 进行前端**：从 'react' 导入 { useEffect, useState }; 从'@tauri-apps/api/event'导入{listen}；接口传感器读取{ 值：数字；时间戳：数字；单位：字符串； } 函数传感器监视器() { const [读数，setReadings] = useState([]); 使用效果（（）=> { 让不听：UnlistenFn |未定义； Listen('传感器读数', (事件) => { setReadings(prev => [...prev.slice(-99), event.payload]); }).then(fn => 不听 = fn); return () => 不听？.(); }, []); 返回（

{readings.map((r, i) => (

{r.value} {r.unit}

))}

）； } ### 缓冲流 #[tauri::命令] 异步 fn Stream_logs( 日志文件：字符串，窗户：窗户， ) -> 结果<(), 字符串> { 使用 tokio::io::{AsyncBufReadExt，BufReader}；使用 tokio::fs::File；让文件 = File::open(log_file).await .map_err(|e| e.to_string())?; 让读者= BufReader::new(文件); 让 mutlines = reader.lines(); 让 mut buffer = Vec::new(); while let Some(line) =lines.next_line().await .map_err(|e| e.to_string())？ { 缓冲区.push(行); // 批量发送 10 行如果 buffer.len() >= 10 { window.emit("log-batch", buffer.clone()) .map_err(|e| e.to_string())?; 缓冲区.clear(); } } // 发送剩余行 if !buffer.is_empty() { window.emit(“日志批次”，缓冲区) .map_err(|e| e.to_string())?; } 好的(()) } ## 多窗口通讯 ### 广播到所有窗口使用 tauri::{AppHandle, Manager}; #[tauri::命令] 异步 fn 广播消息（消息：字符串，应用程序：应用程序句柄， ) -> 结果<(), 字符串> { // 发送到所有窗口 app.emit_all("广播", 消息) .map_err(|e| e.to_string()) } ### 有针对性的窗口消息传递 #[tauri::命令] 异步 fn send_to_window( 目标窗口：字符串，消息：字符串，应用程序：应用程序句柄， ) -> 结果<(), 字符串> { // 获取特定窗口 if let Some(window) = app.get_window(&target_window) { window.emit("私人消息", 消息) .map_err(|e| e.to_string())?; 好的(()) } 否则{ Err(format!("未找到窗口'{}'", target_window)) } } ### 通过后端进行窗口到窗口 **窗口 A（发送者）** : 从'@tauri-apps/api/core'导入{调用}；异步函数 sendToSettings(data: any) { 等待调用（'relay_to_settings'，{数据}）； } **后端中继** : #[tauri::命令] 异步 fn relay_to_settings( 数据： serde_json::值，应用程序：应用程序句柄， ) -> 结果<(), 字符串> { if let Some(settings_window) = app.get_window("settings") { settings_window.emit（“数据更新”，数据） .map_err(|e| e.to_string())?; } 好的(()) } **窗口 B（接收器 - 设置）**：从'@tauri-apps/api/event'导入{listen}；使用效果（（）=> { 让不听：UnlistenFn |未定义；听（'数据更新'，（事件）=> { console.log('从主窗口接收：', event.payload); updateSettings(event.payload); }).then(fn => 不听 = fn); return () => 不听？.(); }, []); ## 前端 → 后端事件 ### 自定义前端事件从'@tauri-apps/api/event'导入{emit}； // 前端发出事件等待发出（'用户操作'，{ 动作：'按钮单击'， Button_id: '保存按钮', 时间戳：Date.now() }); **后端监听器** : 使用 tauri::{Manager, Listener}; fn 主() { 金牛座::生成器::默认() .setup(|应用程序| { 让 app_handle = app.handle(); // 监听前端事件 app_handle.listen_global("用户操作", 移动|事件| { if let Some(payload) = event.payload() { println!("用户操作：{}"，有效负载); // 处理事件... } }); 好的(()) }) .run(tauri::generate_context!()) .expect("运行 tauri 应用程序时出错"); } ## 高级听众管理 ### 事件的 React Hook 从 'react' 导入 { useEffect, useState }; 从'@tauri-apps/api/event'导入{listen, UnlistenFn}；函数 useEvent(eventName: string): T |空{ const [有效负载，setPayload] = useState(空); 使用效果（（）=> { 让不听：UnlistenFn |未定义；监听(事件名称, (事件) => { setPayload(事件.payload); }).then(fn => 不听 = fn); return () => 不听？.(); }, [事件名称]); 返回有效负载； } // 用法函数进度显示() { const Progress = useEvent('下载进度'); if (!progress) 返回 null; 返回（

进度：{progress.percentage.toFixed(2)}%

）； } ### 事件队列模式从'@tauri-apps/api/event'导入{listen}；类 EventQueue { 私有队列：T[] = []；私人不听？: UnlistenFn; 异步开始（事件名称：字符串）{ this.unlisten = 等待监听(事件名称, (事件) => { this.queue.push(event.payload); }); } 出队（）：T |未定义{ 返回 this.queue.shift(); } 清除（）{ this.queue = []; } 停止（）{ this.unlisten?.(); } 获取长度（）{ 返回 this.queue.length; } } // 用法 const ProgressQueue = new EventQueue(); 等待progressQueue.start('下载进度'); // 定期处理队列设置间隔（（）=> { while (progressQueue.length > 0) { const event = ProgressQueue.dequeue(); 处理进度（事件）； } }, 100); ### 一次性活动从'@tauri-apps/api/event'导入{一次}； // 只监听一次事件等待一次('初始化完成', (事件) => { console.log('应用程序初始化：', event.payload); 启动应用程序（）； }); ## 事件中的错误处理 ### 安全事件发射 async fn emmit_safe(窗口: &Window, 事件: &str, 负载: impl Serialize) -> Result<(), String> { window.emit（事件，有效负载） .map_err(|e| { eprintln!("未能发出事件 '{}': {}", event, e); e.to_string() }) } #[tauri::命令] 异步 fn process_with_events( 窗户：窗户， ) -> 结果<(), 字符串> { emit_safe(&window, "处理开始", "正在开始...") .等待？ // 处理... emit_safe(&window, "处理完成", "完成！") .等待？好的(()) } ## 性能考虑因素 ### 限制事件使用 std::time::{持续时间，即时}； #[tauri::命令] 异步 fn 高频率更新（窗户：窗户， ) -> 结果<(), 字符串> { 让 mut last_emit = Instant::now(); 让throttle_duration = Duration::from_millis(100); 对于我在 0..10000 { 让值=计算值（i）； // 每 100 毫秒才发出一次如果last_emit.elapsed()>=throttle_duration{ window.emit("更新", 值) .map_err(|e| e.to_string())?; last_emit = Instant::now(); } } 好的(()) } ### 批处理事件 #[tauri::命令] 异步 fn 批量更新（窗户：窗户， ) -> 结果<(), 字符串> { 让 mut 批 = Vec::new(); 对于 process_items() 中的项目 { 批量推送（项目）； // 批量发射 50 个如果batch.len() >= 50 { window.emit("批量更新",batch.clone()) .map_err(|e| e.to_string())?; 批处理.clear(); } } // 发出剩余的项目如果！batch.is_empty() { window.emit("批量更新", 批量) .map_err(|e| e.to_string())?; } 好的(()) } ## 最佳实践 1. **始终清理监听器** \- 使用`unlisten()`来防止内存泄漏 2. **类型事件负载** \- 定义类型安全的接口 3. **使用结构化事件** \- 多种事件类型的标记联合 4. **限制高频事件** \-防止前端不堪重负 5. **尽可能批量** \- 减少序列化开销 6. **优雅地处理错误** \- 记录失败的排放，不要崩溃 7. **对一次性事件使用once() ** \- 初始化、完成信号 8. **命名空间事件名称** \- 使用“download:”、“user:”、“system:”等前缀 ## 常见陷阱 ❌ **忘记不听**： // 错误 - 内存泄漏函数组件() { 听（'我的事件'，处理程序）； // 从未清理过！ } // 正确函数组件() { 使用效果（（）=> { 让不听：UnlistenFn |未定义；听（'我的事件'，处理程序）。然后（fn => unlisten = fn）; return () => 不听？.(); }, []); } ❌ **不处理序列化错误**： // 错误 - 结构无法序列化 #[derive(Clone)] // 缺少序列化！结构事件{} window.emit("事件", 事件{}); // 运行时错误！ // 正确 #[派生（序列化，克隆）] 结构事件{} ❌ **发射过于频繁**： // 错误 - 快速连续发生 10000 个事件对于我在 0..10000 { window.emit("更新", i); // 压倒性的！ } // 正确 - 节流或批量 ## 总结 * **事件是异步的** \- 后端 → 前端通信 * **始终输入有效负载** \- 使用 serde::Serialize + TypeScript 接口 * **清理监听器** \- 在清理中调用 `unlisten()` * **节流/批量** \- 高频事件需要速率限制 * **使用结构化有效负载** \- 多种事件类型的标记联合 * **窗口定位** \- `emit()` 用于特定，`emit_all()` 用于广播 * **前端事件** \- 从前端使用 `emit()`，在后端设置中监听

金牛座事件系统

包含技能