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

我一直在更新我的应用程序以在iOS 7上运行,这在大多数情况下都很顺利。 我注意到在一个以上的应用程序中,UICollectionViewreloadData方法并没有像以前那样表现得很好。

我将加载reloadData,正常填充UICollectionView一些数据。 这在第一次很好用。 但是,如果我请求新数据(填充UICollectionViewDataSource),然后调用reloadData,它将查询数据源numberOfItemsInSectionnumberOfSectionsInCollectionView,但它似乎没有调用cellForItemAtIndexPath适当的次数。

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

有没有人见过这个?

VaporwareWolf asked 2019-08-13T07:28:23Z
17个解决方案
71 votes

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

dispatch_async(dispatch_get_main_queue(), ^ {
    [self.collectionView reloadData];
});
Shaunti Fondrisi answered 2019-08-13T07:28:37Z
63 votes

在我的例子中,数据源中的单元格/节的数量从未改变,我只是想重新加载屏幕上的可见内容。

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

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

然后:

[self.collectionView reloadData];
liamnichols answered 2019-08-13T07:29:12Z
26 votes

我有完全相同的问题,但我设法找到了错误的原因。在我的情况下,我从collectionView:cellForItemAtIndexPath调用reloadData:看起来不正确。

将reloadData调用调用到主队列一次又一次地修复了问题。

  dispatch_async(dispatch_get_main_queue(), ^{
    [self.collectionView reloadData];
  });
Anton Matosov answered 2019-08-13T07:29:47Z
19 votes

重新加载一些项目并不适合我。 在我的情况下,只是因为我使用的collectionView只有一个部分,我只是重新加载该特定部分。这次正确地重新加载内容。很奇怪,这只发生在iOS 7(7.0.3)上

[self.collectionView reloadSections:[NSIndexSet indexSetWithIndex:0]];
miguelsanchez answered 2019-08-13T07:30:14Z
12 votes

斯威夫特4 - 3

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

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

斯威夫特2

// Operation
NSOperationQueue.mainQueue().addOperationWithBlock(collectionView.reloadData)
dimpiax answered 2019-08-13T07:30:41Z
11 votes

我在iOS 7上遇到了与reloadData相同的问题。经过长时间的调试,我发现了问题。

在iOS7上,UICollectionView上的reloadData不会取消尚未完成的先前更新(更新在performBatchUpdates:block内部调用)。

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

user2459624 answered 2019-08-13T07:31:23Z
4 votes

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

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

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

会导致调用方法

我也玩了框架大小 - 并且方法被调用了。

iOS7 UICollectionView存在很多错误。

Avner Barr answered 2019-08-13T07:32:19Z
3 votes

您可以使用此方法

[collectionView reloadItemsAtIndexPaths:arayOfAllIndexPaths];

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

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

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

iDevAmit answered 2019-08-13T07:33:02Z
3 votes

Shaunti Fondrisi给出的解决方案几乎是完美的。 但是这样的一段代码或代码将UICollectionViewNSThread的执行排入NSRunLoopNSThread确实将执行时间置于运行循环中下一个事件循环的开头,这可能会使NSRunLoop更新 用一个电影。

解决这个问题。 我们必须将同一段代码的执行时间放在当前事件循环的末尾,而不是下一个的开始。 我们可以通过使用UICollectionView来实现这一目标。

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

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

在这些活动中,当前事件循环即将结束时可以观察到UICollectionView,并且当下一个事件循环刚刚开始时可以观察到NSThread

由于每NSThread只有一个UICollectionView实例,而NSRunLoop正好驱动NSRunLoop,我们可以认为访问来自同一个NSRunLoop实例,始终从不跨线程。

基于前面提到的几点,我们现在可以编写代码:基于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($0) })

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

使用之前的代码,我们现在可以通过这样一段代码将UICollectionView的执行reloadData()发送到当前事件循环的末尾:

NSRunLoop.currentRunLoop().perform({ () -> Void in
     collectionView.reloadData()
    }).when(.CurrentLoopEnded)

实际上,这样一个基于NSRunLoop的任务调度程序已经在我个人使用过的框架之一:Nest。 这是GitHub上的存储库:[https://github.com/WeZZard/Nest]

WeZZard answered 2019-08-13T07:34:24Z
1 votes

首先感谢这个帖子,非常有帮助。 我有一个与Reload Data类似的问题,除了症状是特定细胞不能再以永久方式选择,而其他细胞则可以。 不调用indexPathsForSelectedItems方法或等效方法。 调试指出重新加载数据。 我在上面尝试了两个选项; 并最终采用了ReloadItemsAtIndexPaths选项,因为其他选项在我的情况下不起作用或者使集合视图闪烁一毫秒左右。 以下代码效果很好:

NSMutableArray *indexPaths = [[NSMutableArray alloc] init]; 
NSIndexPath *indexPath;
for (int i = 0; i < [self.assets count]; i++) {
         indexPath = [NSIndexPath indexPathForItem:i inSection:0];
         [indexPaths addObject:indexPath];
}
[collectionView reloadItemsAtIndexPaths:indexPaths];`
stephane answered 2019-08-13T07:34:54Z
0 votes

它也发生在我的iOS 8.1 sdk中,但是当我注意到即使在更新datasource之后,方法numberOfItemsInSection:没有返回新的项目数,我也弄错了。 我更新了计数并使其正常工作。

Vinay Jain answered 2019-08-13T07:35:24Z
0 votes

你设置UICollectionView.contentInset吗? 删除左右edgeInset,删除后一切正常,iOS8.3中仍然存在bug。

Jiang Qi answered 2019-08-13T07:35:53Z
0 votes

检查每个UICollectionView Delegate方法是否符合您的预期。 例如,如果

collectionView:layout:sizeForItemAtIndexPath:

没有返回有效大小,重新加载不会起作用......

Oded Regev answered 2019-08-13T07:36:29Z
0 votes

试试这段代码。

 NSArray * visibleIdx = [self.collectionView indexPathsForVisibleItems];

    if (visibleIdx.count) {
        [self.collectionView reloadItemsAtIndexPaths:visibleIdx];
    }
Liki qu answered 2019-08-13T07:36:58Z
0 votes
 dispatch_async(dispatch_get_main_queue(), ^{

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


        });

它对我有用。

Prajakta answered 2019-08-13T07:37:21Z
0 votes

以下是它在Swift 4中对我有用的方法

func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {

let cell = campaignsCollection.dequeueReusableCell(withReuseIdentifier: "Cell", for: indexPath) as! Cell

cell.updateCell()

    // TO UPDATE CELLVIEWS ACCORDINGLY WHEN DATA CHANGES
    DispatchQueue.main.async {
        self.campaignsCollection.reloadData()
    }

    return cell
}
Wissa answered 2019-08-13T07:37:49Z
-1 votes
inservif (isInsertHead) {
   [self insertItemsAtIndexPaths:tmpPoolIndex];
   NSArray * visibleIdx = [self indexPathsForVisibleItems];
   if (visibleIdx.count) {
       [self reloadItemsAtIndexPaths:visibleIdx];
   }
}else if (isFirstSyncData) {
    [self reloadData];
}else{
   [self insertItemsAtIndexPaths:tmpPoolIndex];
}
zszen answered 2019-08-13T07:38:13Z
translate from https://stackoverflow.com:/questions/18796891/uicollectionview-reloaddata-not-functioning-properly-in-ios-7