UICollectionView reloadData 在 iOS 7 中无法正常运行

UICollectionView reloadData not functioning properly in iOS 7

提问by VaporwareWolf

I've been updating my apps to run on iOS 7 which is going smoothly for the most part. I have noticed in more than one app that the reloadDatamethod of a UICollectionViewControllerisn't acting quite how it used to.

我一直在更新我的应用程序以在 iOS 7 上运行，这在大多数情况下进展顺利。我在不止一个应用程序中注意到reloadDataa的方法UICollectionViewController不像以前那样表现得很好。

I'll load the UICollectionViewController, populate the UICollectionViewwith some data as normal. This works great on the first time. However if I request new data (populate the UICollectionViewDataSource), and then call reloadData, it will query the data source for numberOfItemsInSectionand numberOfSectionsInCollectionView, but it doesn't seem to call cellForItemAtIndexPaththe proper number of times.

我会像往常一样加载UICollectionViewController、填充UICollectionView一些数据。这在第一次很有效。但是，如果我要求新数据（填充UICollectionViewDataSource），然后调用reloadData，它将查询数据源numberOfItemsInSection和numberOfSectionsInCollectionView，但它似乎并没有调用cellForItemAtIndexPath的次数适当数量。

If I change the code to only reload one section, then it will function properly. This is no problem for me to change these, but I don't think I should have to. reloadDatashould reload all visible cells according to the documentation.

如果我将代码更改为仅重新加载一个部分，那么它将正常运行。改变这些对我来说没有问题，但我认为我不应该这样做。reloadData应根据文档重新加载所有可见单元格。

Has anyone else seen this?

有没有其他人看到这个？

回答by Shaunti Fondrisi

Force this on the main thread:

在主线程上强制执行此操作：

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

回答by liamnichols

In my case, the number of cells/sections in the datasource never changed and I just wanted to reload the visible content on the screen..

就我而言，数据源中单元格/部分的数量从未改变，我只想重新加载屏幕上的可见内容..

I managed to get around this by calling:

我设法通过调用来解决这个问题：

[self.collectionView reloadItemsAtIndexPaths:[self.collectionView indexPathsForVisibleItems]];

then:

然后：

[self.collectionView reloadData];

回答by Anton Matosov

I had exactly the same issue, however I managed to find what was going on wrong. In my case I was calling reloadDatafrom the collectionView:cellForItemAtIndexPath:which looks not to be correct.

我遇到了完全相同的问题，但是我设法找到了问题所在。在我的情况下，我从collectionView:cellForItemAtIndexPath:调用reloadData :这看起来不正确。

Dispatching call of reloadDatato the main queue fixed the problem once and forever.

将reloadData 的调用分派到主队列一劳永逸地解决了这个问题。

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

回答by miguelsanchez

Reloading some items didn't work for me. In my case, and only because the collectionView I'm using has just one section, I simply reload that particular section. This time the contents are correctly reloaded. Weird that this is only happening on iOS 7 (7.0.3)

重新加载一些项目对我不起作用。就我而言，仅因为我使用的 collectionView 只有一个部分，我只需重新加载该特定部分。这次内容正确地重新加载。奇怪的是，这仅发生在 iOS 7 (7.0.3) 上

[self.collectionView reloadSections:[NSIndexSet indexSetWithIndex:0]];

回答by dimpiax

Swift 5 – 4 – 3

斯威夫特 5 – 4 – 3

// GCD    
DispatchQueue.main.async(execute: collectionView.reloadData)

// Operation
OperationQueue.main.addOperation(collectionView.reloadData)

Swift 2

斯威夫特 2

// Operation
NSOperationQueue.mainQueue().addOperationWithBlock(collectionView.reloadData)

回答by user2459624

I had the same issue with reloadData on iOS 7. After long debug session, I found the problem.

我在 iOS 7 上的 reloadData 遇到了同样的问题。经过长时间的调试会话，我发现了问题。

On iOS7, reloadData on UICollectionView doesn't cancel previous updates which haven't completed yet (Updates which called inside performBatchUpdates: block).

在 iOS7 上， UICollectionView 上的 reloadData 不会取消尚未完成的先前更新（在 performBatchUpdates: 块中调用的更新）。

The best solution to solve this bug, is stopping all updates which currently processed and call reloadData. I didn't find a way to cancel or stop a block of performBatchUpdates. Therefore, to solve the bug, I saved a flag which indicates if there's a performBatchUpdates block which currently processed. If there isn't an update block which currently processed, I can call reloadData immediately and everything work as expected. If there's an update block which currently processed, I'll call reloadData on the complete block of performBatchUpdates.

解决此错误的最佳解决方案是停止当前正在处理的所有更新并调用 reloadData。我没有找到取消或停止一块 performBatchUpdates 的方法。因此，为了解决这个错误，我保存了一个标志，指示当前是否有一个 performBatchUpdates 块正在处理。如果没有当前处理的更新块，我可以立即调用 reloadData 并且一切都按预期工作。如果有当前正在处理的更新块，我将在 performBatchUpdates 的完整块上调用 reloadData。

回答by Avner Barr

I also had this problem. By coincidence I added a button on top of the collectionview in order to force reloading for testing - and all of a sudden the methods started getting called.

我也有这个问题。巧合的是，我在 collectionview 顶部添加了一个按钮，以强制重新加载进行测试 - 突然间这些方法开始被调用。

Also just adding something as simple as

也只是添加一些简单的东西

UIView *aView = [UIView new];
[collectionView addSubView:aView];

would cause the methods to be called

会导致方法被调用

Also I played around with the frame size - and voila the methods were getting called.

我还尝试了帧大小 - 瞧，这些方法被调用了。

There are a lot of bugs with iOS7 UICollectionView.

iOS7 UICollectionView 有很多错误。

回答by iDevAmit

You can use this method

你可以使用这个方法

[collectionView reloadItemsAtIndexPaths:arayOfAllIndexPaths];

You can add all indexPathobjects of your UICollectionViewinto array arrayOfAllIndexPathsby iterating the loop for all sections and rows with use of below method

您可以通过使用以下方法迭代所有部分和行的循环，将所有indexPath对象添加UICollectionView到数组arrayOfAllIndexPaths中

[aray addObject:[NSIndexPath indexPathForItem:j inSection:i]];

I hope you understood and it can resolve your problem. If you need any more explanation please reply.

我希望你理解，它可以解决你的问题。如果您需要更多解释，请回复。

回答by WeZZard

The solution given by Shaunti Fondrisi is nearly perfect. But such a piece of code or codes like enqueue the execution of UICollectionView's reloadData()to NSOperationQueue's mainQueueindeed puts the execution timing to the beginning of the next event loop in the run loop, which could make the UICollectionViewupdate with a flick.

Shaunti Fondrisi 给出的解决方案几乎是完美的。但是这样的一段代码或类似 enqueue the execution of UICollectionView's reloadData()to NSOperationQueue's 的代码mainQueue确实将执行时间放在运行循环中的下一个事件循环的开头，这可以使UICollectionView更新轻弹。

To solve this issue. We must put the execution timing of the same piece of code to the end of current event loop but not the beginning of the next. And we can achieve this by making use of CFRunLoopObserver.

为了解决这个问题。我们必须将同一段代码的执行时间放在当前事件循环的末尾，而不是下一个事件循环的开始。我们可以通过使用CFRunLoopObserver.

CFRunLoopObserverobserves all the input source waiting activities and the run loop's entry and exit activity.

CFRunLoopObserver观察所有输入源等待活动和运行循环的进入和退出活动。

public struct CFRunLoopActivity : OptionSetType {
    public init(rawValue: CFOptionFlags)

    public static var Entry: CFRunLoopActivity { get }
    public static var BeforeTimers: CFRunLoopActivity { get }
    public static var BeforeSources: CFRunLoopActivity { get }
    public static var BeforeWaiting: CFRunLoopActivity { get }
    public static var AfterWaiting: CFRunLoopActivity { get }
    public static var Exit: CFRunLoopActivity { get }
    public static var AllActivities: CFRunLoopActivity { get }
}

Among those activities, .AfterWaitingcan be observed when current event loop is about to end, and .BeforeWaitingcan be observed when the next event loop just has began.

在这些活动中，.AfterWaiting可以在当前事件循环即将结束.BeforeWaiting时观察到，也可以在下一个事件循环刚刚开始时观察到。

As there is only one NSRunLoopinstance per NSThreadand NSRunLoopexactly drives the NSThread, we can consider that accesses come from the same NSRunLoopinstance always never cross threads.

由于每个NSRunLoop实例只有一个NSThread并且NSRunLoop正好驱动NSThread，我们可以认为来自同一个NSRunLoop实例的访问永远不会跨线程。

Based on points mentioned before, we can now write the code: an NSRunLoop-based task dispatcher:

基于之前提到的几点，我们现在可以编写代码：一个基于 NSRunLoop 的任务调度器：

import Foundation
import ObjectiveC

public struct Weak<T: AnyObject>: Hashable {
    private weak var _value: T?
    public weak var value: T? { return _value }
    public init(_ aValue: T) { _value = aValue }

    public var hashValue: Int {
        guard let value = self.value else { return 0 }
        return ObjectIdentifier(value).hashValue
    }
}

public func ==<T: AnyObject where T: Equatable>(lhs: Weak<T>, rhs: Weak<T>)
    -> Bool
{
    return lhs.value == rhs.value
}

public func ==<T: AnyObject>(lhs: Weak<T>, rhs: Weak<T>) -> Bool {
    return lhs.value === rhs.value
}

public func ===<T: AnyObject>(lhs: Weak<T>, rhs: Weak<T>) -> Bool {
    return lhs.value === rhs.value
}

private var dispatchObserverKey =
"com.WeZZard.Nest.NSRunLoop.TaskDispatcher.DispatchObserver"

private var taskQueueKey =
"com.WeZZard.Nest.NSRunLoop.TaskDispatcher.TaskQueue"

private var taskAmendQueueKey =
"com.WeZZard.Nest.NSRunLoop.TaskDispatcher.TaskAmendQueue"

private typealias DeallocFunctionPointer =
    @convention(c) (Unmanaged<NSRunLoop>, Selector) -> Void

private var original_dealloc_imp: IMP?

private let swizzled_dealloc_imp: DeallocFunctionPointer = {
    (aSelf: Unmanaged<NSRunLoop>,
    aSelector: Selector)
    -> Void in

    let unretainedSelf = aSelf.takeUnretainedValue()

    if unretainedSelf.isDispatchObserverLoaded {
        let observer = unretainedSelf.dispatchObserver
        CFRunLoopObserverInvalidate(observer)
    }

    if let original_dealloc_imp = original_dealloc_imp {
        let originalDealloc = unsafeBitCast(original_dealloc_imp,
            DeallocFunctionPointer.self)
        originalDealloc(aSelf, aSelector)
    } else {
        fatalError("The original implementation of dealloc for NSRunLoop cannot be found!")
    }
}

public enum NSRunLoopTaskInvokeTiming: Int {
    case NextLoopBegan
    case CurrentLoopEnded
    case Idle
}

extension NSRunLoop {

    public func perform(closure: ()->Void) -> Task {
        objc_sync_enter(self)
        loadDispatchObserverIfNeeded()
        let task = Task(self, closure)
        taskQueue.append(task)
        objc_sync_exit(self)
        return task
    }

    public override class func initialize() {
        super.initialize()

        struct Static {
            static var token: dispatch_once_t = 0
        }
        // make sure this isn't a subclass
        if self !== NSRunLoop.self {
            return
        }

        dispatch_once(&Static.token) {
            let selectorDealloc: Selector = "dealloc"
            original_dealloc_imp =
                class_getMethodImplementation(self, selectorDealloc)

            let swizzled_dealloc = unsafeBitCast(swizzled_dealloc_imp, IMP.self)

            class_replaceMethod(self, selectorDealloc, swizzled_dealloc, "@:")
        }
    }

    public final class Task {
        private let weakRunLoop: Weak<NSRunLoop>

        private var _invokeTiming: NSRunLoopTaskInvokeTiming
        private var invokeTiming: NSRunLoopTaskInvokeTiming {
            var theInvokeTiming: NSRunLoopTaskInvokeTiming = .NextLoopBegan
            guard let amendQueue = weakRunLoop.value?.taskAmendQueue else {
                fatalError("Accessing a dealloced run loop")
            }
            dispatch_sync(amendQueue) { () -> Void in
                theInvokeTiming = self._invokeTiming
            }
            return theInvokeTiming
        }

        private var _modes: NSRunLoopMode
        private var modes: NSRunLoopMode {
            var theModes: NSRunLoopMode = []
            guard let amendQueue = weakRunLoop.value?.taskAmendQueue else {
                fatalError("Accessing a dealloced run loop")
            }
            dispatch_sync(amendQueue) { () -> Void in
                theModes = self._modes
            }
            return theModes
        }

        private let closure: () -> Void

        private init(_ runLoop: NSRunLoop, _ aClosure: () -> Void) {
            weakRunLoop = Weak<NSRunLoop>(runLoop)
            _invokeTiming = .NextLoopBegan
            _modes = .defaultMode
            closure = aClosure
        }

        public func forModes(modes: NSRunLoopMode) -> Task {
            if let amendQueue = weakRunLoop.value?.taskAmendQueue {
                dispatch_async(amendQueue) { [weak self] () -> Void in
                    self?._modes = modes
                }
            }
            return self
        }

        public func when(invokeTiming: NSRunLoopTaskInvokeTiming) -> Task {
            if let amendQueue = weakRunLoop.value?.taskAmendQueue {
                dispatch_async(amendQueue) { [weak self] () -> Void in
                    self?._invokeTiming = invokeTiming
                }
            }
            return self
        }
    }

    private var isDispatchObserverLoaded: Bool {
        return objc_getAssociatedObject(self, &dispatchObserverKey) !== nil
    }

    private func loadDispatchObserverIfNeeded() {
        if !isDispatchObserverLoaded {
            let invokeTimings: [NSRunLoopTaskInvokeTiming] =
            [.CurrentLoopEnded, .NextLoopBegan, .Idle]

            let activities =
            CFRunLoopActivity(invokeTimings.map{ CFRunLoopActivity(
NSRunLoop.currentRunLoop().perform({ () -> Void in
     collectionView.reloadData()
    }).when(.CurrentLoopEnded)
) })

            let observer = CFRunLoopObserverCreateWithHandler(
                kCFAllocatorDefault,
                activities.rawValue,
                true, 0,
                handleRunLoopActivityWithObserver)

            CFRunLoopAddObserver(getCFRunLoop(),
                observer,
                kCFRunLoopCommonModes)

            let wrappedObserver = NSAssociated<CFRunLoopObserver>(observer)

            objc_setAssociatedObject(self,
                &dispatchObserverKey,
                wrappedObserver,
                .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
    }

    private var dispatchObserver: CFRunLoopObserver {
        loadDispatchObserverIfNeeded()
        return (objc_getAssociatedObject(self, &dispatchObserverKey)
            as! NSAssociated<CFRunLoopObserver>)
            .value
    }

    private var taskQueue: [Task] {
        get {
            if let taskQueue = objc_getAssociatedObject(self,
                &taskQueueKey)
                as? [Task]
            {
                return taskQueue
            } else {
                let initialValue = [Task]()

                objc_setAssociatedObject(self,
                    &taskQueueKey,
                    initialValue,
                    .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

                return initialValue
            }
        }
        set {
            objc_setAssociatedObject(self,
                &taskQueueKey,
                newValue,
                .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

        }
    }

    private var taskAmendQueue: dispatch_queue_t {
        if let taskQueue = objc_getAssociatedObject(self,
            &taskAmendQueueKey)
            as? dispatch_queue_t
        {
            return taskQueue
        } else {
            let initialValue =
            dispatch_queue_create(
                "com.WeZZard.Nest.NSRunLoop.TaskDispatcher.TaskAmendQueue",
                DISPATCH_QUEUE_SERIAL)

            objc_setAssociatedObject(self,
                &taskAmendQueueKey,
                initialValue,
                .OBJC_ASSOCIATION_RETAIN_NONATOMIC)

            return initialValue
        }
    }

    private func handleRunLoopActivityWithObserver(observer: CFRunLoopObserver!,
        activity: CFRunLoopActivity)
        -> Void
    {
        var removedIndices = [Int]()

        let runLoopMode: NSRunLoopMode = currentRunLoopMode

        for (index, eachTask) in taskQueue.enumerate() {
            let expectedRunLoopModes = eachTask.modes
            let expectedRunLoopActivitiy =
            CFRunLoopActivity(eachTask.invokeTiming)

            let runLoopModesMatches = expectedRunLoopModes.contains(runLoopMode)
                || expectedRunLoopModes.contains(.commonModes)

            let runLoopActivityMatches =
            activity.contains(expectedRunLoopActivitiy)

            if runLoopModesMatches && runLoopActivityMatches {
                eachTask.closure()
                removedIndices.append(index)
            }
        }

        taskQueue.removeIndicesInPlace(removedIndices)
    }
}

extension CFRunLoopActivity {
    private init(_ invokeTiming: NSRunLoopTaskInvokeTiming) {
        switch invokeTiming {
        case .NextLoopBegan:        self = .AfterWaiting
        case .CurrentLoopEnded:     self = .BeforeWaiting
        case .Idle:                 self = .Exit
        }
    }
}

With the code before, we can now dispatch the execution of UICollectionView's reloadData()to the end of current event loop by such a piece of code:

有了之前的代码，我们现在可以通过这样一段代码将UICollectionView's的执行分派reloadData()到当前事件循环的末尾：

 dispatch_async(dispatch_get_main_queue(), ^{

            [collectionView reloadData];
            [collectionView layoutIfNeeded];
            [collectionView reloadData];


        });

In fact, such an NSRunLoop based task dispatcher has already been in one of my personal used framework: Nest. And here is its repository on GitHub: https://github.com/WeZZard/Nest

事实上，这样一个基于 NSRunLoop 的任务调度器已经在我个人使用的框架之一：Nest 中。这是它在 GitHub 上的存储库：https: //github.com/WeZZard/Nest

回答by Prajakta

##代码##

it worked for me.

它对我有用。