使用Method Swizzling处理URLSession后，逃逸完成句柄执行时App崩溃求助

Hey there, let’s dig into why your swizzled URLSession completion handler is crashing. First, let’s look at the code snippet you shared to spot potential issues:

@objc func mytestTaskWithRequest(request: URLRequest,completionHandler: @escaping (Data?, URLResponse?, Error?) -> Void ) -> URLSessionDataTask { 
    let completionHandler: (Data?, URLResponse?, Error?) -> Void = {(data, response, error) in 
        if error == nil { 
            DispatchQueue.main.async { 
                self.captur...

Here are the key areas to investigate and fix:

• Unsafe self Capture in Escaping Closure
  You’re referencing self inside a DispatchQueue.main.async block, which is an escaping closure. If the object holding this swizzled method gets deallocated before the block runs, accessing self will trigger a crash. Always use weak self to avoid dangling references:

  let wrappedCompletionHandler: (Data?, URLResponse?, Error?) -> Void = { [weak self] data, response, error in
      if error == nil {
          DispatchQueue.main.async {
              guard let self = self else { return } // Safely unwrap weak self
              self.captureYourTargetData(...) // Your capture logic here
          }
      }
  }
  

• Method Signature Mismatch
  URLSession’s original dataTask(with:completionHandler:) uses the Objective-C selector dataTaskWithRequest:completionHandler:. If your swizzled method’s signature (including parameter labels) doesn’t match exactly, swizzling will fail or cause unexpected method dispatch. Adjust your method to match the original signature:

  // Correct signature aligns with the original method's selector
  @objc func mytestTaskWithRequest(_ request: URLRequest, completionHandler: @escaping (Data?, URLResponse?, Error?) -> Void) -> URLSessionDataTask {
  

• Overwriting the Original Completion Handler
  You’re redefining the completionHandler variable inside your method, which replaces the original handler passed by the app. This breaks the app’s native logic and often leads to crashes. Use a unique variable name for your wrapped handler, and always call the original handler first:

  let wrappedCompletionHandler: (Data?, URLResponse?, Error?) -> Void = { [weak self] data, response, error in
      // Execute the app's original completion logic first
      completionHandler(data, response, error)
      
      // Then run your custom capture logic
      if error == nil {
          DispatchQueue.main.async {
              guard let self = self else { return }
              self.captureYourTargetData(...)
          }
      }
  }
  

• Thread Safety in Swizzling Execution
  Method swizzling isn’t thread-safe by default. If you perform swizzling outside a synchronized context, you might end up with partial swizzling that causes method dispatch chaos. Ensure swizzling runs once on the main thread using a thread-safe singleton pattern:

  extension URLSession {
      static let swizzleOnce: Void = {
          DispatchQueue.once {
              let originalSelector = #selector(dataTask(with:completionHandler:))
              let swizzledSelector = #selector(mytestTaskWithRequest(_:completionHandler:))
              // ... rest of your swizzling implementation
          }
      }()
      
      override class func initialize() {
          super.initialize()
          _ = swizzleOnce
      }
  }
  

• Missing Error Case Handling
  Your code only handles the error == nil scenario, but the original app might rely on error-case logic in its completion handler. Skipping the original handler for errors can leave the app in an inconsistent state and cause crashes. Always call the original handler regardless of error status.

Double-check these points, adjust your code accordingly, and test again to see if the crash resolves.

内容的提问来源于stack exchange，提问作者Kashif Jilani