Swift实现类C# protected权限及后台线程自动执行run()函数咨询

问题1：如何在Swift中实现与C#的“protected”访问权限类似的效果？ #

Swift本身并没有提供和C#完全一致的protected访问修饰符，但我们可以通过几种方式模拟类似的行为，核心思路是限制成员只能被子类和同一模块/文件内的代码访问：

• 同一文件内使用fileprivate：
  如果将父类和它的子类放在同一个.swift文件中，用fileprivate修饰的属性或方法，子类可以直接访问，而文件外的代码无法访问。这是最接近protected的轻量方案，适合小型类体系。
  示例代码：

  class Parent {
      fileprivate func protectedMethod() {
          print("This is like a protected method")
      }
  }
  
  class Child: Parent {
      func callProtectedMethod() {
          protectedMethod() // 子类可以正常调用
      }
  }
  
  // 文件外的代码
  let child = Child()
  child.protectedMethod() // 编译报错：'protectedMethod' is inaccessible due to 'fileprivate' protection level
  

• 模块内使用internal（默认权限）：
  Swift的默认访问权限是internal，即同一模块（比如你的App主工程、自定义Framework）内的所有代码都能访问。如果你的子类和父类在同一个模块里，把父类成员设为internal，就能实现“模块内子类可访问，外部模块不可访问”的效果，这在大型项目中更实用。
  示例代码：

  // 模块MyFramework内的Parent类
  public class Parent {
      internal func protectedLikeMethod() {
          print("Module-only access")
      }
  }
  
  // 同一模块内的Child类
  public class Child: Parent {
      func useParentMethod() {
          protectedLikeMethod() // 正常访问
      }
  }
  
  // 外部模块的代码
  let child = Child()
  child.protectedLikeMethod() // 编译报错：'protectedLikeMethod' is inaccessible due to 'internal' protection level
  

• 使用协议+扩展的组合方案：
  如果需要更灵活的控制，可以定义一个协议，把“protected”成员放在协议里，然后让父类遵循协议，同时用private修饰实际实现，再通过扩展让子类访问。不过这种方案稍复杂，适合需要严格控制访问的场景：

  private protocol ParentProtected {
      func protectedProtocolMethod()
  }
  
  class Parent: ParentProtected {
      private func protectedProtocolMethod() {
          print("Protected via protocol")
      }
  }
  
  extension ParentProtected where Self: Parent {
      func callProtectedMethod() {
          protectedProtocolMethod()
      }
  }
  
  class Child: Parent {
      func doSomething() {
          callProtectedMethod() // 通过扩展间接访问
      }
  }
  

问题2：实现自动在后台线程执行run()的类，带完成回调 #

这个需求非常适合用模板方法设计模式来实现——我们创建一个基类封装所有线程调度和回调逻辑，子类只需要专注写业务代码，完全不用碰线程相关的东西。

具体实现方案： #

1. 基类负责处理后台线程调度、错误捕获，以及完成回调的主线程切换；
2. 子类只需要重写run()方法，填充自己的业务逻辑即可；
3. 提供start(completion:)方法作为对外的启动入口，回调会自动在主线程执行（方便后续更新UI）。

完整代码示例： #

import Foundation

// 基类：封装线程和回调逻辑，子类无需关心
open class BackgroundTask {
    // 启动任务，completion会在主线程触发
    public func start(completion: @escaping (Result<Void, Error>) -> Void) {
        // 切换到后台队列执行run()
        DispatchQueue.global(qos: .background).async { [weak self] in
            guard let self = self else {
                DispatchQueue.main.async {
                    completion(.failure(NSError(domain: "BackgroundTask", code: -1, userInfo: [NSLocalizedDescriptionKey: "Task instance was deallocated"])))
                }
                return
            }
            
            do {
                try self.run()
                // 任务成功完成，切回主线程通知调用者
                DispatchQueue.main.async {
                    completion(.success(()))
                }
            } catch {
                // 任务出错，切回主线程传递错误信息
                DispatchQueue.main.async {
                    completion(.failure(error))
                }
            }
        }
    }
    
    // 子类必须重写的业务方法，自动在后台线程执行
    open func run() throws {
        // 基类默认抛出错误，强制子类重写
        fatalError("Subclasses must override the run() method")
    }
}

// 子类示例：只需要实现业务逻辑
class DataProcessingTask: BackgroundTask {
    override func run() throws {
        // 这里写你的业务代码，自动在后台线程运行
        print("Processing data on background thread: \(Thread.current)")
        // 模拟耗时操作
        Thread.sleep(forTimeInterval: 3)
        
        // 如果业务逻辑出错，直接抛出错误即可，基类会处理并传递给completion
        // throw NSError(domain: "DataProcessing", code: 200, userInfo: [NSLocalizedDescriptionKey: "Invalid data format"])
    }
}

// 使用示例
let task = DataProcessingTask()
task.start { result in
    switch result {
    case .success:
        print("Data processing completed on main thread: \(Thread.current)")
    case .failure(let error):
        print("Data processing failed: \(error.localizedDescription)")
    }
}

方案优势： #

• 零线程知识要求：子类开发者只需要专注业务逻辑，完全不用了解GCD或线程调度；
• 统一的错误处理：通过throws机制让子类轻松抛出错误，基类统一处理并传递给回调；
• 主线程回调：自动将completion切换到主线程，避免开发者手动处理线程切换导致的UI问题。

内容的提问来源于stack exchange，提问作者David Rector