In Swift, using for asynchronous code may seem like pure hell because, under the hood, are considered complete if the compilation of their synchronous code is completed. OperationQueue Operations In other words, compiling the example described below will output a broken execution order since, by the time the asynchronous code is executed, the itself will have already been completed. Operation let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 1

operationQueue.addOperation {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        print("First async operation complete")
    }
    print("First sync operation complete")
}

operationQueue.addOperation {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
        print("Second async operation complete")
    }
    print("Second sync operation complete")
} This code will print: First sync operation complete
Second sync operation complete
First async operation complete
Second async operation complete However, there is a way to circumvent these restrictions. To understand how to solve the problem, you need to understand how works under the hood. Operation The itself has four flags by which you can track the life cycle of the operation: Operation — indicates whether the can be performed at this time. isReady Operation —indicates whether an is currently in progress. isExecuting Operation —indicates whether the is currently completed. isFinished Operation —indicates whether the was canceled. isCancelled Operation In theory, the enters the state before the itself is executed asynchronously, so we need to develop a technique by which we will be able to manipulate the life cycle of the . Operation isFinished Operation Operation This possibility can be solved by subclassing the and also by redefining the / methods, as well as all the flags on which the operation's life cycle is built. Operation start cancel Here’s the code: public class AsyncOperation: Operation {
    // MARK: Open

    override open var isAsynchronous: Bool {
        true
    }

    override open var isReady: Bool {
        super.isReady && self.state == .ready
    }

    override open var isExecuting: Bool {
        self.state == .executing
    }

    override open var isFinished: Bool {
        self.state == .finished
    }

    override open func start() {
        if isCancelled {
            state = .finished
            return
        }
        main()
        state = .executing
    }

    override open func cancel() {
        super.cancel()
        state = .finished
    }

    // MARK: Public

    public enum State: String {
        case ready
        case executing
        case finished

        // MARK: Fileprivate

        fileprivate var keyPath: String {
            "is" + rawValue.capitalized
        }
    }

    public var state = State.ready {
        willSet {
            willChangeValue(forKey: newValue.keyPath)
            willChangeValue(forKey: state.keyPath)
        }
        didSet {
            didChangeValue(forKey: oldValue.keyPath)
            didChangeValue(forKey: state.keyPath)
        }
    }
} The subclass we received from the is basic and allows us to forcefully complete it manually. Operation To work with completion blocks, you should create another subclass. However, this will not be a subclass of the , but of . Operation AsyncOperation public typealias VoidClosure = () -> Void
public typealias Closure<T> = (T) -> Void

public class CompletionOperation: AsyncOperation {
    // MARK: Lifecycle

    public init(completeBlock: Closure<VoidClosure?>?) {
        self.completeBlock = completeBlock
    }

    // MARK: Public

    override public func main() {
        DispatchQueue.main.async { [weak self] in
            self?.completeBlock? {
                DispatchQueue.main.async {
                    self?.state = .finished
                }
            }
        }
    }

    // MARK: Private

    private let completeBlock: Closure<VoidClosure?>?
} This subclass will allow us to pass a closure to the , after which the will be completed. Operation Operation Let’s try this type of operation in practice: let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 1

operationQueue.addOperation(
    CompletionOperation { completion in
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            print("First async operation complete")
            completion?()
        }
        print("First sync operation complete")
    }
)

operationQueue.addOperation(
    CompletionOperation { completion in
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
            print("Second async operation complete")
            completion?()
        }
        print("Second sync operation complete")
    }
) As a result, we were able to achieve synchronous execution of : Operations First sync operation complete
First async operation complete
Second sync operation complete
Second async operation complete Don’t hesitate to contact me on if you have any questions. Also, you can always . Twitter buy me a coffee Also published here

Too Long; Didn't Read

In your car, at home, or at work — Bosch technology shapes many areas of life.

OperationQueue + Asynchronous Code: Everything You Need to Know

Too Long; Didn't Read

Boris Bugor

About Author

TOPICS

Languages

THIS ARTICLE WAS FEATURED IN...

OperationQueue + Asynchronous Code: Everything You Need to Know

Too Long; Didn't Read

Boris Bugor

About Author

TOPICS

Languages

THIS ARTICLE WAS FEATURED IN...

RELATED STORIES