how to call a method in a view controller from Appdelegate in Swift?

These types of messaging are in most cases done with static context. As it was already mentioned you could alternatively use notification center within the within the view controller to be notified of your application entering foreground. I discourage you creating custom notifications for this though (but is a possible solution as well).

Anyway for your specific case I suggest you have a model that contains your data. Then create a shared instance of it.

class MyDataModel {

   static var shared: MyDataModel = {
        let model = MyDataModel()
        model.reloadData()
        return model
   }()

   var myObjects: [MyObject]?

   func reloadData() {
       // load data asynchronously
   }
}

Now when your view controller needs to reload it simply uses MyDataModel.shared.myObjects as data source.

In app delegate all you do is reload it when app comes back to foreground using MyDataModel.shared.reloadData().

So now a delegate is still missing so we add

protocol MyDataModelDelegate: class {
    func myDataModel(_ sender: MyDataModel, updatedObjects objects: [MyObject]?)
}
class MyDataModel {

    weak var delegate: MyDataModelDelegate?

   static var shared: MyDataModel = {

Now when your view controller appears it needs to assign itself as a delegate MyDataModel.shared.delegate = self. And implement the protocol in which a reload on the view must be made.

A callout to the delegate can simply be done in a model setter:

}()

var myObjects: [MyObject]? {
   didSet {
       delegate.myDataModel(self, updatedObjects: myObjects)
   }
}

func reloadData() {

You can do something like that, using a technique called Key-Value Observation:

class CommonObservableData: NSObject {
    // Use @objc and dynamic to ensure enabling Key-Value Observation
    @objc dynamic var dateTime: Date?

    static let shared = CommonObservableData()

    func updateFromWeb() {
        // callWebThen is a function you will define that calls your Web API, then
        // calls a completion handler you define, passing new value to your handler
        callWeb(then: { self.dateTime = $0 })
    }
}

Then you observe on it using Swift 4 's new NSKeyValueObservation.

class SomeViewController: UIViewController {
    var kvo: NSKeyValueObservation?
    func viewDidLoad() {
        ...
        kvo = CommonObservableData.shared.observe(
            \CommonObservableData.dateTime, { model, change in

            self.label.text = "\(model.dateTime)"

        })
    }
}

Key-Value Observation is originally an Objective-C technique that is "somewhat revived" by Swift 4, this technique allows you to observe changes on a property (called a Key in Objective-C) of any object.

So, in the previous code snippets, we made a class, and made it a singleton, this singleton has an observable property called dateTime, where we could observe on change of this property, and make any change in this property automatically calls a method where we could update the UI.

Read about KVO here:

Key-Value Observation Apple Programming Guide

Key-Value Observation using Swift 4

Also, if you like Rx and RFP (Reactive Functional Programming), you can use RxSwift and do the observation in a cleaner way using it.

In swift 4 and 5, the notification name is changed the below code working for both.

    notifyCenter.addObserver(self, selector: #selector(new), name:UIApplication.willEnterForegroundNotification, object: nil)

 @objc func  new(){}