reloadData () di UITableView con altezze di celle dinamiche provoca uno scorrimento rapido

Penso che questo potrebbe essere un problema comune e mi chiedevo se ci fosse una soluzione comune ad esso.

Fondamentalmente, il mio UITableView ha altezze di cella dinamiche per ogni cella. Se non sono in cima a UITableView e io tableView.reloadData(), lo scorrimento verso l'alto diventa instabile.

Credo che ciò sia dovuto al fatto che, poiché ho ricaricato i dati, mentre sto scorrendo verso l'alto, UITableView sta ricalcolando l'altezza per ogni cella che viene visualizzata. Come posso mitigarlo o come ricaricare i dati da un determinato IndexPath alla fine di UITableView?

Inoltre, quando riesco a scorrere fino in cima, posso scorrere indietro e poi su, senza problemi senza saltare. Ciò è molto probabilmente perché le altezze di UITableViewCell erano già state calcolate.

Per evitare il salto dovresti risparmiare altezze di celle quando si caricano e dare il valore esatto in tableView:estimatedHeightForRowAtIndexPath:

Swift:

var cellHeights = [IndexPath: CGFloat]()

func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    cellHeights[indexPath] = cell.frame.size.height
}

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
    return cellHeights[indexPath] ?? UITableView.automaticDimension
}

Obiettivo C:

// declare cellHeightsDictionary
NSMutableDictionary *cellHeightsDictionary = @{}.mutableCopy;

// declare table dynamic row height and create correct constraints in cells
tableView.rowHeight = UITableViewAutomaticDimension;

// save height
- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath {
    [cellHeightsDictionary setObject:@(cell.frame.size.height) forKey:indexPath];
}

// give exact height value
- (CGFloat)tableView:(UITableView *)tableView estimatedHeightForRowAtIndexPath:(NSIndexPath *)indexPath {
    NSNumber *height = [cellHeightsDictionary objectForKey:indexPath];
    if (height) return height.doubleValue;
    return UITableViewAutomaticDimension;
}

Swift 3 versione della risposta accettata.

var cellHeights: [IndexPath : CGFloat] = [:]


func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    cellHeights[indexPath] = cell.frame.size.height
}

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
    return cellHeights[indexPath] ?? 70.0 
}

Il salto è a causa di una cattiva altezza stimata. Maggiore è il valore stimato di RowHeight dall'altezza effettiva, più la tabella può saltare quando viene ricaricata, soprattutto più in basso è stata fatta scorrere. Questo perché le dimensioni stimate della tabella differiscono radicalmente dalle dimensioni effettive, costringendo la tabella a regolare le dimensioni del contenuto e l'offset. Quindi l'altezza stimata non dovrebbe essere un valore casuale ma vicino a quello che pensi sarà l'altezza. Ho anche sperimentato quando ho impostato UITableViewAutomaticDimension se le tue celle sono dello stesso tipo allora

func viewDidLoad() {
     super.viewDidLoad()
     tableView.estimatedRowHeight = 100//close to your cell height
}

se hai varietà di cellule in diverse sezioni, penso che sia il posto migliore

func tableView(tableView: UITableView, estimatedHeightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
     //return different sizes for different cells if you need to
     return 100
}

La risposta di @Igor funziona bene in questo caso,Swift-4codice di esso.

// declaration & initialization  
var cellHeightsDictionary: [IndexPath: CGFloat] = [:]  

nei seguenti metodi di UITableViewDelegate

func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
  // print("Cell height: \(cell.frame.size.height)")
  self.cellHeightsDictionary[indexPath] = cell.frame.size.height
}

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
  if let height =  self.cellHeightsDictionary[indexPath] {
    return height
  }
  return UITableView.automaticDimension
}

Ho provato tutte le soluzioni alternative sopra, ma nulla ha funzionato.

Dopo aver trascorso ore e aver affrontato tutte le possibili frustrazioni, ho trovato un modo per risolvere questo problema. Questa soluzione è un salvatore di vita! Ha funzionato come un fascino!

Swift 4

let lastContentOffset = tableView.contentOffset
tableView.beginUpdates()
tableView.endUpdates()
tableView.layer.removeAllAnimations()
tableView.setContentOffset(lastContentOffset, animated: false)

L'ho aggiunto come estensione, per rendere il codice più pulito ed evitare di scrivere tutte queste righe ogni volta che voglio ricaricare.

extension UITableView {

    func reloadWithoutAnimation() {
        let lastScrollOffset = contentOffset
        beginUpdates()
        endUpdates()
        layer.removeAllAnimations()
        setContentOffset(lastScrollOffset, animated: false)
    }
}

finalmente ..

tableView.reloadWithoutAnimation()

O potresti effettivamente aggiungere queste righe nel tuo UITableViewCell awakeFromNib()metodo

layer.shouldRasterize = true
layer.rasterizationScale = UIScreen.main.scale

e fare normale reloadData()

Uso più modi per risolverlo:

Per il controller di visualizzazione:

var cellHeights: [IndexPath : CGFloat] = [:]


func tableView(_ tableView: UITableView, willDisplay cell: UITableViewCell, forRowAt indexPath: IndexPath) {
    cellHeights[indexPath] = cell.frame.size.height
}

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
    return cellHeights[indexPath] ?? 70.0 
}

come estensione per UITableView

extension UITableView {
  func reloadSectionWithouAnimation(section: Int) {
      UIView.performWithoutAnimation {
          let offset = self.contentOffset
          self.reloadSections(IndexSet(integer: section), with: .none)
          self.contentOffset = offset
      }
  }
}

Il risultato è

tableView.reloadSectionWithouAnimation(section: indexPath.section)

Mi sono imbattuto in questo oggi e ho osservato:

1. È solo iOS 8, in effetti.
2. Sostituire cellForRowAtIndexPathnon aiuta.

La correzione era in realtà piuttosto semplice:

Sostituisci estimatedHeightForRowAtIndexPathe assicurati che restituisca i valori corretti.

Con questo, tutti gli strani strani jitter e salti nelle mie UITableViews si sono fermati.

NOTA: in realtà conosco le dimensioni delle mie celle. Esistono solo due valori possibili. Se le tue celle sono veramente di dimensioni variabili, potresti voler memorizzare nella cache il cell.bounds.size.heightdatableView:willDisplayCell:forRowAtIndexPath:

Puoi infatti ricaricare solo determinate righe usando reloadRowsAtIndexPaths, ad esempio:

tableView.reloadRowsAtIndexPaths(indexPathArray, withRowAnimation: UITableViewRowAnimation.None)

Ma, in generale, potresti anche animare i cambiamenti di altezza delle celle della tabella in questo modo:

tableView.beginUpdates()
tableView.endUpdates()

Ecco una versione un po 'più breve:

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
    return self.cellHeightsDictionary[indexPath] ?? UITableViewAutomaticDimension
}

Sostituzione del metodo stimatoHeightForRowAtIndexPath con un valore elevato, ad esempio 300f

Questo dovrebbe risolvere il problema :)

C'è un bug che credo sia stato introdotto in iOS11.

Cioè quando si esegue un reloadtableView contentOffSetviene inaspettatamente modificato. In realtà contentOffsetnon dovrebbe cambiare dopo un ricaricamento. Tende a succedere a causa di errori di calcolo diUITableViewAutomaticDimension

Devi salvare il tuo contentOffSete ripristinarlo al valore salvato una volta terminato il ricaricamento.

func reloadTableOnMain(with offset: CGPoint = CGPoint.zero){

    DispatchQueue.main.async { [weak self] () in

        self?.tableView.reloadData()
        self?.tableView.layoutIfNeeded()
        self?.tableView.contentOffset = offset
    }
}

Come lo usi?

someFunctionThatMakesChangesToYourDatasource()
let offset = tableview.contentOffset
reloadTableOnMain(with: offset)

Questa risposta è stata derivata da qui

Questo ha funzionato per me in Swift4:

extension UITableView {

    func reloadWithoutAnimation() {
        let lastScrollOffset = contentOffset
        reloadData()
        layoutIfNeeded()
        setContentOffset(lastScrollOffset, animated: false)
    }
}

Nessuna di queste soluzioni ha funzionato per me. Ecco cosa ho fatto con Swift 4 e Xcode 10.1 ...

In viewDidLoad (), dichiara l'altezza della riga dinamica della tabella e crea vincoli corretti nelle celle ...

tableView.rowHeight = UITableView.automaticDimension

Sempre in viewDidLoad (), registra tutti i pennini delle celle di TableView in tableview in questo modo:

tableView.register(UINib(nibName: "YourTableViewCell", bundle: nil), forCellReuseIdentifier: "YourTableViewCell")
tableView.register(UINib(nibName: "YourSecondTableViewCell", bundle: nil), forCellReuseIdentifier: "YourSecondTableViewCell")
tableView.register(UINib(nibName: "YourThirdTableViewCell", bundle: nil), forCellReuseIdentifier: "YourThirdTableViewCell")

In tableView heightForRowAt, restituisce l'altezza uguale all'altezza di ciascuna cella in indexPath.row ...

func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {

    if indexPath.row == 0 {
        let cell = Bundle.main.loadNibNamed("YourTableViewCell", owner: self, options: nil)?.first as! YourTableViewCell
        return cell.layer.frame.height
    } else if indexPath.row == 1 {
        let cell = Bundle.main.loadNibNamed("YourSecondTableViewCell", owner: self, options: nil)?.first as! YourSecondTableViewCell
        return cell.layer.frame.height
    } else {
        let cell = Bundle.main.loadNibNamed("YourThirdTableViewCell", owner: self, options: nil)?.first as! YourThirdTableViewCell
        return cell.layer.frame.height
    } 

}

Ora fornisci un'altezza di riga stimata per ogni cella nella tabella Visualizza stimaHeightForRowAt. Sii preciso come puoi ...

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {

    if indexPath.row == 0 {
        return 400 // or whatever YourTableViewCell's height is
    } else if indexPath.row == 1 {
        return 231 // or whatever YourSecondTableViewCell's height is
    } else {
        return 216 // or whatever YourThirdTableViewCell's height is
    } 

}

Dovrebbe funzionare ...

Non ho avuto bisogno di salvare e impostare contentOffset quando ho chiamato tableView.reloadData ()

Ho 2 diverse altezze di cella.

func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
        let cellHeight = CGFloat(checkIsCleanResultSection(index: indexPath.row) ? 130 : 160)
        return Helper.makeDeviceSpecificCommonSize(cellHeight)
    }

Dopo aver aggiunto stimeHeightForRowAt , non c'era più il salto.

func tableView(_ tableView: UITableView, estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
    let cellHeight = CGFloat(checkIsCleanResultSection(index: indexPath.row) ? 130 : 160)
    return Helper.makeDeviceSpecificCommonSize(cellHeight)
}

Prova a chiamare cell.layoutSubviews()prima di restituire la cella func cellForRowAtIndexPath(_ indexPath: NSIndexPath) -> UITableViewCell?. È noto bug in iOS8.

È possibile utilizzare quanto segue in ViewDidLoad()

tableView.estimatedRowHeight = 0     // if have just tableViewCells <br/>

// use this if you have tableview Header/footer <br/>
tableView.estimatedSectionFooterHeight = 0 <br/>
tableView.estimatedSectionHeaderHeight = 0

Ho avuto questo comportamento saltellante e inizialmente sono stato in grado di mitigarlo impostando l'altezza esatta dell'intestazione stimata (perché avevo solo 1 possibile vista dell'intestazione), tuttavia i salti hanno iniziato a verificarsi all'interno delle intestazioni in modo specifico, senza influenzare più l'intero tavolo.

Seguendo le risposte qui, ho avuto la sensazione che fosse correlato alle animazioni, quindi ho scoperto che la vista della tabella era all'interno di una vista pila, e talvolta chiamavamo stackView.layoutIfNeeded()all'interno di un blocco di animazione. La mia soluzione finale è stata quella di assicurarmi che questa chiamata non avvenisse a meno che "veramente" non fosse necessario, poiché il layout "se necessario" aveva comportamenti visivi in ​​quel contesto anche quando "non necessario".

Ho avuto lo stesso problema. Ho avuto l'impaginazione e ricaricato i dati senza animazione, ma non ha aiutato lo scorrimento per evitare il salto. Ho diverse dimensioni di IPhones, lo scorrimento non era nervoso su iPhone8 ma era nervoso su iPhone7 +

Ho applicato le seguenti modifiche alla funzione viewDidLoad :

    self.myTableView.estimatedRowHeight = 0.0
    self.myTableView.estimatedSectionFooterHeight = 0
    self.myTableView.estimatedSectionHeaderHeight = 0

e il mio problema è stato risolto. Spero aiuti anche te.

Uno degli approcci per risolvere questo problema che ho riscontrato è

CATransaction.begin()
UIView.setAnimationsEnabled(false)
CATransaction.setCompletionBlock {
   UIView.setAnimationsEnabled(true)
}
tableView.reloadSections([indexPath.section], with: .none)
CATransaction.commit()

In realtà ho scoperto che se usi reloadRowscausando un problema di salto. Quindi dovresti provare a usare in reloadSectionsquesto modo:

UIView.performWithoutAnimation {
    tableView.reloadSections(NSIndexSet(index: indexPath.section) as IndexSet, with: .none)
}