Swift: Wie rm Alamofire get-Anfrage nacheinander in Schleife

Ich bin ein Anfänger in swift und ich haben einen Fall, wo ich zu laufen AlamoFire GET-request in einer Schleife. Aber soweit ich weiß , die Alamofire Get-Anforderung ist ein Asynchroner Aufruf und den Aufruf in der Schleife, erstellen Sie eine Anzahl von threads.

Voraussetzung ist :

  1. Ich habe ein array von URLs
  2. Dem array zu Durchlaufen in einer Schleife

  3. URL zu jedem index aufgerufen werden, durch AlamoFire GET-Anforderung

  4. Die empfangenen Daten durch die Anfrage Hinzugefügt werden, um ein array von
    Daten

  5. Nachdem die letzten Daten in das array ein
    CollectionView.neu laden call aufgerufen werden soll

Pseudo-code ist wie folgt:

    for bookmarkURL in bookmarks
        Alamofire.request(.GET, bookmarkURL ).responseJSON
                { response in switch response.result {
                case .Success(let JSON):
                    x[i] = JSON as! [String : AnyObject] //saving data

                case .Failure(let error):
                     print("the error for \(self.bookmarkURL) is \(error) ")
                }
        i++
        if i == bookmarks.count{
           collectionView.reload()
          break}
}

kann mir jemand sagen, wie sollte ich tun, es in der Folge?



3 Replies
  1. 11
    • Machen bookmarks array als Klasse Eigenschaft.
    • Fügen Sie die Eigenschaft einer Klasse index zum speichern von index-Wert (Int) beim überqueren der bookmarks array
    • Eine Funktion hinzufügen, um den API-Aufruf und nennen Sie es rekursiv.

    Hier ist der code:

    func getData() {
        var x = [[String: AnyObject]]()
        Alamofire.request(.GET, bookmarks[index]).responseJSON { response in
            switch response.result {
            case .Success(let JSON):
                x[self.index] = JSON as! [String : AnyObject] //saving data
                self.index = self.index + 1
                if self.index < self.bookmarks.count {
                    self.getData()
                }else {
                    self.collectionView.reloadData()
                }
            case .Failure(let error):
                print("the error for \(self.bookmarks[self.index]) is \(error) ")
                if self.index < self.bookmarks.count {
                    self.getData()
                }else {
                    self.collectionView.reloadData()
                }
            }
        }
    
    }

    In diesem Weg Ihre Anfrage wird nur gemacht werden, wenn der Vorherige abgeschlossen ist, so dass es nacheinander, statt parallel, und Sie können auch laden Sie die collectionView erst, nachdem die Letzte Anforderung beendet ist.

    • Die Logik der wiederkehrenden Funktion gut funktioniert
  2. 3

    Wenn Sie möchten, laden Sie Ihre Sammlung Ansicht nur nach Erhalt der gesamten Daten, die Sie verwenden können dispatch_group wie,

        let group = dispatch_group_create() //create a group.
    
        dispatch_group_enter(group) //enter the group just before create the request 
    
        dispatch_group_leave(group)//leave the group on completion closure
        dispatch_group_notify(group, group) { 
            //reload your collection view 
        }

    Vollständigen code

        for bookmarkURL in bookmarks {
            dispatch_group_enter(group)
            Alamofire.request(.GET, bookmarkURL ).responseJSON { response in 
            switch response.result {
                case .Success(let JSON):
                    x[i] = JSON as! [String : AnyObject] //saving data
    
                case .Failure(let error):
                    print("the error for \(self.bookmarkURL) is \(error) ")
                }
            dispatch_group_leave(group)
            }
        }
        dispatch_group_notify(group, group) {
             collectionView.reload()
        }

    Hinweis: wenn Sie Ihre Lesezeichen-array ist zu groß, besser, es nicht zu tun in einer Schleife.
    Dafür können Sie folgenden code

    func loadBookmarkAtIndex(index: Int) {
        if index >= bookmarks.count {
            collectionView.reload()
            return
        }
        let bookmarkURL = bookmarks[index]
        Alamofire.request(.GET, bookmarkURL ).responseJSON { response in
    
            switch response.result {
            case .Success(let JSON):
                x[index] = JSON as! [String : AnyObject] //saving data
    
            case .Failure(let error):
                print("the error for \(bookmarkURL) is \(error) ")
    
            }
            self.loadBookmarkAtIndex(index+1)
        }
    }

    – Und call – self.loadBookmarkAtIndex(0) aus, wo Sie initiieren, der die Daten abrufen.

    • Wird die AlamoFire-GET-Anfrage aufgerufen werden eins nach dem anderen, in-Schleife , mit dieser Methode?
    • Nein, aber es wird warten, bis komplett alle Anfragen, zur Abwicklung der notify-Gruppe. Wenn Sie möchten, rufen Sie alamofire Anfrage eins nach dem anderen, besser, andere techiques.
    • aktualisierte Antwort für den tatsächlichen Bedarf
    • Habe versucht den code für das herunterladen von Bildern von viele URLs, aber die Methode dispatch_group_notify nicht genannt. Irgendwelche Ideen? Übrigens der gleiche code verwendet, um gut funktionieren ein paar Tagen wieder
  3. 2

    Denke ich, sollten Sie reload Element der Kollektion anzeigen jedes mal, wenn Sie erhalten die Antwort vom sever bezüglich der erhaltenen Antwort.

    Hier ist die Lösung:

    let x : NSMutableArray  = NSMutableArray.init(capacity: bookmarks.count)
    
    for var i in 0 ..< x.count {
    
        Alamofire.request(.GET, bookmarkURL ).responseJSON
                    { response in switch response.result {
                    case .Success(let JSON):
    
        x.insertObject(JSON as! [String : AnyObject], atIndex:i)
                    //   x[i] = //saving data
        //<reload relative item cell of collectionView>
    
                    case .Failure(let error):
                         print("the error for \(self.bookmarkURL) is \(error) ")
                    }
            i+=1
    
        }

    Hoffe obigen code wird Ihnen helfen.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.