Wie kann man feststellen, wann UITableView ReloadData abgeschlossen hat?

Ich versuche, nach Abschluss der Ausführung zum Ende einer UITableView zu scrollen [self.tableView reloadData]

Ich hatte ursprünglich

 [self.tableView reloadData]
 NSIndexPath* indexPath = [NSIndexPath indexPathForRow: ([self.tableView numberOfRowsInSection:([self.tableView numberOfSections]-1)]-1) inSection: ([self.tableView numberOfSections]-1)];

[self.tableView scrollToRowAtIndexPath:indexPath atScrollPosition:UITableViewScrollPositionBottom animated:YES];

Aber dann habe ich gelesen, dass reloadData asynchron ist, so dass das Scrollen seit dem nicht mehr stattfindet self.tableView , [self.tableView numberOfSections]und [self.tableView numberOfRowsinSectionsind alle 0.

Vielen Dank!

Was seltsam ist, dass ich benutze:

[self.tableView reloadData];
NSLog(@"Number of Sections %d", [self.tableView numberOfSections]);
NSLog(@"Number of Rows %d", [self.tableView numberOfRowsInSection:([self.tableView numberOfSections]-1)]-1);

In der Konsole wird Sections = 1, Row = -1 zurückgegeben.

Wenn ich genau die gleichen NSLogs in mache, erhalte cellForRowAtIndexPathich Sections = 1 und Row = 8; (8 ist richtig)

Das Neuladen erfolgt während des nächsten Layoutdurchlaufs, der normalerweise erfolgt, wenn Sie die Steuerung an die Ausführungsschleife zurückgeben (z. B. nach Ihrer Tastenaktion oder was auch immer zurückkehrt).

Eine Möglichkeit, nach dem erneuten Laden der Tabellenansicht etwas auszuführen, besteht darin, die Tabellenansicht zu zwingen, das Layout sofort auszuführen:

[self.tableView reloadData];
[self.tableView layoutIfNeeded];
 NSIndexPath* indexPath = [NSIndexPath indexPathForRow: ([self.tableView numberOfRowsInSection:([self.tableView numberOfSections]-1)]-1) inSection: ([self.tableView numberOfSections]-1)];
[self.tableView scrollToRowAtIndexPath:indexPath atScrollPosition:UITableViewScrollPositionBottom animated:YES];

Eine andere Möglichkeit besteht darin, den Code nach dem Layout so zu planen, dass er später ausgeführt wird dispatch_async.

[self.tableView reloadData];

dispatch_async(dispatch_get_main_queue(), ^{
     NSIndexPath* indexPath = [NSIndexPath indexPathForRow: ([self.tableView numberOfRowsInSection:([self.tableView numberOfSections]-1)]-1) inSection:([self.tableView numberOfSections]-1)];

    [self.tableView scrollToRowAtIndexPath:indexPath atScrollPosition:UITableViewScrollPositionBottom animated:YES];
});

AKTUALISIEREN

Bei weiteren Untersuchungen stelle ich fest, dass die Tabellenansicht vor der Rückkehr von tableView:numberOfSections:und tableView:numberOfRowsInSection:an ihre Datenquelle gesendet wird reloadData. Wenn der Delegat implementiert tableView:heightForRowAtIndexPath:, sendet die Tabellenansicht dies auch (für jede Zeile), bevor Sie von zurückkehren reloadData.

Die Tabellenansicht sendet jedoch nicht tableView:cellForRowAtIndexPath:oder tableView:headerViewForSectionerst in der Layoutphase. Dies geschieht standardmäßig, wenn Sie die Steuerung an die Ausführungsschleife zurückgeben.

Ich finde auch, dass in einem winzigen Testprogramm der Code in Ihrer Frage ordnungsgemäß zum Ende der Tabellenansicht gescrollt wird, ohne dass ich etwas Besonderes tue (wie Senden layoutIfNeededoder Verwenden dispatch_async).

Schnell:

extension UITableView {
    func reloadData(completion:@escaping ()->()) {
        UIView.animateWithDuration(0, animations: { self.reloadData() })
            { _ in completion() }
    }
}

...somewhere later...

tableView.reloadData {
    println("done")
}

Ziel c:

[UIView animateWithDuration:0 animations:^{
    [myTableView reloadData];
} completion:^(BOOL finished) {
    //Do something after that...
}];

Ab Xcode 8.2.1, iOS 10 und Swift 3

Sie können das Ende tableView.reloadData()einfach mithilfe eines CATransaction-Blocks bestimmen:

CATransaction.begin()
CATransaction.setCompletionBlock({
    print("reload completed")
    //Your completion code here
})
print("reloading")
tableView.reloadData()
CATransaction.commit()

Das Obige funktioniert auch zum Bestimmen des Endes von reloadData () von UICollectionView und reloadAllComponents () von UIPickerView.

Es dispatch_async(dispatch_get_main_queue())ist nicht garantiert, dass die oben beschriebene Methode funktioniert . Ich sehe damit ein nicht deterministisches Verhalten, bei dem das System manchmal die layoutSubviews und das Rendern von Zellen vor dem Abschlussblock und manchmal danach abgeschlossen hat.

Hier ist eine Lösung, die unter iOS 10 zu 100% für mich funktioniert. Sie erfordert die Fähigkeit, UITableView oder UICollectionView als benutzerdefinierte Unterklasse zu instanziieren. Hier ist die UICollectionView-Lösung, aber für UITableView ist es genau dasselbe:

CustomCollectionView.h:

#import <UIKit/UIKit.h>

@interface CustomCollectionView: UICollectionView

- (void)reloadDataWithCompletion:(void (^)(void))completionBlock;

@end

CustomCollectionView.m:

#import "CustomCollectionView.h"

@interface CustomCollectionView ()

@property (nonatomic, copy) void (^reloadDataCompletionBlock)(void);

@end

@implementation CustomCollectionView

- (void)reloadDataWithCompletion:(void (^)(void))completionBlock
{
    self.reloadDataCompletionBlock = completionBlock;
    [self reloadData];
}

- (void)layoutSubviews
{
    [super layoutSubviews];

    if (self.reloadDataCompletionBlock) {
        self.reloadDataCompletionBlock();
        self.reloadDataCompletionBlock = nil;
    }
}

@end

Anwendungsbeispiel:

[self.collectionView reloadDataWithCompletion:^{
    // reloadData is guaranteed to have completed
}];

Sehen Sie hier für eine Swift - Version dieser Antwort

Ich hatte die gleichen Probleme wie Tyler Sheaffer.

Ich habe seine Lösung implementiert in Swift und sie hat meine Probleme gelöst.

Swift 3.0:

final class UITableViewWithReloadCompletion: UITableView {
  private var reloadDataCompletionBlock: (() -> Void)?

  override func layoutSubviews() {
    super.layoutSubviews()

    reloadDataCompletionBlock?()
    reloadDataCompletionBlock = nil
  }


  func reloadDataWithCompletion(completion: @escaping () -> Void) {
    reloadDataCompletionBlock = completion
    self.reloadData()
  }
}

Swift 2:

class UITableViewWithReloadCompletion: UITableView {

  var reloadDataCompletionBlock: (() -> Void)?

  override func layoutSubviews() {
    super.layoutSubviews()

    self.reloadDataCompletionBlock?()
    self.reloadDataCompletionBlock = nil
  }

  func reloadDataWithCompletion(completion:() -> Void) {
      reloadDataCompletionBlock = completion
      self.reloadData()
  }
}

Anwendungsbeispiel:

tableView.reloadDataWithCompletion() {
 // reloadData is guaranteed to have completed
}

Und eine UICollectionViewVersion, basierend auf der Antwort von kolaworld:

https://stackoverflow.com/a/43162226/1452758

Muss getestet werden. Funktioniert bisher unter iOS 9.2, Xcode 9.2 Beta 2, mit dem Scrollen einer CollectionView zu einem Index als Abschluss.

extension UICollectionView
{
    /// Calls reloadsData() on self, and ensures that the given closure is
    /// called after reloadData() has been completed.
    ///
    /// Discussion: reloadData() appears to be asynchronous. i.e. the
    /// reloading actually happens during the next layout pass. So, doing
    /// things like scrolling the collectionView immediately after a
    /// call to reloadData() can cause trouble.
    ///
    /// This method uses CATransaction to schedule the closure.

    func reloadDataThenPerform(_ closure: @escaping (() -> Void))
    {       
        CATransaction.begin()
            CATransaction.setCompletionBlock(closure)
            self.reloadData()
        CATransaction.commit()
    }
}

Verwendung:

myCollectionView.reloadDataThenPerform {
    myCollectionView.scrollToItem(at: indexPath,
            at: .centeredVertically,
            animated: true)
}

Es scheint, dass die Leute diese Frage und die Antworten immer noch lesen. B / c davon bearbeite ich meine Antwort, um das Wort Synchron zu entfernen für dieses wirklich irrelevant ist.

When [tableView reloadData]gibt zurück, die internen Datenstrukturen hinter der tableView wurden aktualisiert. Wenn die Methode abgeschlossen ist, können Sie daher sicher nach unten scrollen. Ich habe dies in meiner eigenen App überprüft. Die allgemein akzeptierte Antwort von @ rob-mayoff ist zwar auch in der Terminologie verwirrend, bestätigt dies jedoch in seinem letzten Update.

Wenn dein tableView nicht nach unten scrollen, liegt möglicherweise ein Problem mit einem anderen Code vor, den Sie nicht veröffentlicht haben. Vielleicht ändern Sie Daten, nachdem der Bildlauf abgeschlossen ist, und laden dann nicht neu und / oder scrollen dann nach unten?

Fügen Sie wie folgt eine Protokollierung hinzu, um zu überprüfen, ob die Tabellendaten danach korrekt sind reloadData. Ich habe den folgenden Code in einer Beispiel-App und es funktioniert perfekt.

// change the data source

NSLog(@"Before reload / sections = %d, last row = %d",
      [self.tableView numberOfSections],
      [self.tableView numberOfRowsInSection:[self.tableView numberOfSections]-1]);

[self.tableView reloadData];

NSLog(@"After reload / sections = %d, last row = %d",
      [self.tableView numberOfSections],
      [self.tableView numberOfRowsInSection:[self.tableView numberOfSections]-1]);

[self.tableView scrollToRowAtIndexPath:[NSIndexPath indexPathForRow:[self.tableView numberOfRowsInSection:[self.tableView numberOfSections]-1]-1
                                                          inSection:[self.tableView numberOfSections] - 1]
                      atScrollPosition:UITableViewScrollPositionBottom
                              animated:YES];

Ich benutze diesen Trick, ziemlich sicher, dass ich ihn bereits in einem Duplikat dieser Frage gepostet habe:

-(void)tableViewDidLoadRows:(UITableView *)tableView{
    // do something after loading, e.g. select a cell.
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    // trick to detect when table view has finished loading.
    [NSObject cancelPreviousPerformRequestsWithTarget:self selector:@selector(tableViewDidLoadRows:) object:tableView];
    [self performSelector:@selector(tableViewDidLoadRows:) withObject:tableView afterDelay:0];

    // specific to your controller
    return self.objects.count;
}

Eigentlich hat dieser mein Problem gelöst:

-(void) tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath {

NSSet *visibleSections = [NSSet setWithArray:[[tableView indexPathsForVisibleRows] valueForKey:@"section"]];
if (visibleSections) {
    // hide the activityIndicator/Loader
}}

Versuchen Sie es so, es wird funktionieren

[tblViewTerms performSelectorOnMainThread:@selector(dataLoadDoneWithLastTermIndex:) withObject:lastTermIndex waitUntilDone:YES];waitUntilDone:YES];

@interface UITableView (TableViewCompletion)

-(void)dataLoadDoneWithLastTermIndex:(NSNumber*)lastTermIndex;

@end

@implementation UITableView(TableViewCompletion)

-(void)dataLoadDoneWithLastTermIndex:(NSNumber*)lastTermIndex
{
    NSLog(@"dataLoadDone");


NSIndexPath* indexPath = [NSIndexPath indexPathForRow: [lastTermIndex integerValue] inSection: 0];

[self selectRowAtIndexPath:indexPath animated:YES scrollPosition:UITableViewScrollPositionNone];

}
@end

Ich werde ausführen, wenn die Tabelle vollständig geladen ist

Eine andere Lösung ist, dass Sie UITableView unterordnen können

Am Ende habe ich eine Variation von Shawns Lösung verwendet:

Erstellen Sie eine benutzerdefinierte UITableView-Klasse mit einem Delegaten:

protocol CustomTableViewDelegate {
    func CustomTableViewDidLayoutSubviews()
}

class CustomTableView: UITableView {

    var customDelegate: CustomTableViewDelegate?

    override func layoutSubviews() {
        super.layoutSubviews()
        self.customDelegate?.CustomTableViewDidLayoutSubviews()
    }
}

Dann benutze ich in meinem Code

class SomeClass: UIViewController, CustomTableViewDelegate {

    @IBOutlet weak var myTableView: CustomTableView!

    override func viewDidLoad() {
        super.viewDidLoad()

        self.myTableView.customDelegate = self
    }

    func CustomTableViewDidLayoutSubviews() {
        print("didlayoutsubviews")
        // DO other cool things here!!
    }
}

Stellen Sie außerdem sicher, dass Sie Ihre Tabellenansicht im Interface Builder auf CustomTableView setzen:

In Swift 3.0 + können wir eine Erweiterung für erstellen UITableViewmit einem escaped Closurewie unten:

extension UITableView {
    func reloadData(completion: @escaping () -> ()) {
        UIView.animate(withDuration: 0, animations: { self.reloadData()})
        {_ in completion() }
    }
}

Und verwenden Sie es wie unten, wo immer Sie wollen:

Your_Table_View.reloadData {
   print("reload done")
 }

hoffe, das wird jemandem helfen. Prost!

Einzelheiten

• Xcode Version 10.2.1 (10E1001), Swift 5

Lösung

import UIKit

// MARK: - UITableView reloading functions

protocol ReloadCompletable: class { func reloadData() }

extension ReloadCompletable {
    func run(transaction closure: (() -> Void)?, completion: (() -> Void)?) {
        guard let closure = closure else { return }
        CATransaction.begin()
        CATransaction.setCompletionBlock(completion)
        closure()
        CATransaction.commit()
    }

    func run(transaction closure: (() -> Void)?, completion: ((Self) -> Void)?) {
        run(transaction: closure) { [weak self] in
            guard let self = self else { return }
            completion?(self)
        }
    }

    func reloadData(completion closure: ((Self) -> Void)?) {
        run(transaction: { [weak self] in self?.reloadData() }, completion: closure)
    }
}

// MARK: - UITableView reloading functions

extension ReloadCompletable where Self: UITableView {
    func reloadRows(at indexPaths: [IndexPath], with animation: UITableView.RowAnimation, completion closure: ((Self) -> Void)?) {
        run(transaction: { [weak self] in self?.reloadRows(at: indexPaths, with: animation) }, completion: closure)
    }

    func reloadSections(_ sections: IndexSet, with animation: UITableView.RowAnimation, completion closure: ((Self) -> Void)?) {
        run(transaction: { [weak self] in self?.reloadSections(sections, with: animation) }, completion: closure)
    }
}

// MARK: - UICollectionView reloading functions

extension ReloadCompletable where Self: UICollectionView {

    func reloadSections(_ sections: IndexSet, completion closure: ((Self) -> Void)?) {
        run(transaction: { [weak self] in self?.reloadSections(sections) }, completion: closure)
    }

    func reloadItems(at indexPaths: [IndexPath], completion closure: ((Self) -> Void)?) {
        run(transaction: { [weak self] in self?.reloadItems(at: indexPaths) }, completion: closure)
    }
}

Verwendung

UITableView

// Activate
extension UITableView: ReloadCompletable { }

// ......
let tableView = UICollectionView()

// reload data
tableView.reloadData { tableView in print(collectionView) }

// or
tableView.reloadRows(at: indexPathsToReload, with: rowAnimation) { tableView in print(tableView) }

// or
tableView.reloadSections(IndexSet(integer: 0), with: rowAnimation) { _tableView in print(tableView) }

UICollectionView

// Activate
extension UICollectionView: ReloadCompletable { }

// ......
let collectionView = UICollectionView()

// reload data
collectionView.reloadData { collectionView in print(collectionView) }

// or
collectionView.reloadItems(at: indexPathsToReload) { collectionView in print(collectionView) }

// or
collectionView.reloadSections(IndexSet(integer: 0)) { collectionView in print(collectionView) }

Vollständige Probe

Vergessen Sie nicht, den Lösungscode hier hinzuzufügen

import UIKit

class ViewController: UIViewController {

    private weak var navigationBar: UINavigationBar?
    private weak var tableView: UITableView?

    override func viewDidLoad() {
        super.viewDidLoad()
        setupNavigationItem()
        setupTableView()
    }
}
// MARK: - Activate UITableView reloadData with completion functions

extension UITableView: ReloadCompletable { }

// MARK: - Setup(init) subviews

extension ViewController {

    private func setupTableView() {
        guard let navigationBar = navigationBar else { return }
        let tableView = UITableView()
        view.addSubview(tableView)
        tableView.translatesAutoresizingMaskIntoConstraints = false
        tableView.topAnchor.constraint(equalTo: navigationBar.bottomAnchor).isActive = true
        tableView.leftAnchor.constraint(equalTo: view.leftAnchor).isActive = true
        tableView.rightAnchor.constraint(equalTo: view.rightAnchor).isActive = true
        tableView.bottomAnchor.constraint(equalTo: view.bottomAnchor).isActive = true
        tableView.dataSource = self
        self.tableView = tableView
    }

    private func setupNavigationItem() {
        let navigationBar = UINavigationBar()
        view.addSubview(navigationBar)
        self.navigationBar = navigationBar
        navigationBar.translatesAutoresizingMaskIntoConstraints = false
        navigationBar.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor).isActive = true
        navigationBar.leftAnchor.constraint(equalTo: view.leftAnchor).isActive = true
        navigationBar.rightAnchor.constraint(equalTo: view.rightAnchor).isActive = true
        let navigationItem = UINavigationItem()
        navigationItem.rightBarButtonItem = UIBarButtonItem(title: "all", style: .plain, target: self, action: #selector(reloadAllCellsButtonTouchedUpInside(source:)))
        let buttons: [UIBarButtonItem] = [
                                            .init(title: "row", style: .plain, target: self,
                                                  action: #selector(reloadRowButtonTouchedUpInside(source:))),
                                            .init(title: "section", style: .plain, target: self,
                                                  action: #selector(reloadSectionButtonTouchedUpInside(source:)))
                                            ]
        navigationItem.leftBarButtonItems = buttons
        navigationBar.items = [navigationItem]
    }
}

// MARK: - Buttons actions

extension ViewController {

    @objc func reloadAllCellsButtonTouchedUpInside(source: UIBarButtonItem) {
        let elementsName = "Data"
        print("-- Reloading \(elementsName) started")
        tableView?.reloadData { taleView in
            print("-- Reloading \(elementsName) stopped \(taleView)")
        }
    }

    private var randomRowAnimation: UITableView.RowAnimation {
        return UITableView.RowAnimation(rawValue: (0...6).randomElement() ?? 0) ?? UITableView.RowAnimation.automatic
    }

    @objc func reloadRowButtonTouchedUpInside(source: UIBarButtonItem) {
        guard let tableView = tableView else { return }
        let elementsName = "Rows"
        print("-- Reloading \(elementsName) started")
        let indexPathToReload = tableView.indexPathsForVisibleRows?.randomElement() ?? IndexPath(row: 0, section: 0)
        tableView.reloadRows(at: [indexPathToReload], with: randomRowAnimation) { _tableView in
            //print("-- \(taleView)")
            print("-- Reloading \(elementsName) stopped in \(_tableView)")
        }
    }

    @objc func reloadSectionButtonTouchedUpInside(source: UIBarButtonItem) {
        guard let tableView = tableView else { return }
        let elementsName = "Sections"
        print("-- Reloading \(elementsName) started")
        tableView.reloadSections(IndexSet(integer: 0), with: randomRowAnimation) { _tableView in
            //print("-- \(taleView)")
            print("-- Reloading \(elementsName) stopped in \(_tableView)")
        }
    }
}

extension ViewController: UITableViewDataSource {
    func numberOfSections(in tableView: UITableView) -> Int { return 1 }
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int { return 20 }
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = UITableViewCell()
        cell.textLabel?.text = "\(Date())"
        return cell
    }
}

Ergebnisse

Nur um einen anderen Ansatz anzubieten, basierend auf der Idee, dass die Fertigstellung die 'letzte sichtbare' Zelle ist, an die gesendet werden soll cellForRow.

// Will be set when reload is called
var lastIndexPathToDisplay: IndexPath?

typealias ReloadCompletion = ()->Void

var reloadCompletion: ReloadCompletion?

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {

    // Setup cell

    if indexPath == self.lastIndexPathToDisplay {

        self.lastIndexPathToDisplay = nil

        self.reloadCompletion?()
        self.reloadCompletion = nil
    }

    // Return cell
...

func reloadData(completion: @escaping ReloadCompletion) {

    self.reloadCompletion = completion

    self.mainTable.reloadData()

    self.lastIndexPathToDisplay = self.mainTable.indexPathsForVisibleRows?.last
}

Ein mögliches Problem ist: Wenn reloadData()der Vorgang vor dem lastIndexPathToDisplayFestlegen abgeschlossen wurde, wird die 'letzte sichtbare' Zelle angezeigt, bevor sie festgelegt lastIndexPathToDisplaywurde, und der Abschluss wird nicht aufgerufen (und befindet sich im Status 'Warten'):

self.mainTable.reloadData()

// cellForRowAt could be finished here, before setting `lastIndexPathToDisplay`

self.lastIndexPathToDisplay = self.mainTable.indexPathsForVisibleRows?.last

Wenn wir umkehren, könnte die Fertigstellung durch vorheriges Scrollen ausgelöst werden reloadData().

self.lastIndexPathToDisplay = self.mainTable.indexPathsForVisibleRows?.last

// cellForRowAt could trigger the completion by scrolling here since we arm 'lastIndexPathToDisplay' before 'reloadData()'

self.mainTable.reloadData()

Versuche dies:

tableView.backgroundColor = .black

tableView.reloadData()

DispatchQueue.main.async(execute: {

    tableView.backgroundColor = .green

})

Die tableView-Farbe wird erst nach Abschluss der reloadData()Funktion von schwarz nach grün geändert .

Sie können die Funktion performBatchUpdates von uitableview verwenden

So können Sie erreichen

self.tableView.performBatchUpdates({

      //Perform reload
        self.tableView.reloadData()
    }) { (completed) in

        //Reload Completed Use your code here
    }

Erstellen einer wiederverwendbaren Erweiterung von CATransaction:

public extension CATransaction {
    static func perform(method: () -> Void, completion: @escaping () -> Void) {
        begin()
        setCompletionBlock {
            completion()
        }
        method()
        commit()
    }
}

Erstellen Sie nun eine Erweiterung von UITableView, die die Erweiterungsmethode von CATransaction verwendet:

public extension UITableView {
    func reloadData(completion: @escaping (() -> Void)) {
       CATransaction.perform(method: {
           reloadData()
       }, completion: completion)
    }
}

Verwendung:

tableView.reloadData(completion: {
    //Do the stuff
})

Sie können es verwenden, um nach dem erneuten Laden von Daten etwas zu tun:

[UIView animateWithDuration:0 animations:^{
    [self.contentTableView reloadData];
} completion:^(BOOL finished) {
    _isUnderwritingUpdate = NO;
}];

Versuchen Sie, Verzögerungen einzustellen:

[_tableView performSelector:@selector(reloadData) withObject:nil afterDelay:0.2];
[_activityIndicator performSelector:@selector(stopAnimating) withObject:nil afterDelay:0.2];