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 :

Ich habe ein array von URLs
Dem array zu Durchlaufen in einer Schleife
URL zu jedem index aufgerufen werden, durch AlamoFire GET-Anforderung
Die empfangenen Daten durch die Anfrage Hinzugefügt werden, um ein array von
Daten
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?

InformationsquelleAutor Talha Ahmad Khan | 2016-05-31

Tags: alamofire, arrays, asynchronous, swift

3 Replies

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

InformationsquelleAutor Rohan Sanap

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

InformationsquelleAutor Johnykutty

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.

InformationsquelleAutor Payal Maniyar

Schreibe einen Kommentar Antworten abbrechen