reloadData () von UITableView mit dynamischen Zellenhöhen verursacht ein nervöses Scrollen

Ich bin der Meinung, dass dies ein häufiges Problem sein könnte, und habe mich gefragt, ob es eine gemeinsame Lösung dafür gibt.

Grundsätzlich hat mein UITableView dynamische Zellenhöhen für jede Zelle. Wenn ich nicht oben in UITableView bin und ich tableView.reloadData(), wird das Scrollen nach oben nervös.

Ich glaube, dies liegt an der Tatsache, dass UITableView die Höhe für jede Zelle, die sichtbar wird, neu berechnet, da ich beim Scrollen Daten hochgeladen habe. Wie kann ich das abmildern oder wie lade ich Daten nur von einem bestimmten IndexPath bis zum Ende der UITableView neu?

Wenn ich es schaffe, ganz nach oben zu scrollen, kann ich wieder nach unten und dann nach oben scrollen, kein Problem, ohne zu springen. Dies liegt höchstwahrscheinlich daran, dass die UITableViewCell-Höhen bereits berechnet wurden.

Um ein Springen zu verhindern, sollten Sie beim Laden die Höhe der Zellen speichern und den genauen Wert angeben in tableView:estimatedHeightForRowAtIndexPath:

Schnell:

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
}

Ziel 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-Version der akzeptierten Antwort.

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 
}

Der Sprung ist wegen einer schlechten geschätzten Höhe. Je mehr sich die geschätzte Zeilenhöhe von der tatsächlichen Höhe unterscheidet, desto mehr kann die Tabelle springen, wenn sie neu geladen wird, insbesondere je weiter nach unten gescrollt wurde. Dies liegt daran, dass sich die geschätzte Größe der Tabelle radikal von der tatsächlichen Größe unterscheidet und die Tabelle gezwungen ist, ihre Inhaltsgröße und ihren Versatz anzupassen. Die geschätzte Höhe sollte also kein zufälliger Wert sein, sondern in der Nähe dessen, was Sie denken, dass die Höhe sein wird. Ich habe auch erfahren, wann ich festgelegt habe, UITableViewAutomaticDimension ob Ihre Zellen dann vom gleichen Typ sind

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

Wenn Sie verschiedene Zellen in verschiedenen Abschnitten haben, dann denke ich, ist der bessere Ort

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

@Igor Antwort funktioniert in diesem Fall gut,Swift-4Code davon.

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

in folgenden Methoden von 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
}

Ich habe alle oben genannten Problemumgehungen ausprobiert, aber nichts hat funktioniert.

Nachdem Sie Stunden damit verbracht hatten, alle möglichen Frustrationen durchzugehen, fanden Sie einen Weg, dies zu beheben. Diese Lösung ist ein Lebensretter! Lief wie am Schnürchen!

Swift 4

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

Ich habe es als Erweiterung hinzugefügt, damit der Code sauberer aussieht und nicht jedes Mal, wenn ich neu laden möchte, alle diese Zeilen geschrieben werden.

extension UITableView {

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

schließlich ..

tableView.reloadWithoutAnimation()

ODER Sie könnten diese Zeile tatsächlich zu Ihrer UITableViewCell awakeFromNib()Methode hinzufügen

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

und normal machen reloadData()

Ich benutze mehr Möglichkeiten, um das Problem zu beheben:

Für View Controller:

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 
}

als Erweiterung für UITableView

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

Das Ergebnis ist

tableView.reloadSectionWithouAnimation(section: indexPath.section)

Ich bin heute darauf gestoßen und habe Folgendes beobachtet:

1. Es ist in der Tat nur iOS 8.
2. Überschreiben cellForRowAtIndexPathhilft nicht.

Das Update war eigentlich ziemlich einfach:

Überschreiben Sie estimatedHeightForRowAtIndexPathund stellen Sie sicher, dass die richtigen Werte zurückgegeben werden.

Damit hat alles seltsame Zittern und Herumspringen in meinen UITableViews aufgehört.

HINWEIS: Ich kenne die Größe meiner Zellen. Es gibt nur zwei mögliche Werte. Wenn Ihre Zellen wirklich eine variable Größe haben, möchten Sie möglicherweise die cell.bounds.size.heightvon zwischenspeicherntableView:willDisplayCell:forRowAtIndexPath:

Sie können tatsächlich nur bestimmte Zeilen neu laden, indem Sie reloadRowsAtIndexPathsFolgendes verwenden:

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

Im Allgemeinen können Sie aber auch Änderungen der Tabellenzellenhöhe wie folgt animieren:

tableView.beginUpdates()
tableView.endUpdates()

Hier ist eine etwas kürzere Version:

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

Überschreiben der geschätzten HeightForRowAtIndexPath-Methode mit einem hohen Wert, z. B. 300f

Dies sollte das Problem beheben :)

Es gibt einen Fehler, von dem ich glaube, dass er in iOS11 eingeführt wurde.

In reloaddiesem Fall contentOffSetwird die tableView unerwartet geändert. In der Tat contentOffsetsollte sich nach einem Neuladen nicht ändern. Es kann aufgrund von Fehlkalkulationen von passierenUITableViewAutomaticDimension

Sie müssen Ihre speichern contentOffSetund nach dem erneuten Laden auf Ihren gespeicherten Wert zurücksetzen.

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

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

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

Wie benutzt du es?

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

Diese Antwort wurde von hier abgeleitet

Dieser hat in Swift4 für mich gearbeitet:

extension UITableView {

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

Keine dieser Lösungen hat bei mir funktioniert. Folgendes habe ich mit Swift 4 & Xcode 10.1 gemacht ...

Deklarieren Sie in viewDidLoad () die dynamische Zeilenhöhe der Tabelle und erstellen Sie korrekte Einschränkungen in Zellen ...

tableView.rowHeight = UITableView.automaticDimension

Registrieren Sie auch in viewDidLoad () alle Ihre tableView-Zellennibs in tableview wie folgt:

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

Geben Sie in tableView heightForRowAt die Höhe zurück, die der Höhe jeder Zelle bei indexPath.row ... entspricht.

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
    } 

}

Geben Sie nun eine geschätzte Zeilenhöhe für jede Zelle in tableView EstimatedHeightForRowAt an. Sei genau wie du kannst ...

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
    } 

}

Das sollte funktionieren...

Ich musste contentOffset beim Aufrufen von tableView.reloadData () nicht speichern und festlegen.

Ich habe 2 verschiedene Zellenhöhen.

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

Nachdem ich schätzungsweise HeightForRowAt hinzugefügt hatte , gab es kein Springen mehr.

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

Versuchen Sie anzurufen, cell.layoutSubviews()bevor Sie die Zelle zurückgeben func cellForRowAtIndexPath(_ indexPath: NSIndexPath) -> UITableViewCell?. Es ist ein Fehler in iOS8 bekannt.

Sie können Folgendes in verwenden 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

Ich hatte dieses Sprungverhalten und konnte es zunächst durch Festlegen der genauen geschätzten Kopfhöhe abmildern (da ich nur eine mögliche Kopfzeilensicht hatte). Die Sprünge begannen dann jedoch speziell innerhalb der Kopfzeilen und wirkten sich nicht mehr auf die gesamte Tabelle aus.

Nach den Antworten hier hatte ich den Hinweis, dass es sich um Animationen handelt, und stellte fest, dass sich die Tabellenansicht in einer Stapelansicht befand, und manchmal riefen wir stackView.layoutIfNeeded()in einem Animationsblock auf. Meine endgültige Lösung bestand darin, sicherzustellen, dass dieser Aufruf nur dann erfolgt, wenn "wirklich" benötigt wird, da das Layout "falls erforderlich" in diesem Kontext visuelles Verhalten aufweist, selbst wenn "nicht benötigt".

Ich hatte das gleiche Problem. Ich hatte Paginierung und erneutes Laden von Daten ohne Animation, aber es half der Schriftrolle nicht, das Springen zu verhindern. Ich habe eine andere Größe von IPhones, die Schriftrolle war auf dem iPhone 8 nicht nervös, aber auf dem iPhone 7 + war sie nervös

Ich habe folgende Änderungen an der viewDidLoad- Funktion vorgenommen:

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

und mein Problem gelöst. Ich hoffe es hilft dir auch.

Einer der Ansätze zur Lösung dieses Problems, den ich gefunden habe, ist

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

Eigentlich habe ich festgestellt, wenn Sie reloadRowsein Sprungproblem verursachen. Dann sollten Sie versuchen, reloadSectionswie folgt zu verwenden :

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