reloadData () de UITableView avec des hauteurs de cellule dynamiques provoque un défilement instable

J'ai l'impression que cela pourrait être un problème courant et je me demandais s'il y avait une solution commune à ce problème.

Fondamentalement, mon UITableView a des hauteurs de cellule dynamiques pour chaque cellule. Si je ne suis pas en haut de UITableView et moi tableView.reloadData(), le défilement vers le haut devient instable.

Je pense que cela est dû au fait que, parce que j'ai rechargé des données, au fur et à mesure que je défile vers le haut, l'UITableView recalcule la hauteur de chaque cellule qui devient visible. Comment puis-je atténuer cela ou comment recharger uniquement les données d'un certain IndexPath à la fin de UITableView?

De plus, lorsque je parviens à faire défiler tout le chemin vers le haut, je peux faire défiler vers le bas puis vers le haut, sans problème sans sauter. Cela est probablement dû au fait que les hauteurs UITableViewCell ont déjà été calculées.

Pour éviter de sauter, vous devez enregistrer les hauteurs des cellules lors du chargement et donner une valeur exacte dans tableView:estimatedHeightForRowAtIndexPath:

Rapide:

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
}

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

Version Swift 3 de la réponse acceptée.

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 
}

Le saut est dû à une mauvaise hauteur estimée. Plus le estiméRowHeight diffère de la hauteur réelle, plus la table peut sauter lorsqu'elle est rechargée, en particulier plus elle a été défilée vers le bas. En effet, la taille estimée du tableau diffère radicalement de sa taille réelle, ce qui oblige le tableau à ajuster la taille et le décalage de son contenu. Ainsi, la hauteur estimée ne doit pas être une valeur aléatoire mais proche de ce que vous pensez que la hauteur va être. J'ai également expérimenté quand je définis UITableViewAutomaticDimension si vos cellules sont du même type alors

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

si vous avez une variété de cellules dans différentes sections, je pense que le meilleur endroit est

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

La réponse @Igor fonctionne bien dans ce cas, leSwift-4code de celui-ci.

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

dans les méthodes suivantes de 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
}

J'ai essayé toutes les solutions de contournement ci-dessus, mais rien n'a fonctionné.

Après avoir passé des heures et traversé toutes les frustrations possibles, j'ai trouvé un moyen de résoudre ce problème. Cette solution est un sauveur de vie! A travaillé comme un charme!

Swift 4

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

Je l'ai ajouté en tant qu'extension, pour rendre le code plus propre et éviter d'écrire toutes ces lignes à chaque fois que je veux recharger.

extension UITableView {

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

enfin ..

tableView.reloadWithoutAnimation()

OU vous pouvez ajouter ces lignes à votre UITableViewCell awakeFromNib()méthode

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

et fais normal reloadData()

J'utilise plus de moyens pour résoudre ce problème:

Pour le contrôleur de vue:

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 
}

comme extension pour UITableView

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

Le résultat est

tableView.reloadSectionWithouAnimation(section: indexPath.section)

Je suis tombé sur ceci aujourd'hui et j'ai observé:

1. C'est seulement iOS 8, en effet.
2. Overridding cellForRowAtIndexPathn'aide pas.

Le correctif était en fait assez simple:

Remplacez estimatedHeightForRowAtIndexPathet assurez-vous qu'il renvoie les valeurs correctes.

Avec cela, tous les tremblements et sauts bizarres dans mes UITableViews se sont arrêtés.

REMARQUE: je connais en fait la taille de mes cellules. Il n'y a que deux valeurs possibles. Si vos cellules sont vraiment de taille variable, alors vous voudrez peut - être mettre en cache la cell.bounds.size.heightdetableView:willDisplayCell:forRowAtIndexPath:

Vous ne pouvez en fait recharger que certaines lignes en utilisant reloadRowsAtIndexPaths, par exemple:

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

Mais, en général, vous pouvez également animer les changements de hauteur de cellule du tableau comme ceci:

tableView.beginUpdates()
tableView.endUpdates()

Voici une version un peu plus courte:

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

Remplacement de la méthode EstimatedHeightForRowAtIndexPath avec une valeur élevée, par exemple 300f

Cela devrait résoudre le problème :)

Il y a un bogue qui, je crois, a été introduit dans iOS11.

C'est à ce moment-là que vous faites une reloadtableView contentOffSetest modifiée de manière inattendue. En fait contentOffset, ne devrait pas changer après un rechargement. Cela a tendance à se produire en raison d'erreurs de calculUITableViewAutomaticDimension

Vous devez enregistrer votre contentOffSetet le remettre à votre valeur enregistrée une fois votre rechargement terminé.

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

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

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

Comment l'utilisez vous?

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

Cette réponse est tirée d' ici

Celui-ci a fonctionné pour moi dans Swift4:

extension UITableView {

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

Aucune de ces solutions n'a fonctionné pour moi. Voici ce que j'ai fait avec Swift 4 et Xcode 10.1 ...

Dans viewDidLoad (), déclarez la hauteur de ligne dynamique du tableau et créez des contraintes correctes dans les cellules ...

tableView.rowHeight = UITableView.automaticDimension

Aussi dans viewDidLoad (), enregistrez toutes vos nibs de cellule tableView dans tableview comme ceci:

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

Dans tableView heightForRowAt, renvoie une hauteur égale à la hauteur de chaque cellule à 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
    } 

}

Donnez maintenant une hauteur de ligne estimée pour chaque cellule dans tableView EstimatedHeightForRowAt. Soyez aussi précis que possible ...

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
    } 

}

Cela devrait fonctionner...

Je n'avais pas besoin d'enregistrer et de définir contentOffset lors de l'appel de tableView.reloadData ()

J'ai 2 hauteurs de cellule différentes.

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

Après avoir ajouté estiméHeightForRowAt , il n'y avait plus de saut.

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

Essayez d'appeler cell.layoutSubviews()avant de renvoyer la cellule func cellForRowAtIndexPath(_ indexPath: NSIndexPath) -> UITableViewCell?. C'est un bogue connu dans iOS8.

Vous pouvez utiliser les éléments suivants dans 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

J'avais ce comportement de saut et j'ai d'abord pu l'atténuer en définissant la hauteur exacte de l'en-tête estimée (car je n'avais qu'une vue d'en-tête possible), mais les sauts ont alors commencé à se produire spécifiquement à l' intérieur des en-têtes, n'affectant plus l'ensemble du tableau.

Suite aux réponses ici, j'ai eu l'indice qu'il était lié aux animations, donc j'ai trouvé que la vue de table était à l'intérieur d'une vue de pile, et parfois nous appelions à l' stackView.layoutIfNeeded()intérieur d'un bloc d'animation. Ma solution finale était de m'assurer que cet appel ne se produise pas à moins que "vraiment" nécessaire, car la mise en page "si nécessaire" avait des comportements visuels dans ce contexte même quand "pas nécessaire".

J'ai eu le même problème. J'avais des données de pagination et de rechargement sans animation mais cela n'aidait pas le défilement à éviter de sauter. J'ai une taille différente d'IPhones, le scroll n'était pas nerveux sur iphone8 mais il était nerveux sur iphone7 +

J'ai appliqué les modifications suivantes sur la fonction viewDidLoad :

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

et mon problème résolu. J'espère que cela vous aide aussi.

L'une des approches pour résoudre ce problème que j'ai trouvé est

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

En fait, je trouve que si vous utilisez reloadRowsun problème de saut. Ensuite, vous devriez essayer d'utiliser reloadSectionscomme ceci:

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