Woher weiß ich, dass die UICollectionView vollständig geladen wurde?

Ich muss eine Operation ausführen, wenn UICollectionView vollständig geladen wurde, dh zu diesem Zeitpunkt sollten alle Datenquellen- / Layoutmethoden von UICollectionView aufgerufen werden. Woher weiß ich das?? Gibt es eine Delegatenmethode, um den Ladezustand von UICollectionView zu ermitteln?

// In viewDidLoad
[self.collectionView addObserver:self forKeyPath:@"contentSize" options:NSKeyValueObservingOptionOld context:NULL];

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary  *)change context:(void *)context
{
    // You will get here when the reloadData finished 
}

- (void)dealloc
{
    [self.collectionView removeObserver:self forKeyPath:@"contentSize" context:NULL];
}

Das hat bei mir funktioniert:

[self.collectionView reloadData];
[self.collectionView performBatchUpdates:^{}
                              completion:^(BOOL finished) {
                                  /// collection-view finished reload
                              }];

Swift 4-Syntax:

self.collectionView.reloadData()
self.collectionView.performBatchUpdates(nil, completion: {
    (result) in
    // ready
})

Es ist eigentlich ziemlich einfach.

Wenn Sie beispielsweise die reloadData-Methode von UICollectionView oder die invalidateLayout-Methode des Layouts aufrufen, gehen Sie wie folgt vor:

dispatch_async(dispatch_get_main_queue(), ^{
    [self.collectionView reloadData];
});

dispatch_async(dispatch_get_main_queue(), ^{
    //your stuff happens here
    //after the reloadData/invalidateLayout finishes executing
});

Warum das funktioniert:

Der Haupt-Thread (in dem wir alle UI-Updates durchführen sollten) enthält die Hauptwarteschlange, die serieller Natur ist, dh auf FIFO-Weise funktioniert. Im obigen Beispiel wird also der erste Block aufgerufen, bei dem unsere reloadDataMethode aufgerufen wird, gefolgt von allem anderen im zweiten Block.

Jetzt blockiert auch der Haupt-Thread. Wenn Sie also reloadData3s für die Ausführung benötigen, wird die Verarbeitung des zweiten Blocks um diese 3s verzögert.

Nur um eine großartige @ dezinezync-Antwort hinzuzufügen:

Swift 3+

collectionView.collectionViewLayout.invalidateLayout() // or reloadData()
DispatchQueue.main.async {
    // your stuff here executing after collectionView has been layouted
}

Mach es so:

       UIView.animateWithDuration(0.0, animations: { [weak self] in
                guard let strongSelf = self else { return }

                strongSelf.collectionView.reloadData()

            }, completion: { [weak self] (finished) in
                guard let strongSelf = self else { return }

                // Do whatever is needed, reload is finished here
                // e.g. scrollToItemAtIndexPath
                let newIndexPath = NSIndexPath(forItem: 1, inSection: 0)
                strongSelf.collectionView.scrollToItemAtIndexPath(newIndexPath, atScrollPosition: UICollectionViewScrollPosition.Left, animated: false)
        })

Wie dezinezync antwortete, müssen Sie einen Codeblock reloadDatavon einem UITableViewoder an die Hauptwarteschlange sendenUICollectionView senden, und dieser Block wird dann ausgeführt, nachdem die Zellen aus der Warteschlange entfernt wurden

Um dies bei der Verwendung klarer zu gestalten, würde ich eine Erweiterung wie die folgende verwenden:

extension UICollectionView {
    func reloadData(_ completion: @escaping () -> Void) {
        reloadData()
        DispatchQueue.main.async { completion() }
    }
}

Es kann auch zu einer implementiert werden UITableViewund

Ein anderer Ansatz mit RxSwift / RxCocoa:

        collectionView.rx.observe(CGSize.self, "contentSize")
            .subscribe(onNext: { size in
                print(size as Any)
            })
            .disposed(by: disposeBag)

Versuchen Sie, einen synchronen Layoutdurchlauf über layoutIfNeeded () direkt nach dem Aufruf von reloadData () zu erzwingen. Scheint sowohl für UICollectionView als auch für UITableView unter iOS 12 zu funktionieren.

collectionView.reloadData()
collectionView.layoutIfNeeded() 

// cellForItem/sizeForItem calls should be complete
completion?()

Das funktioniert bei mir:

__weak typeof(self) wself= self;
[self.contentCollectionView performBatchUpdates:^{
    [wself.contentCollectionView reloadData];
} completion:^(BOOL finished) {
    [wself pageViewCurrentIndexDidChanged:self.contentCollectionView];
}];

Ich musste einige Aktionen für alle sichtbaren Zellen ausführen, wenn die Sammlungsansicht geladen wurde, bevor sie für den Benutzer sichtbar ist. Ich habe Folgendes verwendet:

public func collectionView(_ collectionView: UICollectionView, willDisplay cell: UICollectionViewCell, forItemAt indexPath: IndexPath) {
    if shouldPerformBatch {
        self.collectionView.performBatchUpdates(nil) { completed in
            self.modifyVisibleCells()
        }
    }
}

Achten Sie darauf, dass dies beim Scrollen durch die Sammlungsansicht aufgerufen wird. Um diesen Overhead zu vermeiden, habe ich Folgendes hinzugefügt:

private var souldPerformAction: Bool = true

und in der Aktion selbst:

private func modifyVisibleCells() {
    if self.shouldPerformAction {
        // perform action
        ...
        ...
    }
    self.shouldPerformAction = false
}

Die Aktion wird weiterhin mehrmals ausgeführt, wie die Anzahl der sichtbaren Zellen im Ausgangszustand. Bei all diesen Anrufen haben Sie jedoch die gleiche Anzahl sichtbarer Zellen (alle). Das boolesche Flag verhindert, dass es erneut ausgeführt wird, nachdem der Benutzer mit der Sammlungsansicht interagiert hat.

Ich habe gerade Folgendes getan, um etwas auszuführen, nachdem die Sammlungsansicht neu geladen wurde. Sie können diesen Code auch in API-Antworten verwenden.

self.collectionView.reloadData()

DispatchQueue.main.async {
   // Do Task after collection view is reloaded                
}

Auf jeden Fall:

//Subclass UICollectionView
class MyCollectionView: UICollectionView {

    //Store a completion block as a property
    var completion: (() -> Void)?

    //Make a custom funciton to reload data with a completion handle
    func reloadData(completion: @escaping() -> Void) {
        //Set the completion handle to the stored property
        self.completion = completion
        //Call super
        super.reloadData()
    }

    //Override layoutSubviews
    override func layoutSubviews() {
        //Call super
        super.layoutSubviews()
        //Call the completion
        self.completion?()
        //Set the completion to nil so it is reset and doesn't keep gettign called
        self.completion = nil
    }

}

Rufen Sie dann so in Ihrem VC an

let collection = MyCollectionView()

self.collection.reloadData(completion: {

})

Stellen Sie sicher, dass Sie die Unterklasse verwenden !!

Diese Arbeit für mich:

- (void)viewDidLoad {
    [super viewDidLoad];

    int ScrollToIndex = 4;

    [self.UICollectionView performBatchUpdates:^{}
                                    completion:^(BOOL finished) {
                                             NSIndexPath *indexPath = [NSIndexPath indexPathForItem:ScrollToIndex inSection:0];
                                             [self.UICollectionView scrollToItemAtIndexPath:indexPath atScrollPosition:UICollectionViewScrollPositionCenteredHorizontally animated:NO];
                                  }];

}

Laden Sie collectionView einfach in Batch-Updates neu und überprüfen Sie dann im Abschlussblock, ob es fertig ist oder nicht, mit Hilfe des booleschen "finish".

self.collectionView.performBatchUpdates({
        self.collectionView.reloadData()
    }) { (finish) in
        if finish{
            // Do your stuff here!
        }
    }

Die beste Lösung, die ich bisher gefunden habe, ist die Verwendung CATransaction, um die Fertigstellung zu handhaben.

Swift 5 :

CATransaction.begin()
CATransaction.setCompletionBlock {
    // UICollectionView is ready
}

collectionView.reloadData()

CATransaction.commit()

So habe ich das Problem mit Swift 3.0 gelöst:

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)

    if !self.collectionView.visibleCells.isEmpty {
        // stuff
    }
}

Versuche dies:

- (NSInteger)collectionView:(UICollectionView *)collectionView numberOfItemsInSection:(NSInteger)section
{
    return _Items.count;
}

- (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView cellForItemAtIndexPath:(NSIndexPath *)indexPath
{
    UICollectionViewCell *cell;
    //Some cell stuff here...

    if(indexPath.row == _Items.count-1){
       //THIS IS THE LAST CELL, SO TABLE IS LOADED! DO STUFF!
    }

    return cell;
}

Sie können so tun ...

  - (void)reloadMyCollectionView{

       [myCollectionView reload];
       [self performSelector:@selector(myStuff) withObject:nil afterDelay:0.0];

   }

  - (void)myStuff{
     // Do your stuff here. This will method will get called once your collection view get loaded.

    }