Escaping closure setting views in DispatchQueue.main.async Swift 3

Question

I'm dealing with some asynchronous functions and trying to update views. In short I have function 1 with asynchronous function that will return a string to be passed to function 2. I am updating views in both functions, on main thread. It all works but I need to understand if this is correct way.

class A {
    var varA = ""
    var varB = ""

    func f1 (_ completion: @escaping (String) -> void ){

        some asynchronous call ... { in
            ... 
            DispatchQueue.main.async {
                self.varA = "something"
                sef.labelA.text = self.varA
                completion(self.varA)
            }
        }
    }

    func f2 (_ string: String){

        another asynchronous call ... { in
            ... 
            DispatchQueue.main.async {
                self.varB = string
                sef.labelB.text = self.varB

            }
        }
    }

    // funcation call
    f1(completion: f2)
}

Three questions, 1) What is the right way to run a dependent function where there is wait for an asynchronous callback?

2) Is DispatchQueue.main.async needed to update views?

3) Is it ok to call async func in another async callback? Isn't there chance self may be nil in some cases if you are updating views in some escaping function?

Answer 1

I'm going to try helping you according to your questions:

Question 1) There are many right ways and each developer can have its own logic, but in this case, what I personally would probably do is something like this:

class A {    
    func f1 (_ completion: @escaping (String) -> void ){

        some asynchronous call ... { in
            ... 
            DispatchQueue.main.async { [weak self] in // 1
                guard let strongSelf = self else { return } // 2
                let varA = "something" // 3
                strongSelf.label.text = varA
                completion(varA) // 4
            }
        }
    }

    func f2 (_ string: String){

        another asynchronous call ... { in
            ... 
            DispatchQueue.main.async {
                sef.labelB.text = string // 5
            }
        }
    }

    // function call
    // 6
    f1(completion: { [weak self] text in
        guard let strongSelf = self else { return }
        strongSelf.f2(text)
    })
}

1 - Here I'm using [weak self] to avoid retain cycles.

2 - Just unwrapping the optional self, case it's nil, I'll just return.

3 - In your case, it's not really necessary to have class variables, so I'm just creating local variables inside the block.

4 - Finally, I'm calling the completion with the variable containing the string.

5 - I also don't really need to set a class variable in here, so I'm just updating the label text with the string provided as a paramater.

6 - Then, I just need to call the first function and use the completion block to call the second after the first one completes.

Question 2) Yes, you must call DispatchQueue.main to update the view. This way your making sure that your code will be executed in the main thread that is crucial for things interacting with UI because it allow us to have a sincronization point as you can read in Apple's documentation.

Question 3) Using [weak self] and guard let strongSelf = self else { return }, I'm avoiding retain cycles and the cases where self can be nil.