UITableView完成查询数据后会收到通知吗？

有什么方法可以找出何时UITableView从其数据源中查询数据？

的无viewDidLoad/ viewWillAppear/ viewDidAppear关联的视图控制器（方法UITableViewController）是使用在这里，因为他们都火得太早。它们（完全可以理解）都不能保证对数据源的查询暂时已经完成（例如，直到视图滚动为止）。

一个解决办法，我发现是调用reloadData的viewDidAppear，因为当reloadData返回时，表视图是保证完成查询数据源，它更需要的时间存在。

但是，这似乎有点令人讨厌，因为我认为这会导致在reloadData首次加载数据源时两次（自动一次，由于调用而一次）要求输入相同的信息。

我要执行此操作的原因是我想保留-的滚动位置，UITableView但要一直到像素级别，而不仅仅是到最近的行。

当恢复滚动位置（使用scrollRectToVisible:animated:），我需要的表视图已经有足够的数据在里面，否则scrollRectToVisible:animated:方法调用什么也不做（这是如果你把它自己的呼叫任何会发生什么viewDidLoad，viewWillAppear或viewDidAppear）。

由于自编写答案以来对UITableView实现进行了一些更改，因此该答案似乎不再有效。看到这个评论：UITableView完成请求数据时得到通知？

我一直在玩这个问题困扰了几天，觉得子类UITableView的reloadData是最好的方法：

- (void)reloadData {

    NSLog(@"BEGIN reloadData");

    [super reloadData];

    NSLog(@"END reloadData");

}

reloadData在表完成重新加载其数据之前不会结束。因此，当第二个NSLog被触发时，表视图实际上已经完成了对数据的查询。

我已经将其子类化UITableView，以便在之前和之后将方法发送给委托reloadData。它像一种魅力。

我的应用中确实有相同的情况，并认为会将我的答案发布给大家，因为此处提到的其他答案不适用于iOS7和更高版本

最后，这是唯一为我解决的问题。

[yourTableview reloadData];

dispatch_async(dispatch_get_main_queue(),^{
        NSIndexPath *path = [NSIndexPath indexPathForRow:yourRow inSection:yourSection];
        //Basically maintain your logic to get the indexpath
        [yourTableview scrollToRowAtIndexPath:path atScrollPosition:UITableViewScrollPositionTop animated:YES];
 });

快速更新：

yourTableview.reloadData()
dispatch_async(dispatch_get_main_queue(), { () -> Void in
    let path : NSIndexPath = NSIndexPath(forRow: myRowValue, inSection: mySectionValue)
    //Basically maintain your logic to get the indexpath
    yourTableview.scrollToRowAtIndexPath(path, atScrollPosition: UITableViewScrollPosition.Top, animated: true)

})

那么这是如何工作的。

基本上，当您进行重新加载时，主线程会变得繁忙，因此，当我们执行分派异步线程时，该块将等待直到主线程完成。因此，一旦tableview被完全加载，主线程将完成，因此将分派我们的方法块

在iOS7和iOS8中进行了测试，效果很棒；）

iOS9更新： iOS9也可以正常工作。我已经在github中创建了一个示例项目作为POC。 https://github.com/ipraba/TableReloadingNotifier

我在这里附上我的测试屏幕截图。

测试环境：Xcode7的iOS9 iPhone6模拟器

编辑：这个答案实际上不是解决方案。乍一看似乎可行，因为重新加载可以很快进行，但是实际上，在数据完全完成重新加载之后，不一定会调用完成块-因为reloadData不会阻止。您可能应该寻找更好的解决方案。

为了扩展@Eric MORAND的答案，让我们输入一个完成代码块。谁不喜欢一个代码块？

@interface DUTableView : UITableView

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

@end

和...

#import "DUTableView.h"

@implementation DUTableView

- (void) reloadDataWithCompletion:( void (^) (void) )completionBlock {
    [super reloadData];
    if(completionBlock) {
        completionBlock();
    }
}

@end

用法：

[self.tableView reloadDataWithCompletion:^{
                                            //do your stuff here
                                        }];

reloadData只是询问可见单元的数据。说，要在表的指定部分加载时收到通知，请挂钩该tableView: willDisplayCell:方法。

- (void) reloadDisplayData
{
    isLoading =  YES;
    NSLog(@"Reload display with last index %d", lastIndex);
    [_tableView reloadData];
    if(lastIndex <= 0){
    isLoading = YES;
    //Notify completed
}

- (void) tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath
{
    if(indexPath.row >= lastIndex){
    isLoading = NO;
    //Notify completed
}

那是我的解决方案。100％可以在许多项目中使用。这是一个简单的UITableView子类。

@protocol MyTableViewDelegate<NSObject, UITableViewDelegate>
@optional
- (void)tableViewWillReloadData:(UITableView *)tableView;
- (void)tableViewDidReloadData:(UITableView *)tableView;
@end

@interface MyTableView : UITableView {
    struct {
        unsigned int delegateWillReloadData:1;
        unsigned int delegateDidReloadData:1;
        unsigned int reloading:1;
    } _flags;
}
@end

@implementation MyTableView
- (id<MyTableViewDelegate>)delegate {
    return (id<MyTableViewDelegate>)[super delegate];
}

- (void)setDelegate:(id<MyTableViewDelegate>)delegate {
    [super setDelegate:delegate];
    _flags.delegateWillReloadData = [delegate respondsToSelector:@selector(tableViewWillReloadData:)];
    _flags.delegateDidReloadData = [delegate    respondsToSelector:@selector(tableViewDidReloadData:)];
}

- (void)reloadData {
    [super reloadData];
    if (_flags.reloading == NO) {
        _flags.reloading = YES;
        if (_flags.delegateWillReloadData) {
            [(id<MyTableViewDelegate>)self.delegate tableViewWillReloadData:self];
        }
        [self performSelector:@selector(finishReload) withObject:nil afterDelay:0.0f];
    }
}

- (void)finishReload {
    _flags.reloading = NO;
    if (_flags.delegateDidReloadData) {
        [(id<MyTableViewDelegate>)self.delegate tableViewDidReloadData:self];
    }
}

@end

除了一个例外，它类似于乔什·布朗的解决方案。performSelector方法无需延迟。不管reloadData需要多长时间。问完tableViewDidLoadData:总是开枪。tableViewdataSource cellForRowAtIndexPath

即使您不想继承子类，UITableView也可以简单地调用，[performSelector:@selector(finishReload) withObject:nil afterDelay:0.0f]并且在表重新加载完成后立即调用选择器。但是，您应确保每次调用时只会调用一次选择器reloadData：

[self.tableView reloadData];
[self performSelector:@selector(finishReload) withObject:nil afterDelay:0.0f];

请享用。:)

这是对一个稍有不同的问题的解答：我需要知道何时UITableView还打电话cellForRowAtIndexPath()。我layoutSubviews()继承了子类（感谢@Eric MORAND）并添加了委托回调：

SDTableView.h：

@protocol SDTableViewDelegate <NSObject, UITableViewDelegate>
@required
- (void)willReloadData;
- (void)didReloadData;
- (void)willLayoutSubviews;
- (void)didLayoutSubviews;
@end

@interface SDTableView : UITableView

@property(nonatomic,assign) id <SDTableViewDelegate> delegate;

@end;

SDTableView.m：

#import "SDTableView.h"

@implementation SDTableView

@dynamic delegate;

- (void) reloadData {
    [self.delegate willReloadData];

    [super reloadData];

    [self.delegate didReloadData];
}

- (void) layoutSubviews {
    [self.delegate willLayoutSubviews];

    [super layoutSubviews];

    [self.delegate didLayoutSubviews];
}

@end

用法：

MyTableViewController.h：

#import "SDTableView.h"
@interface MyTableViewController : UITableViewController <SDTableViewDelegate>
@property (nonatomic) BOOL reloadInProgress;

MyTableViewController.m：

#import "MyTableViewController.h"
@implementation MyTableViewController
@synthesize reloadInProgress;

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {

    if ( ! reloadInProgress) {
        NSLog(@"---- numberOfSectionsInTableView(): reloadInProgress=TRUE");
        reloadInProgress = TRUE;
    }

    return 1;
}

- (void)willReloadData {}
- (void)didReloadData {}
- (void)willLayoutSubviews {}

- (void)didLayoutSubviews {
    if (reloadInProgress) {
        NSLog(@"---- layoutSubviewsEnd(): reloadInProgress=FALSE");
        reloadInProgress = FALSE;
    }
}

注意： 由于这是一个子类，UITableView因此已经有一个委托属性，它指向MyTableViewController无需再添加一个委托属性。“ @动态委托”告诉编译器使用此属性。（以下是描述此链接：http : //farhadnoorzay.com/2012/01/20/objective-c-how-to-add-delegate-methods-in-a-subclass/）

必须更改中的UITableView属性MyTableViewController以使用新SDTableView类。这是在Interface Builder身份检查器中完成的。选择的UITableView内部，UITableViewController并将其“自定义类”设置为SDTableView。

我已经发现了类似以获取更改通知的东西contentSize的TableView。我认为这也应该在这里工作，因为contentSize也随着加载数据而变化。

试试这个：

在viewDidLoad书面上，

[self.tableView addObserver:self forKeyPath:@"contentSize" options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionOld | NSKeyValueObservingOptionPrior context:NULL];

并将此方法添加到您的viewController中：

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
    if ([keyPath isEqualToString:@"contentSize"]) {
        DLog(@"change = %@", change.description)

        NSValue *new = [change valueForKey:@"new"];
        NSValue *old = [change valueForKey:@"old"];

        if (new && old) {
            if (![old isEqualToValue:new]) {
                // do your stuff
            }
        }


    }
}

您可能需要在更改检查中稍作修改。虽然这对我有用。

干杯! :)

这是一个可能的解决方案，尽管它是一个hack：

[self.tableView reloadData];
[self performSelector:@selector(scrollTableView) withObject:nil afterDelay:0.3];

您的-scrollTableView方法使用滚动表格视图的位置-scrollRectToVisible:animated:。而且，当然，您可以将上述代码中的延迟从0.3配置为适合您的延迟。是的，这很荒谬，但是它可以在我的iPhone 5和4S上使用。

我相信我也有类似的事情。我添加了一个BOOL作为实例变量，该变量告诉我偏移量是否已还原，并在中进行检查-viewWillAppear:。当尚未还原时，我用该方法还原它，并将BOOL设置为指示我确实恢复了偏移量。

这是一种破解，可能可以做得更好，但是此刻对我而言有效。

听起来好像您要更新单元格内容，但要避免单元格插入和删除伴随的突然跳跃。

有几篇有关此操作的文章。 这是一。

我建议使用setContentOffset：animated：而不是scrollRectToVisible：animated：来实现滚动视图的像素完美设置。

您可以尝试以下逻辑：

-(UITableViewCell *) tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"MyIdentifier"];

    if (cell == nil) {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:@"MyIdentifier"];
        cell.selectionStyle = UITableViewCellSelectionStyleNone;
    }

    if ( [self chkIfLastCellIndexToCreate:tableView :indexPath]){
        NSLog(@"Created Last Cell. IndexPath = %@", indexPath);
        //[self.activityIndicator hide];
        //Do the task for TableView Loading Finished
    }
    prevIndexPath = indexPath;

    return cell;
}



-(BOOL) chkIfLastCellIndexToCreate:(UITableView*)tableView : (NSIndexPath *)indexPath{

    BOOL bRetVal = NO;
    NSArray *visibleIndices = [tableView indexPathsForVisibleRows];

    if (!visibleIndices || ![visibleIndices count])
        bRetVal = YES;

    NSIndexPath *firstVisibleIP = [visibleIndices objectAtIndex:0];
    NSIndexPath *lastVisibleIP = [visibleIndices objectAtIndex:[visibleIndices count]-1];

    if ((indexPath.row > prevIndexPath.row) && (indexPath.section >= prevIndexPath.section)){
        //Ascending - scrolling up
        if ([indexPath isEqual:lastVisibleIP]) {
            bRetVal = YES;
            //NSLog(@"Last Loading Cell :: %@", indexPath);
        }
    } else if ((indexPath.row < prevIndexPath.row) && (indexPath.section <= prevIndexPath.section)) {
        //Descending - scrolling down
        if ([indexPath isEqual:firstVisibleIP]) {
            bRetVal = YES;
            //NSLog(@"Last Loading Cell :: %@", indexPath);
        }
    }
    return bRetVal;
}

在调用reloadData之前，请将prevIndexPath设置为nil。喜欢：

prevIndexPath = nil;
[mainTableView reloadData];

我使用NSLogs进行了测试，这种逻辑看起来还可以。您可以根据需要自定义/改进。

终于我使我的代码可以使用了-

[tableView scrollToRowAtIndexPath:scrollToIndex atScrollPosition:UITableViewScrollPositionTop animated:YES];

有几件事需要照顾-

1. 在“ - (UITableViewCell *)MyTableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath” 内称呼它
2. 只需确保将“ scrollToRowAtIndexPath”消息发送到UITableView的相关实例即可，在这种情况下，该实例肯定是MyTableview。
3. 在我的情况下，UIView是包含UITableView实例的视图
4. 同样，将为每个单元负载调用此方法。因此，请在“ cellForRowAtIndexPath”内部放置一个逻辑，以避免多次调用“ scrollToRowAtIndexPath”。

加载所有数据后，可以使用以下方法调整表格视图的大小或设置其内容大小：

- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath
{
    tableView.frame =CGRectMake(tableView.frame.origin.x, tableView.frame.origin.y, tableView.frame.size.width, tableView.contentSize.height);
}

我只是运行重复的计划计时器，并且仅当tableHeaderView高度（表中存在行内容）时表的contentSize较大时才使它无效。C＃（monotouch）中的代码，但我希望这个想法很清楚：

    public override void ReloadTableData()
    {
        base.ReloadTableData();

        // don't do anything if there is no data
        if (ItemsSource != null && ItemsSource.Length > 0)
        {
            _timer = NSTimer.CreateRepeatingScheduledTimer(TimeSpan.MinValue, 
                new NSAction(() => 
                {
                    // make sure that table has header view and content size is big enought
                    if (TableView.TableHeaderView != null &&
                        TableView.ContentSize.Height > 
                            TableView.TableHeaderView.Frame.Height)
                    {
                        TableView.SetContentOffset(
                            new PointF(0, TableView.TableHeaderView.Frame.Height), false);
                        _timer.Invalidate();
                        _timer = null;
                    }
                }));
        }
    }

是不是UITableView layoutSubviews在表格视图显示内容之前就调用了它？我注意到，一旦表视图完成了其数据的加载，便会调用它，也许您应该朝这个方向进行研究。

从iOS 6开始，UITableview委托方法调用：

-(void)tableView:(UITableView *)tableView willDisplayHeaderView:(UIView *)view forSection:(NSInteger)section

成功加载表后，将执行。您可以根据需要在此方法中进行自定义。

我在Swift中找到的最佳解决方案

extension UITableView {
    func reloadData(completion: ()->()) {
        self.reloadData()
        dispatch_async(dispatch_get_main_queue()) {
            completion()
        }
    }
}

为什么不只是扩展？

@interface UITableView(reloadComplete)
- (void) reloadDataWithCompletion:( void (^) (void) )completionBlock;
@end

@implementation UITableView(reloadComplete)
- (void) reloadDataWithCompletion:( void (^) (void) )completionBlock {
    [self reloadData];
    if(completionBlock) {
        completionBlock();
    }
}
@end

滚动到末尾：

[self.table reloadDataWithCompletion:^{
    NSInteger numberOfRows = [self.table numberOfRowsInSection:0];
    if (numberOfRows > 0)
    {
        NSIndexPath *indexPath = [NSIndexPath indexPathForRow:numberOfRows-1 inSection:0];
        [self.table scrollToRowAtIndexPath:indexPath atScrollPosition:UITableViewScrollPositionTop animated:NO];
    }
}];

未经大量数据测试