Dans mon projet SWIFT, j'ai un bouton et il y a beaucoup d'œuvres que je dois faire lorsque j'appuie sur le bouton (disons que ces travaux prennent environ 40 secondes à partir du moment où j'appuie sur le bouton). Par conséquent, pendant cette période de temps, mon bouton est dans son état "sélectionné". Ce que je veux, c'est de modifier le texte d'une étiquette plusieurs fois (chaque après des fonctions spécifiques est effectuée) lorsque ce bouton est enfoncé. Donc j'ai quelque chose comme ceci: mais quand je clique sur le bouton, toutes ces fonctions commencent à courir et ils ne voient que je ne vois que le texte de Mylabel change sur "Quelqu'un de Text4" sera Ne changez jamais à "Quelqu'un de Texte1" ou "Certains Text2" ou "Certains Text3" avant de devenir "Quelques Text4". Je pensais que peut-être mettre
3 Réponses :
Ajouter un bloc d'achèvement à votre fonction. Puis changez le texte de l'étiquette à l'intérieur du bloc d'achèvement
typealias completionBlock = () -> Void
@IBOutlet weak var myLabel: UILabel!
@IBAction func myButton(_ sender: UIButton) {
firstFunction {
self.myLabel.text = "Some text1"
}
secondFunction {
self.myLabel.text = "Some text2"
}
thirdFuntion {
self.myLabel.text = "Some text3"
}
}
func firstFunction(_ completion: @escaping completionBlock) {
// your function body
completion()
}
func secondFunction(_ completion: @escaping completionBlock) {
// your function body
completion()
}
func thirdFuntion(_ completion: @escaping completionBlock) {
// your function body
completion()
}
Vous pouvez exécuter toutes vos tâches de longue date dans une file d'attente de fond et rendre les mises à jour des étiquettes dans la file d'attente principale. La clé consiste à appeler la fonction suivante uniquement lorsque la première est terminée, sinon elles s'exécuteront en parallèle et pourraient toutes mettre à jour en même temps. Voici un exemple
func doSomething1() {
// as good a way as any to simulate a long-running process
sleep(1)
DispatchQueue.main.async {
self.myLabel.text = "Some text1"
}
DispatchQueue.global(qos: .background).async {
self.doSomething2()
}
}
func doSomething2() {
sleep(1)
DispatchQueue.main.async {
self.myLabel.text = "Some text2"
}
DispatchQueue.global(qos: .background).async {
self.doSomething3()
}
}
func doSomething3() {
sleep(1)
DispatchQueue.main.async {
self.myLabel.text = "Some text3"
}
DispatchQueue.global(qos: .background).async {
self.doSomething4()
}
}
func doSomething4() {
sleep(1)
DispatchQueue.main.async {
self.myLabel.text = "Some text4"
}
}
@IBAction func cmdDoStuff(_ sender: UIButton) {
DispatchQueue.global(qos: .background).async {
self.doSomething1()
}
}
C'est exactement ce dont j'avais besoin, ça a fonctionné. Merci beaucoup!
Étant donné que votre code est synchrone, le code sur la ligne est exécuté immédiatement après le code de la ligne précédente. Donc, vous verrez toujours le dernier texte distingué Pour appeler un code après quelque chose est effectué, nous utilisons des gestionnaires d'achèvement dans Swift P> "Quelqu'un text4" code> @IBAction func myButton(_ sender: UIButton) {
callAfter(2, text: "Text1") { text in
print(text)
}
callAfter(4, text: "Text2") { text in
print(text)
}
callAfter(6, text: "Text3") { text in
print(text)
}
}
func callAfter(_ duration: Double, text: String, _ completion: @escaping (String)->Void) {
DispatchQueue.main.asyncAfter(deadline: .now() + duration) {
completion(text)
}
}
Ces fonctions sont exécutées dans des micro-seconde
Je sais que c'est exactement mon problème. Mes fonctions prennent trop longtemps pour que je puisse être capable de voir les changements, pourquoi je ne les vois pas? Soit self.mylabel.text = "Certains Text1" prend 1 micro deuxièmement, j'ai d'énormes fonctions après cela qui prendra 10 secondes après 10 secondes, Self.MyLabel.text = "Certains text2" devraient être exécutés afin que je puisse être capable de pouvoir être capable. Pour voir Self.MyLabel.Text = "Quelqu'un de Texte1" pendant 10 secondes !!!