甚至在我的操作在 main 方法中完成之前就触发了完成块

Question

I am trying to create user in firebase using OperationQueue and Operation. I placed the Firebase Auth call in operation main method. Completion block of the operation is getting triggered even before firebase registration process is succeeded.

RegistrationViewModal.swift

//This is operation initialization
 let operationQueues = OperationQueues()
 let registrationRecord = RegistrationRecord(user: self.user!, encryptedData: self.fireBaseAuthCompliance)
 let userRegistrationOperation = UserRegistrationOperation(registrationRecord: registrationRecord)
            userRegistrationOperation.completionBlock = {
//I am expecting this completion block will be called only when my firebase invocation in main() method is finished
   DispatchQueue.main.async {
//Since this block is getting triggered even before completion, the //value is returning as null
     self.user?.uid = userRegistrationOperation.registrationRecord.user.uid

                }
            }
     operationQueues.userRegistrationQueue.addOperation(userRegistrationOperation)

UserRegistrationOperation.swift

class OperationQueues {
    lazy var userRegistrationQueue: OperationQueue = {
        var queue = OperationQueue()
        queue.maxConcurrentOperationCount = 1
        queue.name = "User registration queue"
        return queue
    }()
}

class UserRegistrationOperation: Operation {
    var registrationRecord: RegistrationRecord

    init(registrationRecord: RegistrationRecord) {
        self.registrationRecord = registrationRecord
    }
    override func main() {

        guard !isCancelled else { return }
        self.registrationRecord.state = RegistrationStatus.pending
//Firebase invocation to create a user in Firebase Auth
        Auth.auth().createUser(withEmail: self.registrationRecord.user.userEmail, password: self.registrationRecord.encryptedData){ [weak self](result, error) in
            if error != nil {
                print("Error occured while user registration process")
                self?.registrationRecord.state = RegistrationStatus.failed

                return
            }
            self?.registrationRecord.user.uid = result?.user.uid
            self?.registrationRecord.state = RegistrationStatus.processed

        }
    }

}

Answer 1

The problem is that your operation is initiating an asynchronous process, but the operation finishes when the asynchronous task is started, not when the asynchronous task finishes.

You need to do the KVO associated with a “concurrent” operation, as outlined in the documentation :

If you are creating a concurrent operation, you need to override the following methods and properties at a minimum:

• start()
• isAsynchronous
• isExecuting
• isFinished

In a concurrent operation, your start() method is responsible for starting the operation in an asynchronous manner. Whether you spawn a thread or call an asynchronous function, you do it from this method. Upon starting the operation, your start() method should also update the execution state of the operation as reported by the isExecuting property. You do this by sending out KVO notifications for the isExecuting key path, which lets interested clients know that the operation is now running. Your isExecuting property must also provide the status in a thread-safe manner.

Upon completion or cancellation of its task, your concurrent operation object must generate KVO notifications for both the isExecuting and isFinished key paths to mark the final change of state for your operation. (In the case of cancellation, it is still important to update the isFinished key path, even if the operation did not completely finish its task. Queued operations must report that they are finished before they can be removed from a queue.) In addition to generating KVO notifications, your overrides of the isExecuting and isFinished properties should also continue to report accurate values based on the state of your operation.

Now all of that sounds quite hairy, but it's actually not that bad. One way is to write a base operation class that takes care of all of this KVO stuff, and this this answer outlines one example implementation .

Then you can subclass AsynchronousOperation instead, and make sure to call finish (or whatever triggers the isFinished KVO) when the task is done:

class UserRegistrationOperation: AsynchronousOperation {
    var registrationRecord: RegistrationRecord

    init(registrationRecord: RegistrationRecord) {
        self.registrationRecord = registrationRecord
        super.init()                                // whenever you subclass, remember to call `super`
    }

    override func main() {    
        self.registrationRecord.state = .pending

        //Firebase invocation to create a user in Firebase Auth

        Auth.auth().createUser(withEmail: registrationRecord.user.userEmail, password: registrationRecord.encryptedData) { [weak self] result, error in
            defer { self?.finish() }                // make sure to call `finish` regardless of how we leave this closure

            guard let result = result, error == nil else {
                print("Error occured while user registration process")
                self?.registrationRecord.state = .failed    
                return
            }

            self?.registrationRecord.user.uid = result.user.uid
            self?.registrationRecord.state = .processed
        }
    }
}

There are lots of ways to implement that AsynchronousOperation class and this is just one example. But once you have a class that nicely encapsulates the concurrent operation KVO, you can subclass it and you can write your own concurrent operations with very little changes to your code.