iOS Amplify 查询仅在第二次视图控制器出现后才有效

Question

我在加载视图控制器后立即运行 Amplify 查询，但是除非我切换到另一个选项卡然后返回，否则不会返回任何数据，或者重新加载应用程序然后它就可以工作了。然后每次加载视图控制器时它每次都工作，它只是第一次不工作。这是在多个真实设备和模拟器上。谁能告诉我为什么它第一次不起作用但之后每隔一次都不起作用？

override func viewDidAppear(_ animated: Bool) {
        inspections = [InspectionWrapper]()
        fetchInspectionData()
}

func fetchInspectionData() {
    let amplify = AmplifyHelper()
    
    SVProgressHUD.show()
    
    
    
    DispatchQueue.global(qos: .background).async {
        amplify.queryInspections { retrievedInspections in
            for inspection in retrievedInspections {
       
                var newInspection = InspectionWrapper(inspection: inspection)
                
                amplify.queryInspectionResponses(forInspection: inspection) { retrievedInspectionReponses in
                    for inspectionReponse in retrievedInspectionReponses {
                        
                        newInspection.inspectionResponses.append(inspectionReponse)

                        amplify.queryQuestions(forInspectionResponse: inspectionReponse) { retrievedQuestions in
                            for question in retrievedQuestions {
                                
                                var questionAndAnswers = QuestionAndAnswers(question: question, answers: nil)
                                
                                amplify.queryAnswers(forQuestion: question) { retrievedAnswers in
                                    questionAndAnswers.answers = [Answer]()
                                    for answer in retrievedAnswers {
                                        questionAndAnswers.answers?.append(answer)
                                    }
                                    
                                    newInspection.questionAndAnswers.append(questionAndAnswers)
                                    
                                    
                                }
                            }
                        }
                    }
                    
                    self.inspections.append(newInspection)
                }
                
            }
            
  
        }
        DispatchQueue.main.async {

            SVProgressHUD.dismiss()
            self.collectionView.reloadData()
        }
    }
}

AmplifyHelper()

func queryInspections(completion: @escaping ([Inspection]) -> ())  {
        Amplify.DataStore.query(Inspection.self) { result in
            switch result {
            case .success(let retrievedInspections):
                completion(retrievedInspections)
            case .failure(let error):
                print("Error on query for type Inspection - \(error.localizedDescription)")
            }
        }
    }
    
    func queryInspectionResponses(forInspection inspection: Inspection, completion: @escaping ([InspectionResponse]) -> ()) {
        let inspectionResponseKeys = InspectionResponse.keys
        Amplify.DataStore.query(InspectionResponse.self, where: inspectionResponseKeys.inspectionID.eq(inspection.id)) { result in
            switch result {
            case .success(let retrievedInspectionResponses):
                completion(retrievedInspectionResponses)
            case .failure(let error):
                print("Error on query for type InspectionResponse - \(error.localizedDescription)")
            }
        }
        
    }
    
    func queryQuestions(forInspectionResponse inspectionResponse: InspectionResponse, completion: @escaping ([Question]) -> ()) {
        let questionKeys = Question.keys
        Amplify.DataStore.query(Question.self, where: questionKeys.inspectionID.eq(inspectionResponse.inspectionID)) { result in
            switch result {
            case .success(let retrievedQuestions):
                completion(retrievedQuestions)
            case .failure(let error):
                print("Error on query for type Question - \(error.localizedDescription)")
            }
        }
    }
    
    func queryAnswers(forQuestion question: Question, completion: @escaping ([Answer]) -> ()) {
        let answerKeys = Answer.keys
        Amplify.DataStore.query(Answer.self, where: answerKeys.qid.eq(question.id)) { result in
            switch result {
            case .success(let retrievedAnswers):
                completion(retrievedAnswers)
            case .failure(let error):
                print("Error on query for type Answer - \(error.localizedDescription)")
            }
        }
        
    }

Answer 1

您的集合视图从什么位置加载数据？自我检查？您可能有竞争状况....尝试移动

DispatchQueue.main.async {
    SVProgressHUD.dismiss()
    self.collectionView.reloadData()
}

一个括号，以便它仅在 amplify.queryInspections 完成后执行。缓存可能是在调用 reloadData 之前允许后续查询完成的原因。