मुझे कैसे पता चलेगा कि UICollectionView को पूरी तरह से लोड किया गया है?

Question 1

जब भी UICollectionView को पूरी तरह से लोड किया गया है, तो मुझे कुछ ऑपरेशन करना होगा, अर्थात उस समय सभी UICollectionView के डेटा स्रोत / लेआउट विधियों को बुलाया जाना चाहिए। मुझे इस बात की जानकारी कैसे होगी?? UICollectionView भरी हुई स्थिति जानने के लिए क्या कोई प्रतिनिधि विधि है?

Question 2

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

Question 3

यह मेरे लिए काम किया:

[self.collectionView reloadData];
[self.collectionView performBatchUpdates:^{}
                              completion:^(BOOL finished) {
                                  /// collection-view finished reload
                              }];

स्विफ्ट 4 सिंटैक्स:

self.collectionView.reloadData()
self.collectionView.performBatchUpdates(nil, completion: {
    (result) in
    // ready
})

Question 4

यह वास्तव में बहुत सरल है।

जब आप उदाहरण के लिए UICollectionView की पुनः लोड विधि को कॉल करते हैं या यह लेआउट की अमान्य विधि है, तो आप निम्न कार्य करते हैं:

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

यह क्यों काम करता है:

मुख्य धागा (जो कि हमें सभी यूआई अपडेट करना चाहिए) में मुख्य कतार है, जो प्रकृति में धारावाहिक है, अर्थात यह एफआईएफओ फैशन में काम करता है। इसलिए उपरोक्त उदाहरण में, पहले ब्लॉक को कॉल किया जाता है, जिसमें हमारी reloadDataविधि को आमंत्रित किया जाता है, इसके बाद दूसरे ब्लॉक में कुछ भी होता है।

अब मुख्य धागा भी अवरुद्ध हो रहा है। इसलिए यदि आपको reloadDataनिष्पादन के लिए 3s लगते हैं , तो दूसरे ब्लॉक के प्रसंस्करण को उन 3s द्वारा स्थगित कर दिया जाएगा।

Question 5

बस एक महान @dezinezync उत्तर में जोड़ने के लिए:

स्विफ्ट 3+

collectionView.collectionViewLayout.invalidateLayout() // or reloadData()
DispatchQueue.main.async {
    // your stuff here executing after collectionView has been layouted
}

Question 6

इसको ऐसे करो:

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

Question 7

पुनः लोडडैट () कॉल के ठीक बाद लेआउटआईएफएनएडेड () के माध्यम से एक तुल्यकालिक लेआउट पास की कोशिश करें। IOS 12 पर UICollectionView और UITableView दोनों के लिए काम करता है।

collectionView.reloadData()
collectionView.layoutIfNeeded() 

// cellForItem/sizeForItem calls should be complete
completion?()

Question 8

के रूप में dezinezync ने उत्तर दिया, क्या आप की जरूरत के बाद कोड का एक खंड मुख्य कतार में प्रेषण करने के लिए है reloadDataएक से UITableViewया UICollectionView, और उसके बाद इस ब्लॉक कोशिकाओं के बाद निष्पादित किया जाएगा dequeuing

उपयोग करते समय इसे और अधिक सीधा बनाने के लिए, मैं इस तरह से एक एक्सटेंशन का उपयोग करूंगा:

extension UICollectionView {
    func reloadData(_ completion: @escaping () -> Void) {
        reloadData()
        DispatchQueue.main.async { completion() }
    }
}

इसे एक UITableViewअच्छी तरह से भी लागू किया जा सकता है

Question 9

RxSwift / RxCocoa का उपयोग करते हुए एक अलग तरीका:

        collectionView.rx.observe(CGSize.self, "contentSize")
            .subscribe(onNext: { size in
                print(size as Any)
            })
            .disposed(by: disposeBag)

Question 10

यह मेरे लिए काम करता है:

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

Question 11

जब दृश्य उपयोगकर्ता को दिखाई देता है, तो मुझे उपयोग किए जाने से पहले संग्रहित दृश्य लोड होने पर मुझे सभी दृश्य कक्षों पर कुछ कार्रवाई करने की आवश्यकता थी:

public func collectionView(_ collectionView: UICollectionView, willDisplay cell: UICollectionViewCell, forItemAt indexPath: IndexPath) {
    if shouldPerformBatch {
        self.collectionView.performBatchUpdates(nil) { completed in
            self.modifyVisibleCells()
        }
    }
}

ध्यान दें कि यह संग्रह दृश्य के माध्यम से स्क्रॉल करते समय कहा जाएगा, इसलिए इस ओवरहेड को रोकने के लिए, मैंने कहा:

private var souldPerformAction: Bool = true

और कार्रवाई में ही:

private func modifyVisibleCells() {
    if self.shouldPerformAction {
        // perform action
        ...
        ...
    }
    self.shouldPerformAction = false
}

प्रारंभिक अवस्था में दृश्य कोशिकाओं की संख्या के रूप में कार्रवाई अभी भी कई बार की जाएगी। लेकिन उन सभी कॉल पर, आपके पास दृश्यमान कोशिकाओं (उन सभी) की संख्या समान होगी। और उपयोगकर्ता द्वारा संग्रह दृश्य के साथ बातचीत शुरू करने के बाद बूलियन ध्वज फिर से चलने से रोक देगा।

Question 12

मैं सिर्फ संग्रह दृश्य पुनः लोड होने के बाद कुछ भी करने के लिए निम्नलिखित किया था। आप एपीआई प्रतिक्रिया में भी इस कोड का उपयोग कर सकते हैं।

self.collectionView.reloadData()

DispatchQueue.main.async {
   // Do Task after collection view is reloaded                
}

Question 13

सबसे अच्छा समाधान जो मैंने अभी तक पाया है, उसे CATransactionपूरा करने के लिए उपयोग करना है।

स्विफ्ट 5 :

CATransaction.begin()
CATransaction.setCompletionBlock {
    // UICollectionView is ready
}

collectionView.reloadData()

CATransaction.commit()

Question 14

यह करें:

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

}

फिर अपने वीसी के अंदर इस तरह से कॉल करें

let collection = MyCollectionView()

self.collection.reloadData(completion: {

})

सुनिश्चित करें कि आप उपवर्ग का उपयोग कर रहे हैं !!

Question 15

मेरे लिए यह काम:


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

}

Question 16

बस बैच अपडेट के अंदर संग्रह दृश्य पुनः लोड करें और फिर पूर्ण ब्लॉक में जांचें कि क्या यह बूलियन "फिनिश" की मदद से समाप्त हो गया है या नहीं।

self.collectionView.performBatchUpdates({
        self.collectionView.reloadData()
    }) { (finish) in
        if finish{
            // Do your stuff here!
        }
    }

Question 17

नीचे केवल वही तरीका है जो मेरे लिए काम करता है।

extension UICollectionView {
    func reloadData(_ completion: (() -> Void)? = nil) {
        reloadData()
        guard let completion = completion else { return }
        layoutIfNeeded()
        completion()
    }
}

Question 18

इस तरह मैंने स्विफ्ट 3.0 के साथ समस्या हल की है:

override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)

    if !self.collectionView.visibleCells.isEmpty {
        // stuff
    }
}

Question 19

इसे इस्तेमाल करे:

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

Question 20

आप ऐसा कर सकते हैं ...

  - (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.

    }