Eu tenho um UITableViewcom um personalizado UITableViewCelldefinido em um storyboard usando layout automático. A célula possui várias linhas UILabels.

O UITableViewparece calcular corretamente as alturas das células, mas para as primeiras células essa altura não é dividida corretamente entre os rótulos. Depois de rolar um pouco, tudo funciona conforme o esperado (mesmo as células que estavam inicialmente incorretas).

- (void)viewDidLoad {
    [super viewDidLoad]
    // ...
    self.tableView.rowHeight = UITableViewAutomaticDimension;
}


- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    TableViewCell *cell = [self.tableView dequeueReusableCellWithIdentifier:@"TestCell"];
    // ...
    // Set label.text for variable length string.
    return cell;
}

Existe alguma coisa que eu possa estar perdendo, que está fazendo com que o layout automático não consiga fazer seu trabalho nas primeiras vezes?

Criei um projeto de amostra que demonstra esse comportamento.

Não sei se isso está claramente documentado ou não, mas adicionar [cell layoutIfNeeded]antes de devolver o celular resolve seu problema.

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    TableViewCell *cell = [self.tableView dequeueReusableCellWithIdentifier:@"TestCell"];
    NSUInteger n1 = firstLabelWordCount[indexPath.row];
    NSUInteger n2 = secondLabelWordCount[indexPath.row];
    [cell setNumberOfWordsForFirstLabel:n1 secondLabel:n2];

    [cell layoutIfNeeded]; // <- added

    return cell;
}

Isso funcionou para mim quando outras soluções semelhantes não:

override func didMoveToSuperview() {
    super.didMoveToSuperview()
    layoutIfNeeded()
}

Este parece ser um bug real, já que estou muito familiarizado com o AutoLayout e como usar UITableViewAutomaticDimension, no entanto, ainda ocasionalmente me deparo com esse problema. Estou feliz por finalmente encontrar algo que funciona como uma solução alternativa.

Adicionando [cell layoutIfNeeded]em cellForRowAtIndexPathnão funciona para células que são inicialmente enrolado out-of-view.

Nem prefaciar com [cell setNeedsLayout].

Você ainda tem que rolar certas células para fora e de volta à vista para que sejam redimensionadas corretamente.

Isso é muito frustrante, já que a maioria dos desenvolvedores possui Dynamic Type, AutoLayout e Self-Sizing Cells funcionando corretamente - exceto neste caso irritante. Este bug afeta todos os meus controladores de visualização de tabela "mais altos".

Tive a mesma experiência em um de meus projetos.

Por que isso acontece?

Célula projetada no Storyboard com alguma largura para algum dispositivo. Por exemplo, 400px. Por exemplo, sua etiqueta tem a mesma largura. Quando carrega do storyboard, tem largura de 400 px.

Aqui está um problema:

tableView:heightForRowAtIndexPath: chamado antes do layout da célula é subvisualizações.

Portanto, ele calculou a altura do rótulo e da célula com largura de 400 px. Mas você roda em aparelho com tela, por exemplo, 320px. E esta altura calculada automaticamente está incorreta. Só porque o celular layoutSubviewssó acontece depois. tableView:heightForRowAtIndexPath: Mesmo que você configure preferredMaxLayoutWidthseu rótulo manualmente, layoutSubviewsisso não ajuda.

Minha solução:

1) Subclasse UITableViewe substituição dequeueReusableCellWithIdentifier:forIndexPath:. Defina a largura da célula igual à largura da tabela e o layout da célula de força.

- (UITableViewCell *)dequeueReusableCellWithIdentifier:(NSString *)identifier forIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [super dequeueReusableCellWithIdentifier:identifier forIndexPath:indexPath];
    CGRect cellFrame = cell.frame;
    cellFrame.size.width = self.frame.size.width;
    cell.frame = cellFrame;
    [cell layoutIfNeeded];
    return cell;
}

2) Subclasse UITableViewCell. Defina preferredMaxLayoutWidthmanualmente para seus rótulos em layoutSubviews. Além disso, você precisa do layout manualmente contentView, porque ele não faz o layout automaticamente após a mudança do quadro da célula (não sei por que, mas é)

- (void)layoutSubviews {
    [super layoutSubviews];
    [self.contentView layoutIfNeeded];
    self.yourLongTextLabel.preferredMaxLayoutWidth = self.yourLongTextLabel.width;
}

Eu tenho um problema semelhante, no primeiro carregamento, a altura da linha não foi calculada, mas depois de alguma rolagem ou vá para outra tela e volto a esta tela as linhas são calculadas. No primeiro carregamento, meus itens são carregados da internet e no segundo carregamento meus itens são carregados primeiro do Core Data e recarregados da internet e eu percebi que a altura das linhas são calculadas no recarregamento da internet. Portanto, percebi que quando tableView.reloadData () é chamado durante a animação segue (mesmo problema com push e segue segue), a altura da linha não foi calculada. Então, escondi o tableview na inicialização do modo de exibição e coloquei um carregador de atividade para evitar um efeito desagradável para o usuário e chamei tableView.reloadData após 300 ms e agora o problema está resolvido. Acho que é um bug do UIKit, mas essa solução alternativa resolve o problema.

Eu coloquei essas linhas (Swift 3.0) no meu gerenciador de conclusão de carga de item

DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(300), execute: {
        self.tableView.isHidden = false
        self.loader.stopAnimating()
        self.tableView.reloadData()
    })

Isso explica por que, para algumas pessoas, colocar reloadData em layoutSubviews resolve o problema

nenhuma das soluções acima funcionou para mim, o que funcionou é esta receita de mágica: chame-os nesta ordem:

tableView.reloadData()
tableView.layoutIfNeeded() tableView.beginUpdates() tableView.endUpdates()

meus dados do tableView são preenchidos a partir de um serviço da web, no retorno de chamada da conexão, escrevo as linhas acima.

No meu caso, a última linha do UILabel foi truncada quando a célula foi exibida pela primeira vez. Aconteceu de forma bastante aleatória e a única maneira de dimensionar corretamente era rolar a célula para fora da visualização e trazê-la de volta. Tentei todas as soluções possíveis exibidas até agora (layoutIfNeeded..reloadData), mas nada funcionou para mim. O truque era definir "Autoshrink" para Minimuum Font Scale (0,5 para mim). De uma chance

Adicione uma restrição para todo o conteúdo dentro de uma célula personalizada de visualização de tabela, em seguida, estime a altura da linha de visualização de tabela e defina a altura da linha para dimensão automática com uma carga viewdid:

    override func viewDidLoad() {
    super.viewDidLoad()

    tableView.estimatedRowHeight = 70
    tableView.rowHeight = UITableViewAutomaticDimension
}

Para corrigir esse problema de carregamento inicial, aplique o método layoutIfNeeded em uma célula de visualização de tabela personalizada:

class CustomTableViewCell: UITableViewCell {

override func awakeFromNib() {
    super.awakeFromNib()
    self.layoutIfNeeded()
    // Initialization code
}
}

Tentei a maioria das respostas a esta pergunta e não consegui fazer nenhuma delas funcionar. A única solução funcional que encontrei foi adicionar o seguinte à minha UITableViewControllersubclasse:

override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)
    UIView.performWithoutAnimation {
        tableView.beginUpdates()
        tableView.endUpdates()
    }
}

A UIView.performWithoutAnimationchamada é necessária, caso contrário, você verá a animação normal da visualização da tabela conforme o controlador da visualização carrega.

A configuração preferredMaxLayoutWidthajuda no meu caso. Eu adicionei

cell.detailLabel.preferredMaxLayoutWidth = cell.frame.width

no meu código.

Consulte também o texto de linha única ocupa duas linhas em UILabel e http://openradar.appspot.com/17799811 .

ligar para cell.layoutIfNeeded()dentro cellForRowAtfuncionou para mim no iOS 10 e no iOS 11, mas não no iOS 9.

para conseguir esse trabalho no ios 9 também, ligo cell.layoutSubviews()e funcionou.

Para mim, nenhuma dessas abordagens funcionou, mas descobri que o rótulo tinha um Preferred Widthconjunto explícito no Interface Builder. Removendo isso (desmarcando "Explícito") e usando UITableViewAutomaticDimensionfuncionou como esperado.

Tentei todas as soluções nesta página, mas desmarcar usar classes de tamanho e, em seguida, verificar novamente resolveu meu problema.

Edit: Desmarcar as classes de tamanho causa muitos problemas no storyboard, então tentei outra solução. Preenchi minha table view em meu view controller viewDidLoade viewWillAppearmétodos. Isso resolveu meu problema.

Tenho o problema de redimensionar o rótulo, então preciso apenas fazer
chatTextLabel.text = chatMessage.message chatTextLabel? .UpdateConstraints () após configurar o texto

// código completo

func setContent() {
    chatTextLabel.text = chatMessage.message
    chatTextLabel?.updateConstraints()

    let labelTextWidth = (chatTextLabel?.intrinsicContentSize().width) ?? 0
    let labelTextHeight = chatTextLabel?.intrinsicContentSize().height

    guard labelTextWidth < originWidth && labelTextHeight <= singleLineRowheight else {
      trailingConstraint?.constant = trailingConstant
      return
    }
    trailingConstraint?.constant = trailingConstant + (originWidth - labelTextWidth)

  }

No meu caso, fui atualizando em outro ciclo. Portanto, a altura de tableViewCell foi atualizada após a configuração de labelText. Excluí o bloco assíncrono.

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
     let cell = tableView.dequeueReusableCell(withIdentifier:Identifier, for: indexPath) 
     // Check your cycle if update cycle is same or not
     // DispatchQueue.main.async {
        cell.label.text = nil
     // }
}

Apenas certifique-se de não definir o texto do rótulo no método delegado 'willdisplaycell' de visualização de tabela. Defina o texto do rótulo no método delegado 'cellForRowAtindexPath' para cálculo de altura dinâmica.

De nada :)

No meu caso, uma exibição de pilha na célula estava causando o problema. Aparentemente, é um bug. Depois de removê-lo, o problema foi resolvido.

O problema é que as células iniciais são carregadas antes de termos uma altura de linha válida. A solução alternativa é forçar o recarregamento da tabela quando a exibição for exibida.

- (void)viewDidAppear:(BOOL)animated
{
  [super viewDidAppear:animated];
  [self.tableView reloadData];
}

Apenas para iOS 12+, 2019 em diante ...

Um exemplo contínuo da incompetência bizarra ocasional da Apple, onde os problemas duram literalmente anos.

Parece ser o caso de

        cell.layoutIfNeeded()
        return cell

vai consertar isso. (Você está perdendo algum desempenho, é claro.)

Assim é a vida com a Apple.

No meu caso, o problema com a altura da célula ocorre depois que a visualização da tabela inicial é carregada e ocorre uma ação do usuário (tocar em um botão em uma célula que tem o efeito de alterar a altura da célula). Não consegui fazer a célula mudar sua altura, a menos que eu:

[self.tableView reloadData];

Eu tentei

[cell layoutIfNeeded];

mas isso não funcionou.

No Swift 3. Tive que chamar self.layoutIfNeeded () cada vez que atualizo o texto da célula reutilizável.

import UIKit
import SnapKit

class CommentTableViewCell: UITableViewCell {

    static let reuseIdentifier = "CommentTableViewCell"

    var comment: Comment! {
        didSet {
            textLbl.attributedText = comment.attributedTextToDisplay()
            self.layoutIfNeeded() //This is a fix to make propper automatic dimentions (height).
        }
    }

    internal var textLbl = UILabel()

    override func layoutSubviews() {
        super.layoutSubviews()

        if textLbl.superview == nil {
            textLbl.numberOfLines = 0
            textLbl.lineBreakMode = .byWordWrapping
            self.contentView.addSubview(textLbl)
            textLbl.snp.makeConstraints({ (make) in
                make.left.equalTo(contentView.snp.left).inset(10)
                make.right.equalTo(contentView.snp.right).inset(10)
                make.top.equalTo(contentView.snp.top).inset(10)
                make.bottom.equalTo(contentView.snp.bottom).inset(10)
            })
        }
    }
}

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let comment = comments[indexPath.row]
        let cell = tableView.dequeueReusableCell(withIdentifier: CommentTableViewCell.reuseIdentifier, for: indexPath) as! CommentTableViewCell
        cell.selectionStyle = .none
        cell.comment = comment
        return cell
    }

commentsTableView.rowHeight = UITableViewAutomaticDimension
    commentsTableView.estimatedRowHeight = 140

Nenhuma das soluções acima funcionou, mas a seguinte combinação de sugestões funcionou.

Tive que adicionar o seguinte em viewDidLoad ().

DispatchQueue.main.async {

        self.tableView.reloadData()

        self.tableView.setNeedsLayout()
        self.tableView.layoutIfNeeded()

        self.tableView.reloadData()

    }

A combinação acima de reloadData, setNeedsLayout e layoutIfNeeded funcionou, mas nenhuma outra. No entanto, pode ser específico para as células do projeto. E sim, tive que invocar reloadData duas vezes para fazê-lo funcionar.

Defina também o seguinte em viewDidLoad

tableView.rowHeight = UITableViewAutomaticDimension
tableView.estimatedRowHeight = MyEstimatedHeight

Em tableView (_ tableView: UITableView, cellForRowAt indexPath: IndexPath)

cell.setNeedsLayout()
cell.layoutIfNeeded() 

Corri para esse problema e corrigi-lo movendo meu código de inicialização view / label DE tableView(willDisplay cell:)PARA tableView(cellForRowAt:).

- (CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath{


//  call the method dynamiclabelHeightForText
}

use o método acima que retorna a altura da linha dinamicamente. E atribua a mesma altura dinâmica à etiqueta que você está usando.

-(int)dynamiclabelHeightForText:(NSString *)text :(int)width :(UIFont *)font
{

    CGSize maximumLabelSize = CGSizeMake(width,2500);

    CGSize expectedLabelSize = [text sizeWithFont:font
                                constrainedToSize:maximumLabelSize
                                    lineBreakMode:NSLineBreakByWordWrapping];


    return expectedLabelSize.height;


}

Este código ajuda a encontrar a altura dinâmica do texto exibido no rótulo.