MBProgressHUD实战：Swift项目集成与问题解决-优快云博客

MBProgressHUD实战：Swift项目集成与问题解决

【免费下载链接】MBProgressHUD MBProgressHUD + Customizations 项目地址: https://gitcode.com/gh_mirrors/mb/MBProgressHUD

本文详细介绍了在Swift项目中集成Objective-C编写的MBProgressHUD库的完整流程和最佳实践。从基础的桥接配置、多线程环境下的正确使用方法，到常见问题排查与性能优化技巧，最后通过实际项目案例展示如何封装统一的HUD管理类。文章涵盖了网络请求集成、文件上传下载进度显示、复杂业务流程状态管理等多个实战场景，帮助开发者避免常见的陷阱并提升应用的用户体验。

Swift项目中Objective-C桥接配置

在Swift项目中集成Objective-C编写的MBProgressHUD库时，桥接配置是关键的第一步。虽然MBProgressHUD提供了Swift Package Manager支持，但在某些情况下，开发者仍然需要手动配置桥接文件来确保Objective-C代码能够被Swift正确识别和使用。

桥接头文件创建与配置

创建桥接头文件是Swift调用Objective-C代码的核心步骤。以下是详细的配置流程：

mermaid

首先，在Xcode项目中创建桥接头文件：

新建头文件：在Xcode中右键点击项目，选择"New File" → "Header File"，命名为项目名-Bridging-Header.h
自动配置：Xcode通常会提示是否配置桥接头文件，选择"Yes"会自动在Build Settings中设置
手动配置：如果自动配置失败，需要手动设置：
- 选择项目Target → Build Settings
- 搜索"Objective-C Bridging Header"
- 设置路径为：$(SRCROOT)/项目名/项目名-Bridging-Header.h

桥接头文件内容配置

在创建的桥接头文件中，需要导入MBProgressHUD的头文件：

// 项目名-Bridging-Header.h
#ifndef ProjectName_Bridging_Header_h
#define ProjectName_Bridging_Header_h

#import "MBProgressHUD.h"

#endif /* ProjectName_Bridging_Header_h */

常见配置问题与解决方案

在实际配置过程中，可能会遇到各种问题，以下是常见问题及解决方法：

问题类型	错误信息	解决方案
头文件找不到	`'MBProgressHUD.h' file not found`	确保头文件路径正确，或使用`#import <MBProgressHUD/MBProgressHUD.h>`
桥接文件未配置	`Cannot find interface declaration`	检查Build Settings中的桥接头文件路径配置
框架链接错误	`Undefined symbols for architecture`	确保在General → Frameworks中链接了必要的框架

Swift中使用MBProgressHUD的代码示例

配置完成后，就可以在Swift中直接使用MBProgressHUD了：

import UIKit

class ViewController: UIViewController {
    
    func showProgressHUD() {
        // 显示加载指示器
        let hud = MBProgressHUD.showAdded(to: self.view, animated: true)
        hud.label.text = "加载中..."
        hud.mode = .indeterminate
        
        // 模拟耗时操作
        DispatchQueue.global().async {
            // 执行后台任务
            sleep(2)
            
            DispatchQueue.main.async {
                // 隐藏HUD
                MBProgressHUD.hide(for: self.view, animated: true)
            }
        }
    }
    
    func showSuccessHUD() {
        // 显示成功提示
        let hud = MBProgressHUD.showAdded(to: self.view, animated: true)
        hud.mode = .customView
        hud.customView = UIImageView(image: UIImage(systemName: "checkmark"))
        hud.label.text = "操作成功"
        hud.hide(animated: true, afterDelay: 2.0)
    }
}

高级配置技巧

对于复杂的项目结构，可能需要更精细的配置：

模块化配置：如果使用CocoaPods或Carthage，通常不需要手动桥接，依赖管理器会自动处理

Swift Package Manager：推荐使用SPM集成，无需桥接配置：

// Package.swift
dependencies: [
    .package(url: "https://github.com/jdg/MBProgressHUD.git", from: "1.2.0")
]

条件编译：针对不同集成方式的条件编译

#if canImport(MBProgressHUD)
import MBProgressHUD
#else
// 手动桥接的代码
#endif

调试与验证

配置完成后，可以通过以下方式验证桥接是否成功：

编译检查：尝试编译项目，确保没有桥接相关的错误
代码补全：在Swift文件中输入MBProgress，查看是否有自动补全提示
运行时验证：运行应用并测试HUD功能是否正常工作

正确的桥接配置是Swift项目成功集成MBProgressHUD的基础，遵循上述步骤可以避免大多数常见的配置问题，确保Objective-C代码在Swift环境中无缝工作。

多线程环境下的正确使用方法

在iOS开发中，多线程环境下的UI操作是一个常见且容易出错的问题。MBProgressHUD作为一个UI组件，必须在主线程上进行所有操作，否则会导致不可预知的行为甚至崩溃。本节将深入探讨在多线程环境中正确使用MBProgressHUD的最佳实践。

核心原则：主线程唯一性

MBProgressHUD的所有UI操作都必须在主线程上执行，这是iOS开发的基本原则。框架内部通过断言来确保这一点：

#define MBMainThreadAssert() NSAssert([NSThread isMainThread], @"MBProgressHUD needs to be accessed on the main thread.");

这个断言会在调试模式下检查当前线程，如果不是主线程就会触发断言失败。

标准的多线程使用模式

最常见的正确使用模式是使用Grand Central Dispatch (GCD)来管理线程：

// Swift示例
let hud = MBProgressHUD.showAdded(to: self.view, animated: true)
hud.label.text = "正在处理..."

DispatchQueue.global(qos: .userInitiated).async {
    // 在后台线程执行耗时操作
    self.performHeavyTask()
    
    DispatchQueue.main.async {
        // 回到主线程隐藏HUD
        hud.hide(animated: true)
    }
}

对应的Objective-C代码：

// Objective-C示例
MBProgressHUD *hud = [MBProgressHUD showHUDAddedTo:self.view animated:YES];
hud.label.text = @"正在处理...";

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
    // 在后台线程执行耗时操作
    [self performHeavyTask];
    
    dispatch_async(dispatch_get_main_queue(), ^{
        // 回到主线程隐藏HUD
        [hud hideAnimated:YES];
    });
});

进度更新的线程安全处理

当需要在后台线程更新进度时，必须通过主线程来更新HUD的进度属性：

// Swift进度更新示例
func updateProgressInBackground() {
    let hud = MBProgressHUD.showAdded(to: self.view, animated: true)
    hud.mode = .annularDeterminate
    hud.label.text = "处理中..."
    
    DispatchQueue.global(qos: .userInitiated).async {
        for i in 0...100 {
            // 模拟耗时操作
            Thread.sleep(forTimeInterval: 0.05)
            
            DispatchQueue.main.async {
                // 在主线程更新进度
                hud.progress = Float(i) / 100.0
            }
        }
        
        DispatchQueue.main.async {
            hud.hide(animated: true)
        }
    }
}

使用NSProgress对象进行进度管理

MBProgressHUD支持与NSProgress对象集成，这提供了更线程安全的进度管理方式：

// Swift NSProgress示例
func useNSProgressWithHUD() {
    let hud = MBProgressHUD.showAdded(to: self.view, animated: true)
    hud.mode = .determinate
    hud.label.text = "下载中..."
    
    let progress = Progress(totalUnitCount: 100)
    hud.progressObject = progress
    
    DispatchQueue.global(qos: .userInitiated).async {
        for i in 0...100 {
            Thread.sleep(forTimeInterval: 0.03)
            progress.completedUnitCount = Int64(i)
        }
        
        DispatchQueue.main.async {
            hud.hide(animated: true)
        }
    }
}

网络请求中的HUD使用

在网络请求场景中，正确的HUD使用模式尤为重要：

// Swift网络请求示例
func fetchDataWithHUD() {
    let hud = MBProgressHUD.showAdded(to: self.view, animated: true)
    hud.label.text = "加载数据..."
    
    URLSession.shared.dataTask(with: URL(string: "https://api.example.com/data")!) { data, response, error in
        // 网络请求在后台线程完成
        
        DispatchQueue.main.async {
            // 回到主线程处理结果和更新UI
            if let error = error {
                hud.mode = .text
                hud.label.text = "加载失败"
                hud.hide(animated: true, afterDelay: 2.0)
            } else if let data = data {
                self.processData(data)
                hud.hide(animated: true)
            }
        }
    }.resume()
}

避免的常见错误模式

以下是一些在多线程环境中使用MBProgressHUD时需要避免的错误模式：

错误：在后台线程操作HUD

// ❌ 错误示例 - 在后台线程操作HUD
DispatchQueue.global().async {
    let hud = MBProgressHUD.showAdded(to: self.view, animated: true) // 崩溃！
}

错误：忘记回到主线程

// ❌ 错误示例 - 忘记回到主线程隐藏HUD
DispatchQueue.global().async {
    // 执行任务...
    hud.hide(animated: true) // 可能崩溃！
}

错误：频繁的跨线程更新

// ❌ 错误示例 - 过于频繁的跨线程调用
DispatchQueue.global().async {
    for _ in 0...1000 {
        DispatchQueue.main.async {
            hud.progress += 0.001 // 性能问题！
        }
    }
}

线程安全的HUD管理工具类

为了简化多线程环境下的HUD使用，可以创建一个工具类：

// HUD管理工具类
class HUDManager {
    static func showLoading(on view: UIView, message: String = "加载中...") -> MBProgressHUD {
        var hud: MBProgressHUD!
        DispatchQueue.main.async {
            hud = MBProgressHUD.showAdded(to: view, animated: true)
            hud.label.text = message
        }
        return hud
    }
    
    static func hideLoading(_ hud: MBProgressHUD) {
        DispatchQueue.main.async {
            hud.hide(animated: true)
        }
    }
    
    static func showSuccess(on view: UIView, message: String, duration: TimeInterval = 2.0) {
        DispatchQueue.main.async {
            let hud = MBProgressHUD.showAdded(to: view, animated: true)
            hud.mode = .customView
            hud.customView = UIImageView(image: UIImage(systemName: "checkmark.circle.fill"))
            hud.label.text = message
            hud.hide(animated: true, afterDelay: duration)
        }
    }
}

性能优化建议

在多线程环境中使用HUD时，考虑以下性能优化：

批量更新：避免过于频繁的进度更新，可以累积多次更新后一次性提交
使用合适的QoS：根据任务重要性选择合适的服务质量等级
避免内存泄漏：确保在任务完成后及时隐藏和释放HUD
重用HUD实例：在频繁显示/隐藏的场景中考虑重用HUD实例

mermaid

通过遵循这些最佳实践，你可以在多线程环境中安全、高效地使用MBProgressHUD，为用户提供流畅的加载体验，同时避免常见的线程相关崩溃和性能问题。

常见问题排查与性能优化技巧

在Swift项目中使用MBProgressHUD时，开发者经常会遇到各种性能问题和集成挑战。本节将深入探讨常见问题的排查方法和性能优化技巧，帮助您构建更加稳定高效的HUD体验。

主线程访问问题排查

MBProgressHUD是一个UI组件，必须在主线程上进行所有操作。违反这一原则会导致不可预测的行为和崩溃。

// ❌ 错误示例 - 在后台线程操作HUD
DispatchQueue.global().async {
    let hud = MBProgressHUD.showAdded(to: self.view, animated: true)
    // 这里会崩溃，因为HUD操作必须在主线程
}

// ✅ 正确示例 - 确保在主线程操作
DispatchQueue.global().async {
    // 执行耗时任务
    DispatchQueue.main.async {
        let hud = MBProgressHUD.showAdded(to: self.view, animated: true)
    }
}

问题排查流程图： mermaid

内存泄漏检测与预防

MBProgressHUD在使用过程中容易产生循环引用，特别是在使用闭包和委托模式时。

class ViewController: UIViewController {
    var progressHUD: MBProgressHUD?
    
    func showHUD() {
        let hud = MBProgressHUD.showAdded(to: view, animated: true)
        hud.completionBlock = { [weak self] in
            // 使用weak self避免循环引用
            self?.handleHUDCompletion()
        }
        self.progressHUD = hud
    }
    
    deinit {
        progressHUD?.hide(animated: false)
    }
}

内存泄漏检测表：

症状	可能原因	解决方案
HUD不消失	强引用循环	使用weak引用
内存持续增长	未及时释放HUD	在deinit中隐藏HUD
重复创建HUD	未复用实例	使用单例或共享实例

性能优化策略

1. HUD复用机制

避免频繁创建和销毁HUD实例，特别是在列表或集合视图中：

class HUDManager {
    static let shared = HUDManager()
    private var hudCache: [UIView: MBProgressHUD] = [:]
    
    func showHUD(in view: UIView) -> MBProgressHUD {
        if let existingHUD = hudCache[view] {
            return existingHUD
        }
        
        let hud = MBProgressHUD.showAdded(to: view, animated: true)
        hudCache[view] = hud
        return hud
    }
    
    func hideHUD(in view: UIView) {
        if let hud = hudCache[view] {
            hud.hide(animated: true)
            hudCache.removeValue(forKey: view)
        }
    }
}

2. 动画性能优化

// 配置高效的动画参数
hud.animationType = .fade  // 使用淡入淡出动画，性能最佳
hud.minShowTime = 0.5      // 避免闪烁显示
hud.graceTime = 0.3        // 短任务不显示HUD

3. 资源使用监控

mermaid

常见错误代码及修复

错误1：视图层级问题

// ❌ 错误：在未加载的视图上添加HUD
override func viewDidLoad() {
    super.viewDidLoad()
    // 此时view可能还未完全加载
    MBProgressHUD.showAdded(to: view, animated: true)
}

// ✅ 正确：在视图显示后添加HUD
override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)
    MBProgressHUD.showAdded(to: view, animated: true)
}

错误2：并发访问冲突

// 使用线程安全的HUD管理
class ThreadSafeHUDManager {
    private let queue = DispatchQueue(label: "com.example.hudmanager", attributes: .concurrent)
    private var _hudInstances: [UIView: MBProgressHUD] = [:]
    
    var hudInstances: [UIView: MBProgressHUD] {
        queue.sync { _hudInstances }
    }
    
    func setHUD(_ hud: MBProgressHUD, for view: UIView) {
        queue.async(flags: .barrier) {
            self._hudInstances[view] = hud
        }
    }
}

调试技巧与工具

1. 使用Instruments检测

# 启动Time Profiler检测CPU使用
instruments -t "Time Profiler" -D tracefile YourApp.app

# 检查内存分配
instruments -t "Allocations" -D tracefile YourApp.app

2. 自定义调试日志

#if DEBUG
extension MBProgressHUD {
    func debugLog(_ message: String) {
        print("[MBProgressHUD Debug] \(message) - Thread: \(Thread.current)")
    }
}
#endif

3. 性能监控指标

指标	正常范围	警告阈值	紧急阈值
创建时间	< 5ms	10ms	20ms
动画时间	< 300ms	500ms	800ms
内存占用	< 2MB	5MB	10MB

高级优化技巧

1. 预加载HUD实例

// 在应用启动时预创建HUD实例
func preloadHUDResources() {
    DispatchQueue.global(qos: .utility).async {
        // 预加载HUD相关资源
        _ = MBProgressHUD(frame: CGRect(x: 0, y: 0, width: 100, height: 100))
    }
}

2. 智能显示策略

class SmartHUDController {
    private var lastShowTime: Date?
    private let minInterval: TimeInterval = 0.5
    
    func showHUDIfNeeded(in view: UIView) -> Bool {
        let now = Date()
        if let lastTime = lastShowTime, now.timeIntervalSince(lastTime) < minInterval {
            return false  // 避免过于频繁显示
        }
        
        lastShowTime = now
        MBProgressHUD.showAdded(to: view, animated: true)
        return true
    }
}

通过实施这些排查方法和优化策略，您可以显著提升MBProgressHUD在Swift项目中的性能和稳定性，为用户提供更加流畅的加载体验。

实际项目中的最佳实践案例

在真实的Swift项目开发中，MBProgressHUD的集成和使用需要遵循一些最佳实践，以确保代码的健壮性和用户体验的流畅性。以下是一些经过实践验证的案例和技巧：

封装统一的HUD管理类

在大型项目中，直接使用MBProgressHUD的原始API会导致代码重复和维护困难。建议创建一个统一的HUD管理类：

import MBProgressHUD

class HUDManager {
    static let shared = HUDManager()
    
    private var currentHUD: MBProgressHUD?
    
    func showLoading(on view: UIView, message: String? = nil) {
        hideCurrentHUD()
        
        let hud = MBProgressHUD.showAdded(to: view, animated: true)
        hud.mode = .indeterminate
        hud.label.text = message ?? "加载中..."
        hud.removeFromSuperViewOnHide = true
        
        currentHUD = hud
    }
    
    func showSuccess(on view: UIView, message: String, duration: TimeInterval = 2.0) {
        hideCurrentHUD()
        
        let hud = MBProgressHUD.showAdded(to: view, animated: true)
        hud.mode = .customView
        hud.customView = UIImageView(image: UIImage(named: "success_icon"))
        hud.label.text = message
        hud.removeFromSuperViewOnHide = true
        hud.hide(animated: true, afterDelay: duration)
    }
    
    func showError(on view: UIView, message: String, duration: TimeInterval = 2.0) {
        hideCurrentHUD()
        
        let hud = MBProgressHUD.showAdded(to: view, animated: true)
        hud.mode = .customView
        hud.customView = UIImageView(image: UIImage(named: "error_icon"))
        hud.label.text = message
        hud.removeFromSuperViewOnHide = true
        hud.hide(animated: true, afterDelay: duration)
    }
    
    func hideCurrentHUD() {
        currentHUD?.hide(animated: true)
        currentHUD = nil
    }
    
    func updateProgress(_ progress: Float, message: String? = nil) {
        guard let hud = currentHUD, hud.mode == .determinate || hud.mode == .annularDeterminate else {
            return
        }
        
        hud.progress = progress
        if let message = message {
            hud.label.text = message
        }
    }
}

网络请求中的HUD集成

在网络请求场景中，HUD的显示和隐藏需要与异步操作完美配合：

class NetworkService {
    func fetchDataWithHUD<T: Decodable>(
        from view: UIView,
        endpoint: String,
        parameters: [String: Any] = [:],
        completion: @escaping (Result<T, Error>) -> Void
    ) {
        // 显示加载HUD
        HUDManager.shared.showLoading(on: view, message: "正在加载数据")
        
        let url = URL(string: "https://api.example.com/\(endpoint)")!
        var request = URLRequest(url: url)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        do {
            request.httpBody = try JSONSerialization.data(withJSONObject: parameters)
        } catch {
            HUDManager.shared.showError(on: view, message: "参数错误")
            completion(.failure(error))
            return
        }
        
        URLSession.shared.dataTask(with: request) { data, response, error in
            DispatchQueue.main.async {
                // 无论成功失败都先隐藏HUD
                HUDManager.shared.hideCurrentHUD()
                
                if let error = error {
                    HUDManager.shared.showError(on: view, message: "网络请求失败")
                    completion(.failure(error))
                    return
                }
                
                guard let data = data else {
                    HUDManager.shared.showError(on: view, message: "无返回数据")
                    completion(.failure(NetworkError.noData))
                    return
                }
                
                do {
                    let decodedData = try JSONDecoder().decode(T.self, from: data)
                    completion(.success(decodedData))
                } catch {
                    HUDManager.shared.showError(on: view, message: "数据解析失败")
                    completion(.failure(error))
                }
            }
        }.resume()
    }
}

文件上传下载的进度显示

对于大文件的上传下载操作，使用进度条HUD能显著提升用户体验：

class FileService {
    func uploadFile(
        _ fileData: Data,
        to view: UIView,
        progressHandler: @escaping (Float) -> Void,
        completion: @escaping (Result<String, Error>) -> Void
    ) {
        let hud = MBProgressHUD.showAdded(to: view, animated: true)
        hud.mode = .annularDeterminate
        hud.label.text = "上传中..."
        hud.removeFromSuperViewOnHide = true
        
        let boundary = "Boundary-\(UUID().uuidString)"
        var request = URLRequest(url: URL(string: "https://api.example.com/upload")!)
        request.httpMethod = "POST"
        request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
        
        var body = Data()
        body.append("--\(boundary)\r\n".data(using: .utf8)!)
        body.append("Content-Disposition: form-data; name=\"file\"; filename=\"file.jpg\"\r\n".data(using: .utf8)!)
        body.append("Content-Type: image/jpeg\r\n\r\n".data(using: .utf8)!)
        body.append(fileData)
        body.append("\r\n--\(boundary)--\r\n".data(using: .utf8)!)
        
        let session = URLSession(configuration: .default, delegate: self, delegateQueue: nil)
        let task = session.uploadTask(with: request, from: body) { data, response, error in
            DispatchQueue.main.async {
                hud.hide(animated: true)
                
                if let error = error {
                    HUDManager.shared.showError(on: view, message: "上传失败")
                    completion(.failure(error))
                    return
                }
                
                HUDManager.shared.showSuccess(on: view, message: "上传成功")
                completion(.success("上传完成"))
            }
        }
        
        // 进度更新
        task.progress.observe(\.fractionCompleted) { progress, _ in
            DispatchQueue.main.async {
                hud.progress = Float(progress.fractionCompleted)
                hud.label.text = String(format: "上传中... %.0f%%", progress.fractionCompleted * 100)
            }
        }
        
        task.resume()
    }
}

复杂业务流程中的HUD状态管理

在涉及多个步骤的业务流程中，合理的HUD状态管理至关重要：

class OrderService {
    func createOrderWithMultipleSteps(on view: UIView, orderData: OrderData) {
        let hud = MBProgressHUD.showAdded(to: view, animated: true)
        hud.mode = .determinate
        hud.removeFromSuperViewOnHide = true
        
        // 步骤1: 验证订单数据
        hud.label.text = "验证订单数据..."
        hud.progress = 0.25
        
        validateOrder(orderData) { result in
            switch result {
            case .success:
                // 步骤2: 创建订单
                hud.label.text = "创建订单..."
                hud.progress = 0.5
                
                self.createOrder(orderData) { result in
                    switch result {
                    case .success(let orderId):
                        // 步骤3: 处理支付
                        hud.label.text = "处理支付..."
                        hud.progress = 0.75
                        
                        self.processPayment(orderId: orderId) { result in
                            DispatchQueue.main.async {
                                hud.hide(animated: true)
                                
                                switch result {
                                case .success:
                                    HUDManager.shared.showSuccess(on: view, message: "订单创建成功")
                                case .failure(let error):
                                    HUDManager.shared.showError(on: view, message: "支付失败: \(error.localizedDescription)")
                                }
                            }
                        }
                        
                    case .failure(let error):
                        DispatchQueue.main.async {
                            hud.hide(animated: true)
                            HUDManager.shared.showError(on: view, message: "订单创建失败: \(error.localizedDescription)")
                        }
                    }
                }
                
            case .failure(let error):
                DispatchQueue.main.async {
                    hud.hide(animated: true)
                    HUDManager.shared.showError(on: view, message: "订单验证失败: \(error.localizedDescription)")
                }
            }
        }
    }
}

HUD的自定义样式和主题

根据应用的整体设计风格，自定义HUD的外观：

extension MBProgressHUD {
    static func configureAppearance() {
        let appearance = MBProgressHUD.appearance()
        appearance.contentColor = .white
        appearance.bezelView.color = UIColor.black.withAlphaComponent(0.8)
        appearance.bezelView.style = .blur
        appearance.animationType = .zoom
        appearance.minSize = CGSize(width: 120, height: 120)
    }
    
    static func createCustomHUD(for view: UIView) -> MBProgressHUD {
        let hud = MBProgressHUD.showAdded(to: view, animated: true)
        hud.contentColor = .white
        hud.bezelView.color = UIColor.black.withAlphaComponent(0.8)
        hud.bezelView.style = .blur
        hud.animationType = .zoom
        hud.minSize = CGSize(width: 120, height: 120)
        hud.removeFromSuperViewOnHide = true
        return hud
    }
}

// 在AppDelegate中配置全局样式
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    MBProgressHUD.configureAppearance()
    return true
}

性能优化和内存管理

为了避免HUD相关的内存泄漏和性能问题，需要注意以下几点：

class MemorySafeHUDExample {
    private weak var currentHUD: MBProgressHUD?
    
    func showTemporaryHUD(on view: UIView) {
        // 使用weak引用避免循环引用
        let hud = MBProgressHUD.showAdded(to: view, animated: true)
        currentHUD = hud
        
        hud.mode = .text
        hud.label.text = "操作成功"
        hud.removeFromSuperViewOnHide = true
        
        // 使用weak self避免内存泄漏
        hud.hide(animated: true, afterDelay: 2.0)
    }
    
    deinit {
        // 在对象销毁时隐藏HUD
        currentHUD?.hide(animated: false)
    }
}

多线程环境下的HUD安全使用

确保在多线程环境下安全地操作HUD：

class ThreadSafeHUDExample {
    private let hudQueue = DispatchQueue(label: "com.example.hud.queue")
    private var pendingHUDOperations: [() -> Void] = []
    private var isShowingHUD = false
    
    func showHUDSafely(on view: UIView, message: String) {
        hudQueue.async { [weak self] in
            let operation = {
                DispatchQueue.main.async {
                    let hud = MBProgressHUD.showAdded(to: view, animated: true)
                    hud.label.text = message
                    hud.removeFromSuperViewOnHide = true
                    
                    // 模拟一些工作
                    DispatchQueue.global().async {
                        Thread.sleep(forTimeInterval: 2)
                        DispatchQueue.main.async {
                            hud.hide(animated: true)
                            self?.isShowingHUD = false
                            self?.processNextHUDOperation()
                        }
                    }
                }
            }
            
            if self?.isShowingHUD == true {
                self?.pendingHUDOperations.append(operation)
            } else {
                self?.isShowingHUD = true
                operation()
            }
        }
    }
    
    private func processNextHUDOperation() {
        hudQueue.async { [weak self] in
            guard let self = self, !self.pendingHUDOperations.isEmpty else { return }
            
            let nextOperation = self.pendingHUDOperations.removeFirst()
            self.isShowingHUD = true
            nextOperation()
        }
    }
}

这些最佳实践案例涵盖了从基础封装到高级应用的各个方面，帮助开发者在实际项目中更好地集成和使用MBProgressHUD，提升应用的用户体验和代码质量。

总结

MBProgressHUD作为iOS开发中常用的加载指示器组件，在Swift项目中的集成需要特别注意桥接配置、线程安全和性能优化。通过本文介绍的封装管理类、网络请求集成方案、文件传输进度显示以及多线程安全使用方法，开发者可以构建出稳定高效的HUD体验。记住始终在主线程操作UI、合理管理内存避免泄漏、根据业务场景选择合适的HUD模式，这些最佳实践将显著提升应用质量和用户满意度。

【免费下载链接】MBProgressHUD MBProgressHUD + Customizations 项目地址: https://gitcode.com/gh_mirrors/mb/MBProgressHUD

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考