Comment puis-je savoir que le UICollectionView a été complètement chargé?

Je dois faire une opération à chaque fois que UICollectionView a été complètement chargé, c'est à dire à l'époque tous les UICollectionView de la source de données /méthodes de présentation doit être appelé. Comment je le sais?? Est-il un délégué méthode pour connaître UICollectionView chargé de statut?

InformationsquelleAutor Jirune | 2012-12-24

61
```
//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];
}
```
- cela se bloque pour moi, quand je revenir en arrière, sinon fonctionne bien.
- ajouter [self.collectionView removeObserver:self forKeyPath:@"contentSize" context:NULL]; à -viewWillDisappear:animated: ainsi.
- Génial! Merci beaucoup!
- La taille du contenu des modifications lors du défilement également, ainsi il n'est pas fiable.
- J'ai essayé pour la vue d'une collection qui se de données à l'aide d'un async reste de la méthode. Cela signifie que les Cellules Visibles est toujours vide quand cette méthode incendies, ce qui signifie que je faites défiler jusqu'à un élément de la collection au début.
- Utilisez cette méthode avec précaution, il n'est pas fiable. UIKit est surtout PAS KVO conforme.
- Inutile si vous faites défiler la collectionView
InformationsquelleAutor Cullen SUN
135

Cela a fonctionné pour moi:
```
[self.collectionView reloadData];
[self.collectionView performBatchUpdates:^{}
                              completion:^(BOOL finished) {
                                  ///collection-view finished reload
                              }];
```
Swift 4 syntaxe:
```
self.collectionView.reloadData()
self.collectionView.performBatchUpdates(nil, completion: {
    (result) in
    //ready
})
```
- J'ai essayé mais ça n'a pas fonctionné dans mon cas.
- ne fonctionne pas dans iOS9 (qui a travaillé sur iOS8)
- A fonctionné pour moi sur iOS 9
- pouvez-vous nous expliquer un peu le code ?
- Errrr, c'est sûr.... de quoi avez-vous besoin d'expliquer? La première ligne reloadData actualise la collectionView de sorte qu'il attire sur lui la source de données méthodes de nouveau... le performBatchUpdates a un achèvement bloc joint donc si les deux sont effectuées sur le thread principal, vous savez tout code qui mettent en place des /// collection-view finished reload exécutera avec un nouveau et mis collectionView
- N'a pas travaillé pour moi quand le collectionView avaient dynamique de la taille des cellules
- Cette méthode est la solution parfaite, sans maux de tête.
- Swift 4.2 IOS 11 a fonctionné pour moi aussi
- Cela fonctionne parfaitement pour moi avec dynamique de la taille des cellules, Swift 4.2 IOS 12
- insertItemsAtIndexPaths:indexSet]; dispatch_async(dispatch_get_main_queue(), ^{ [self.collectionView scrollToItemsAtIndexPaths:indexSet scrollPosition:NSCollectionViewScrollPositionBottom]; });
- Fonctionne pour moi dans iOS 11. Merci.
InformationsquelleAutor myeyesareblind
25

C'est plutôt très simple.

Quand par exemple appeler la UICollectionView de reloadData de la méthode ou de la disposition de l'invalidateLayout méthode, vous effectuez les opérations suivantes:
```
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
});
```
Pourquoi cela fonctionne:

Le thread principal (qui est l'endroit où nous devrions faire toutes les mises à jour de l'INTERFACE utilisateur) maisons de la file d'attente principale, qui est de série dans la nature, c'est à dire qu'elle travaille dans la FIFO de la mode. Ainsi, dans l'exemple ci-dessus, le premier bloc est appelé, qui a notre reloadData méthode invoquée, suivie par quoi que ce soit d'autre dans le second bloc.

Maintenant, le thread principal est bloquant ainsi. Donc, si vous êtes reloadData prend 3s à exécuter, le traitement de la seconde tranche sera reporté par ceux 3s.
- En fait je viens de testé, Le bloc est appelé avant que l'ensemble de mes délégués d'autres méthodes. Si cela ne fonctionne pas?
- hey, j'ai mis à jour le code, quelque chose que j'utilise maintenant dans 2 production des applications. Également inclus l'explication.
- Ne fonctionne pas pour moi. Quand je l'appelle reloadData, le collectionView demandes de cellules après l'exécution de la deuxième bloc. Donc je vais avoir le même problème que @taylorcressy semblent avoir.
- Je peux confirmer avec @RaphaelWichmann. J'obtiens le même problème.
- Pouvez-vous essayer de mettre la deuxième appel de bloc à l'intérieur de la première? Non vérifiées, mais pourrait fonctionner.
- Je ne pense pas que ce soit la bonne solution. Je pense qu'il ne fonctionne que de temps en temps parce que vous ne savez pas ce qui se passe sous le capot de la reloadData. Il pourrait être, dans certains cas, le deuxième bloc async est ajouté à la file d'attente principale avant le code dans reloadData décide de mettre quelque chose sur le thread principal.
- Autant que je sache, toutes les opérations qui se produisent à l'intérieur de reloadData sont synchrones. Donc, n'importe quel code vous mettre en file d'attente sur le thread principal après la reloadData invocation se déclencher après qu'il a terminé.
- ok cool. Serait intéressant de savoir pourquoi, alors, certains ont trouvé que cela ne fonctionne pas alors
- oui, en effet. Seulement les exemples de code serait aider dans de telles situations.
- Cela ne fonctionne pas pour moi. J'ai des données venant de l'affichage de la collection et de la première section je fais un reload de données, les données que je dois insérer un article. Le problème se produit lorsque les deux appels sont trop proches. Peut-être recharger des données n'est pas synchrone
- avez-vous essayé d'emballage à la fois à l'intérieur du bloc?
- Ce que j'ai fait était de mettre un @synchronisée sur l'appel de la méthode j'ai aussi mis un drapeau dans la réalisation des blocs de collectionView performBatchUpdates: et ignorer mon insérer et d'utiliser recharger si le drapeau fini n'avait pas été fixée. Cela semble fonctionner 99% du temps.
- Les docs disent pour performBatchUpdates: Un gestionnaire d'achèvement bloc à exécuter lorsque toutes les opérations sont terminées. Ce bloc prend un seul paramètre Booléen qui contient la valeur OUI, si toutes les animations terminées avec succès ou NON si elles ont été interrompues. Ce paramètre peut être nul. Donc, en théorie, le drapeau de travail
- pouvez-vous s'il vous plaît poster cet exemple quelque part afin que je puisse plonger dans il ainsi? Je suis intrigué par cette.
- Dépend de ce que vous voulez savoir... ContentSize peuvent ne pas être exacts en ce moment
- reloadData maintenant place en file d'attente au chargement des cellules sur le thread principal (même si elles sont appelées par le thread principal). Si les cellules ne sont pas réellement chargé (cellForRowAtIndexPath: n'est pas appelé) après reloadData retourne. Emballage code que vous voulez exécuter après vos cellules sont chargées dans dispatch_async(dispatch_get_main... et l'appel que suite à votre appel à reloadData permettra d'atteindre le résultat souhaité.
- Quant à savoir pourquoi cela ne fonctionne pas. Suivre les commentaires à partir de here. L'essentiel, c'est: "Le thread principal exécute une NSRunLoop. Une course en boucle a différentes phases, et vous pouvez programmer un rappel pour une phase spécifique (à l'aide d'un CFRunLoopObserver). UIKit horaires de la mise en page à produire au cours d'une phase ultérieure, une fois que votre gestionnaire d'événement renvoie" . Mais aussi assurez-vous de lire la réponse ainsi.
InformationsquelleAutor dezinezync
12

Juste pour ajouter à un grand @dezinezync réponse:

Swift 3+
```
collectionView.collectionViewLayout.invalidateLayout() //or reloadData()
DispatchQueue.main.async {
    //your stuff here executing after collectionView has been layouted
}
```
- pour cela, nous devons ajouter à vue, ne semble !!
- Pas nécessairement, vous pouvez appeler à partir d'où vous voulez faire quelque chose lors de la mise en page est enfin chargé.
- J'ai été faire défiler scintille essayer de faire de mon collectionView faites défiler jusqu'à la fin après l'insertion d'éléments, ce qu'il est corrigé, merci.
InformationsquelleAutor nikans

De faire comme ceci:

       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)
        })

InformationsquelleAutor Darko

2

Une approche différente à l'aide de RxSwift/RxCocoa:
```
        collectionView.rx.observe(CGSize.self, "contentSize")
            .subscribe(onNext: { size in
                print(size as Any)
            })
            .disposed(by: disposeBag)
```
- Je suis aimer cela. performBatchUpdates ne marchait pas dans mon cas, c'est un fait. Cheers!
- Il ne fonctionne pas, il est appelé à chaque fois que vous faites défiler
- Pouvez-vous mettre à jour votre code quelque part? La méthode doit être appelée uniquement lorsque contentSize a été changé? Donc, sauf si vous changer sur chaque rouleau, cela devrait fonctionner!
InformationsquelleAutor Chinh Nguyen
2

Essayer de forcer un synchrone passe de mise en page via layoutIfNeeded() juste après la reloadData() de l'appel. Semble fonctionner pour les deux UICollectionView et UITableView sur iOS 12.
```
collectionView.reloadData()
collectionView.layoutIfNeeded() 

//cellForItem/sizeForItem calls should be complete
completion?()
```
- Merci man! J'ai été chercher la solution de ce problème pour un temps assez long.
InformationsquelleAutor tyler

Cela fonctionne pour moi:

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

un non-sens... ce qui n'a pas fini la pose d'une quelconque façon.

InformationsquelleAutor jAckOdE

1

Comme dezinezync répondu, ce que vous avez besoin est d'envoyer à la file d'attente principale, un bloc de code après reloadData à partir d'un UITableView ou UICollectionView, et puis ce bloc sera exécuté après que les cellules de file d'attente

Afin de le rendre plus directement lors de l'utilisation, je voudrais utiliser une extension comme ceci:
```
extension UICollectionView {
    func reloadData(_ completion: @escaping () -> Void) {
        reloadData()
        DispatchQueue.main.async { completion() }
    }
}
```
Il peut également être mis en œuvre pour une UITableView ainsi

InformationsquelleAutor Matheus Rocco

Def ce faire:

//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
    }

}

Ensuite appeler comme ça à l'intérieur de votre VC

let collection = MyCollectionView()

self.collection.reloadData(completion: {

})

Assurez-vous d'utiliser la sous-classe!!

InformationsquelleAutor Jon Vogel

0

J'ai besoin d'un peu d'action à faire sur toutes les cellules visibles lors de l'affichage de la collection chargés avant qu'il soit visible pour l'utilisateur, j'ai utilisé:
```
public func collectionView(_ collectionView: UICollectionView, willDisplay cell: UICollectionViewCell, forItemAt indexPath: IndexPath) {
    if shouldPerformBatch {
        self.collectionView.performBatchUpdates(nil) { completed in
            self.modifyVisibleCells()
        }
    }
}
```
Faire attention à ce que ce seront appelés lorsque vous faites défiler l'affichage de la collection, afin d'éviter cette surcharge de travail, j'ai ajouté:
```
private var souldPerformAction: Bool = true
```
et dans l'action elle-même:
```
private func modifyVisibleCells() {
    if self.shouldPerformAction {
        //perform action
        ...
        ...
    }
    self.shouldPerformAction = false
}
```
L'action sera tout de même effectué plusieurs fois, comme le nombre de cellules visibles à l'état initial. mais sur tous ces appels, vous aurez le même nombre de cellules visibles (toutes). Et le drapeau booléen empêcher de courir à nouveau après que l'utilisateur a commencé à interagir avec l'affichage de la collection.

InformationsquelleAutor gutte

Ce travail pour moi:


- (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];
                                  }];

}

InformationsquelleAutor chrisz

-1

C'est comment j'ai résolu le problème avec Swift 3.0:
```
override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)

    if !self.collectionView.visibleCells.isEmpty {
        //stuff
    }
}
```
- Cela ne fonctionnera pas. VisibleCells aura le contenu dès que la première cellule est chargé... le problème c'est que nous voulons savoir quand la dernière cellule a été chargé.
InformationsquelleAutor landonandrey
-9

Vous pouvez le faire comme ceci...
```
  - (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.

    }
```
- Bien que ce code peut répondre à la question, en fournissant plus de contexte sur pourquoi et/ou comment il répond à la question permettrait d'améliorer de manière significative sa valeur à long terme. Veuillez modifier votre réponse à ajouter quelques explications.
InformationsquelleAutor Swapnil

-9

Essayez ceci:

- (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;
}

Il n'est pas correct, cellFor sera appelée que si la cellule va être visible, dans ce cas, le dernier élément visible ne sera pas égale au nombre total d'éléments...

InformationsquelleAutor Rocker

Vous devez vous connecter pour publier un commentaire.