Dla IOS8 jest to naprawdę proste:

override func viewDidLoad() {  
    super.viewDidLoad()

    self.tableView.estimatedRowHeight = 80
    self.tableView.rowHeight = UITableViewAutomaticDimension
}

Lub

func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
    return UITableViewAutomaticDimension
}

Ale dla IOS7 kluczem jest obliczenie wysokości po autolayout,

func calculateHeightForConfiguredSizingCell(cell: GSTableViewCell) -> CGFloat {
    cell.setNeedsLayout()
    cell.layoutIfNeeded()
    let height = cell.contentView.systemLayoutSizeFittingSize(UILayoutFittingExpandedSize).height + 1.0
    return height
}

Ważne

• Jeśli wiele linii etykiet, nie zapomnij ustawić numberOfLines na 0.

• Nie zapomnij label.preferredMaxLayoutWidth = CGRectGetWidth(tableView.bounds)

Pełny przykładowy kod to tutaj .

Szybki przykład zmiennej wysokości UITableViewCell

Aktualizacja dla Swift 3

Szybka odpowiedź Williama Hu jest dobra, ale pomaga mi mieć kilka prostych, ale szczegółowych kroków podczas nauki robienia czegoś po raz pierwszy. Poniższy przykład to mój projekt testowy podczas nauki tworzenia UITableView ze zmienną wysokością komórek. Oparłem go na tym podstawowym przykładzie UITableView dla Swift.

Gotowy projekt powinien wyglądać jak to:

Utwórz nowy projekt

Może to być tylko jedna aplikacja widoku.

Dodaj kod

Dodaj nowy plik Swift do swojego projektu. Nazwij to MyCustomCell. Ta klasa będzie przechowywać punkty dla widoków, które dodajesz do swojej komórki w storyboardzie. W tym podstawowym przykładzie będziemy mieli tylko jedną etykietę w każdej komórce.

import UIKit
class MyCustomCell: UITableViewCell {
    @IBOutlet weak var myCellLabel: UILabel!
}

Podłączymy to gniazdo później.

Otwórz ViewController.swift i upewnij się, że masz następująca treść:

import UIKit
class ViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {

    // These strings will be the data for the table view cells
    let animals: [String] = [
        "Ten horses:  horse horse horse horse horse horse horse horse horse horse ",
        "Three cows:  cow, cow, cow",
        "One camel:  camel",
        "Ninety-nine sheep:  sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep baaaa sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep sheep",
        "Thirty goats:  goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat goat "]

    // Don't forget to enter this in IB also
    let cellReuseIdentifier = "cell"

    @IBOutlet var tableView: UITableView!

    override func viewDidLoad() {
        super.viewDidLoad()

        // delegate and data source
        tableView.delegate = self
        tableView.dataSource = self

        // Along with auto layout, these are the keys for enabling variable cell height
        tableView.estimatedRowHeight = 44.0
        tableView.rowHeight = UITableViewAutomaticDimension
    }

    // number of rows in table view
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return self.animals.count
    }

    // create a cell for each table view row
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {

        let cell:MyCustomCell = self.tableView.dequeueReusableCell(withIdentifier: cellReuseIdentifier) as! MyCustomCell
        cell.myCellLabel.text = self.animals[indexPath.row]
        return cell
    }

    // method to run when table view cell is tapped
    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        print("You tapped cell number \(indexPath.row).")
    }
}

Ważna Uwaga:

• Są to dwie następujące linie kodu (wraz z automatycznym układem), które umożliwiają zmienną wysokość komórki:

  tableView.estimatedRowHeight = 44.0
  tableView.rowHeight = UITableViewAutomaticDimension
  

Setup the storyboard

Dodaj Widok tabeli do kontrolera widoku i użyj układu automatycznego, aby przypiąć go do czterech stron. Następnie przeciągnij komórkę widoku tabeli na widok tabeli. I na komórkę prototypu przeciągnij Etykietę. Użyj układu automatycznego, aby przypiąć etykietę do cztery krawędzie widoku zawartości komórki widoku tabeli.

Ważna uwaga:

• układ Automatyczny współpracuje z dwoma ważnymi liniami kodu, o których wspomniałem powyżej. Jeśli nie używasz układu automatycznego, to nie zadziała.

Inne ustawienia IB

Niestandardowa nazwa klasy i identyfikator

Wybierz komórkę widoku tabeli i ustaw klasę niestandardową na MyCustomCell (Nazwa klasy w pliku Swift dodaliśmy). Ustaw również identyfikator na cell (ten sam ciąg znaków, który użyliśmy dla cellReuseIdentifier w powyższym kodzie.

Linie zerowe dla etykiety

Ustaw liczbę linii na 0 w etykiecie. Oznacza to wielowierszowość i umożliwia etykiecie zmianę rozmiaru w zależności od jej zawartości.

Podłącz gniazdka

• sterowanie przeciąganiem z widoku tabeli w storyboardzie do tableView zmienna w kodzie ViewController.
• zrób to samo dla etykiety w komórce prototypu do zmiennej myCellLabel w klasie MyCustomCell.

Zakończone

Powinieneś być w stanie uruchomić swój projekt teraz i uzyskać komórki o zmiennej wysokości.

Uwagi

• ten przykład działa tylko dla iOS 8 i Później. Jeśli nadal potrzebujesz obsługi systemu iOS 7, nie będzie to dla ciebie działać.
• Twoje własne komórki w przyszłych projektach będą prawdopodobnie miały więcej niż jedna wytwórnia. Upewnij się, że wszystko jest prawidłowo przypięte, aby układ automatyczny mógł określić właściwą wysokość do użycia. Może być również konieczne zastosowanie pionowej odporności na ściskanie i przytulanie. Zobacz ten artykuł aby dowiedzieć się więcej na ten temat.

• Jeśli nie przypinasz krawędzi początkowej i końcowej (lewej i prawej), może być również konieczne ustawienie etykiety preferredMaxLayoutWidth, aby wiedziała, kiedy zawijać linię. Na przykład, jeśli do etykiety dodano ograniczenie środkowe poziomo w projekt powyżej zamiast przypinać krawędzie początkowe i końcowe, musisz dodać tę linię do metody tableView:cellForRowAtIndexPath:

   cell.myCellLabel.preferredMaxLayoutWidth = tableView.bounds.width
  

Zobacz też

• w systemie iOS 8 nie ma możliwości zmiany rozmiaru komórek i typu dynamicznego.]}
• komórki widoku tabeli o różnej wysokości wierszy
• przykład UITableView dla Swift

Zawinąłem rozwiązanie iOS7 @smileyborg w kategorii

Postanowiłem zawinąć to sprytne rozwiązanie @ smileyborg w kategorię UICollectionViewCell+AutoLayoutDynamicHeightCalculation.

Kategoria rozwiązuje również problemy opisane w odpowiedzi @wildmonkey (Ładowanie komórki z stalówki i systemLayoutSizeFittingSize: zwracanie CGRectZero)

Nie bierze pod uwagę żadnego buforowania, ale odpowiada moim potrzebom w tej chwili. Zapraszam do kopiowania, wklejania i hack na to.

UICollectionViewCell+AutoLayoutDynamicHeightCalculation.h

#import <UIKit/UIKit.h>

typedef void (^UICollectionViewCellAutoLayoutRenderBlock)(void);

/**
 *  A category on UICollectionViewCell to aid calculating dynamic heights based on AutoLayout contraints.
 *
 *  Many thanks to @smileyborg and @wildmonkey
 *
 *  @see stackoverflow.com/questions/18746929/using-auto-layout-in-uitableview-for-dynamic-cell-layouts-variable-row-heights
 */
@interface UICollectionViewCell (AutoLayoutDynamicHeightCalculation)

/**
 *  Grab an instance of the receiving type to use in order to calculate AutoLayout contraint driven dynamic height. The method pulls the cell from a nib file and moves any Interface Builder defined contrainsts to the content view.
 *
 *  @param name Name of the nib file.
 *
 *  @return collection view cell for using to calculate content based height
 */
+ (instancetype)heightCalculationCellFromNibWithName:(NSString *)name;

/**
 *  Returns the height of the receiver after rendering with your model data and applying an AutoLayout pass
 *
 *  @param block Render the model data to your UI elements in this block
 *
 *  @return Calculated constraint derived height
 */
- (CGFloat)heightAfterAutoLayoutPassAndRenderingWithBlock:(UICollectionViewCellAutoLayoutRenderBlock)block collectionViewWidth:(CGFloat)width;

/**
 *  Directly calls `heightAfterAutoLayoutPassAndRenderingWithBlock:collectionViewWidth` assuming a collection view width spanning the [UIScreen mainScreen] bounds
 */
- (CGFloat)heightAfterAutoLayoutPassAndRenderingWithBlock:(UICollectionViewCellAutoLayoutRenderBlock)block;

@end

UICollectionViewCell+AutoLayoutDynamicHeightCalculation.m

#import "UICollectionViewCell+AutoLayout.h"

@implementation UICollectionViewCell (AutoLayout)

#pragma mark Dummy Cell Generator

+ (instancetype)heightCalculationCellFromNibWithName:(NSString *)name
{
    UICollectionViewCell *heightCalculationCell = [[[NSBundle mainBundle] loadNibNamed:name owner:self options:nil] lastObject];
    [heightCalculationCell moveInterfaceBuilderLayoutConstraintsToContentView];
    return heightCalculationCell;
}

#pragma mark Moving Constraints

- (void)moveInterfaceBuilderLayoutConstraintsToContentView
{
    [self.constraints enumerateObjectsUsingBlock:^(NSLayoutConstraint *constraint, NSUInteger idx, BOOL *stop) {
        [self removeConstraint:constraint];
        id firstItem = constraint.firstItem == self ? self.contentView : constraint.firstItem;
        id secondItem = constraint.secondItem == self ? self.contentView : constraint.secondItem;
        [self.contentView addConstraint:[NSLayoutConstraint constraintWithItem:firstItem
                                                                     attribute:constraint.firstAttribute
                                                                     relatedBy:constraint.relation
                                                                        toItem:secondItem
                                                                     attribute:constraint.secondAttribute
                                                                    multiplier:constraint.multiplier
                                                                      constant:constraint.constant]];
    }];
}

#pragma mark Height

- (CGFloat)heightAfterAutoLayoutPassAndRenderingWithBlock:(UICollectionViewCellAutoLayoutRenderBlock)block
{
    return [self heightAfterAutoLayoutPassAndRenderingWithBlock:block
                                            collectionViewWidth:CGRectGetWidth([[UIScreen mainScreen] bounds])];
}

- (CGFloat)heightAfterAutoLayoutPassAndRenderingWithBlock:(UICollectionViewCellAutoLayoutRenderBlock)block collectionViewWidth:(CGFloat)width
{
    NSParameterAssert(block);

    block();

    [self setNeedsUpdateConstraints];
    [self updateConstraintsIfNeeded];

    self.bounds = CGRectMake(0.0f, 0.0f, width, CGRectGetHeight(self.bounds));

    [self setNeedsLayout];
    [self layoutIfNeeded];

    CGSize calculatedSize = [self.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize];

    return calculatedSize.height;

}

@end

Przykład użycia:

- (CGSize)collectionView:(UICollectionView *)collectionView layout:(UICollectionViewLayout *)collectionViewLayout sizeForItemAtIndexPath:(NSIndexPath *)indexPath
{
    MYSweetCell *cell = [MYSweetCell heightCalculationCellFromNibWithName:NSStringFromClass([MYSweetCell class])];
    CGFloat height = [cell heightAfterAutoLayoutPassAndRenderingWithBlock:^{
        [(id<MYSweetCellRenderProtocol>)cell renderWithModel:someModel];
    }];
    return CGSizeMake(CGRectGetWidth(self.collectionView.bounds), height);
}

Na szczęście nie będziemy musieli robić tego Jazzu w iOS8, ale na razie jest!

Oto moje rozwiązanie. Przed załadowaniem widoku należy podać w widoku TableView szacowaną wartość. W przeciwnym razie nie będzie w stanie zachowywać się jak oczekiwano.

- (void)viewWillAppear:(BOOL)animated {
    _messageField.delegate = self;
    _tableView.estimatedRowHeight = 65.0;
    _tableView.rowHeight = UITableViewAutomaticDimension;
}

Rozwiązanie zaproponowane przez @ smileyborg jest prawie idealne. Jeśli masz własną komórkę i chcesz mieć jedną lub więcej UILabel z dynamicznymi wysokościami, to metoda systemLayoutSizeFittingSize w połączeniu z włączonym AutoLayout zwraca CGSizeZero, chyba że przeniesiesz wszystkie ograniczenia komórek z komórki do contentView (jak sugeruje @TomSwift tutaj Jak zmienić rozmiar superview, aby pasował do wszystkich podwizów z autolayout?).

Aby to zrobić, musisz wstawić następujący kod w swoim niestandardowym Implementacja UITableViewCell (dzięki @Adrian).

- (void)awakeFromNib{
    [super awakeFromNib];
    for (NSLayoutConstraint *cellConstraint in self.constraints) {
        [self removeConstraint:cellConstraint];
        id firstItem = cellConstraint.firstItem == self ? self.contentView : cellConstraint.firstItem;
        id seccondItem = cellConstraint.secondItem == self ? self.contentView : cellConstraint.secondItem;
        NSLayoutConstraint *contentViewConstraint =
        [NSLayoutConstraint constraintWithItem:firstItem
                                 attribute:cellConstraint.firstAttribute
                                 relatedBy:cellConstraint.relation
                                    toItem:seccondItem
                                 attribute:cellConstraint.secondAttribute
                                multiplier:cellConstraint.multiplier
                                  constant:cellConstraint.constant];
        [self.contentView addConstraint:contentViewConstraint];
    }
}

Mieszanie @smileyborg odpowiedź z tym powinno działać.

Na tyle ważny, że wpadłem, by napisać jako odpowiedź.

@smileyborg odpowiedź jest w większości poprawna. Jeśli jednak w metodzie layoutSubviews niestandardowej klasy komórki masz jakiś kod, na przykład ustawiając preferredMaxLayoutWidth, nie będzie on uruchamiany z tym kodem:

[cell.contentView setNeedsLayout];
[cell.contentView layoutIfNeeded];

Mój kod roboczy wygląda tak:

TCAnswerDetailAppSummaryCell *cell = [self.tableView dequeueReusableCellWithIdentifier:@"TCAnswerDetailAppSummaryCell"];
[cell configureWithThirdPartyObject:self.app];
[cell layoutIfNeeded];
CGFloat height = [cell.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize].height;
return height;

Zauważ, że jeśli tworzysz nową komórkę, jestem prawie pewien, że nie musisz wywoływać setNeedsLayout, ponieważ powinna być już ustawiona. W przypadku, gdy zapisujesz odniesienie do komórki, prawdopodobnie powinieneś zadzwonić. Tak czy siak, to nie powinno zaszkodzić.

Kolejna wskazówka, jeśli używasz podklas komórek, gdzie ustawiasz rzeczy takie jak preferredMaxLayoutWidth. Jak wspomina @smileyborg, "Twoja komórka widoku tabeli nie ma jeszcze swojej szerokości ustalonej do szerokości widoku tabeli". To prawda, i kłopot, jeśli wykonujesz swoją pracę w swojej podklasie, a nie w kontrolerze widoku. Można jednak po prostu ustawić ramkę komórki w tym miejscu, używając szerokości tabeli:

Na przykład w obliczeniach wysokości:

self.summaryCell = [self.tableView dequeueReusableCellWithIdentifier:@"TCAnswerDetailDefaultSummaryCell"];
CGRect oldFrame = self.summaryCell.frame;
self.summaryCell.frame = CGRectMake(oldFrame.origin.x, oldFrame.origin.y, self.tableView.frame.size.width, oldFrame.size.height);

(zdarza mi się buforować tę konkretną komórkę do ponownego użycia, ale to nieistotne).

Na wypadek, gdyby ludzie nadal mieli z tym problemy. Napisałem szybki post na blogu o używaniu Autolayout z Uitableviews wykorzystując Autolayout dla dynamicznych wysokości komórek , a także komponent open source, aby pomóc to bardziej abstrakcyjne i łatwiejsze do wdrożenia. https://github.com/Raizlabs/RZCellSizeManager

(dla Xcode 8.x / Xcode 9.x czytane na dole)

Uwaga na następujący problem w Xcode 7.x, co może być źródłem nieporozumień:

Interface Builder nie radzi sobie z automatyczną konfiguracją komórek. Nawet jeśli Twoje ograniczenia są absolutnie ważne, IB nadal będzie narzekać i daje mylące sugestie i błędy. Powodem jest to, że IB nie chce zmieniać wysokości wiersza zgodnie z Twoimi ograniczeniami (aby komórka pasowała do Twojej treści). Zamiast tego utrzymuje stałą wysokość wiersza i zaczyna sugerować zmianę ograniczeń, co powinieneś zignorować.

Na przykład wyobraź sobie, że ustawiłeś wszystko w porządku, bez ostrzeżeń, bez błędów, wszystko działa.

Teraz jeśli zmienisz rozmiar czcionki (w tym przykładzie zmieniam rozmiar czcionki etykiety opisu z 17.0 na 18.0).

Ponieważ rozmiar czcionki się zwiększył, Etykieta chce teraz zajmować 3 wiersze (wcześniej zajmował 2 rzędy).

Jeśli Interface Builder działał zgodnie z oczekiwaniami, zmieniłby rozmiar komórki, aby dostosować ją do nowej wysokości etykiety. Jednak to, co się dzieje, to to, że IB wyświetla czerwoną ikonę błędu auto-layout i sugeruje zmodyfikowanie priorytetów Przytulania/kompresji.

Zmieniałem tę wysokość jednym kliknięciem na raz (za pomocą steppera góra/dół), aż błędy czerwonej strzałki znikną! (w rzeczywistości otrzymasz żółte ostrzeżenia, w tym momencie po prostu idź do przodu i zrób "Aktualizuj Ramki", to wszystko powinno działać).

* zauważ, że nie musisz rozwiązywać tych czerwonych błędów lub żółtych ostrzeżeń w Interface Builder - w czasie wykonywania wszystko będzie działać poprawnie (nawet jeśli IB pokazuje błędy/ostrzeżenia). Tylko upewnij się, że w czas pracy w dzienniku konsoli nie występują błędy AutoLayout.

W rzeczywistości próba aktualizacji wysokości wiersza w IB jest bardzo irytująca, a czasami prawie niemożliwa (z powodu wartości ułamkowych).

Aby zapobiec irytującym ostrzeżeniom/błędom IB, możesz wybrać widoki zaangażowane i w {[0] } dla właściwości Ambiguity Wybierz Verify Position Only

Tak długo, jak twój układ w komórce jest dobry.

-(CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [self tableView:tableView cellForRowAtIndexPath:indexPath];

    return [cell.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize].height;
}

Aktualizacja: powinieneś użyć dynamicznej zmiany rozmiaru wprowadzonej w systemie iOS 8.

Jak @Bob-Spryn natknąłem się na na tyle ważne, że zamieszczam to jako odpowiedź.

Przez jakiś czas zmagałem się z@smileyborg ' s odpowiedz. Jeśli zdefiniowałeś swoją prototypową komórkę w IB z dodatkowymi elementami (UILabels, UIButtons, itd.) w IB, gdy tworzysz instancję komórki za pomocą [[YourTableViewCellClass alloc] init], nie tworzy ona instancji wszystkich innych elementów w tej komórce, chyba że napisałeś w tym celu kod. (Miałem podobne doświadczenie z initWithStyle.)

Aby storyboard stworzył instancję wszystkich dodatkowych elementów, uzyskaj komórkę za pomocą [tableView dequeueReusableCellWithIdentifier:@"DoseNeeded"] (nie [tableView dequeueReusableCellWithIdentifier:forIndexPath:], ponieważ spowoduje to interesujące problemy.) Kiedy to zrobisz, wszystkie elementy zdefiniowane w IB zostaną utworzone.

Dynamiczny widok tabeli wysokość komórki i automatyczny układ

Dobry sposób na rozwiązanie problemu z układem automatycznym storyboard:

- (CGFloat)heightForImageCellAtIndexPath:(NSIndexPath *)indexPath {
  static RWImageCell *sizingCell = nil;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
    sizingCell = [self.tableView dequeueReusableCellWithIdentifier:RWImageCellIdentifier];
  });

  [sizingCell setNeedsLayout];
  [sizingCell layoutIfNeeded];

  CGSize size = [sizingCell.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize];
  return size.height;
}

Aby ustawić automatyczny wymiar dla wysokości wiersza i szacowanej wysokości wiersza, upewnij się, że wykonasz następujące kroki, aby wymiar automatyczny był skuteczny dla układu wysokości komórki/wiersza.

• Przypisywanie i implementowanie tableview dataSource i delegowanie
• przypisanieUITableViewAutomaticDimension do rowHeight & estimatedRowHeight
• zaimplementuj metody delegate/dataSource (tzn. heightForRowAt i zwróć do niej wartość UITableViewAutomaticDimension)

-

Cel C:

// in ViewController.h
#import <UIKit/UIKit.h>

@interface ViewController : UIViewController <UITableViewDelegate, UITableViewDataSource>

  @property IBOutlet UITableView * table;

@end

// in ViewController.m

- (void)viewDidLoad {
    [super viewDidLoad];
    self.table.dataSource = self;
    self.table.delegate = self;

    self.table.rowHeight = UITableViewAutomaticDimension;
    self.table.estimatedRowHeight = UITableViewAutomaticDimension;
}

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

    return UITableViewAutomaticDimension;
}

Swift:

@IBOutlet weak var table: UITableView!

override func viewDidLoad() {
    super.viewDidLoad()

    // Don't forget to set dataSource and delegate for table
    table.dataSource = self
    table.delegate = self

    // Set automatic dimensions for row height
    // Swift 4.2 onwards
    table.rowHeight = UITableView.automaticDimension
    table.estimatedRowHeight = UITableView.automaticDimension


    // Swift 4.1 and below
    table.rowHeight = UITableViewAutomaticDimension
    table.estimatedRowHeight = UITableViewAutomaticDimension

}



// UITableViewAutomaticDimension calculates height of label contents/text
func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
    // Swift 4.2 onwards
    return UITableView.automaticDimension

    // Swift 4.1 and below
    return UITableViewAutomaticDimension
}

Dla instancja etykiety w UITableviewCell

• Set number of lines = 0 (&line break mode = truncate tail)
• Ustaw wszystkie ograniczenia (góra, dół, prawy lewy) w odniesieniu do jego kontenera superview/ cell.
• opcjonalne : ustaw minimalną wysokość etykiety, jeśli chcesz, aby minimalna powierzchnia pionowa była pokryta etykietą, nawet jeśli nie ma danych.

Uwaga: jeśli masz więcej niż jedną etykietę (UIElements) o dynamicznej długości, która powinna być dostosowana w zależności od rozmiaru zawartości: Dostosuj "priorytet Przytulania zawartości i odporności na ściskanie" dla etykiet, które chcesz rozszerzyć/skompresować z wyższym priorytetem.

Inne "rozwiązanie": pomiń całą tę frustrację i użyj UIScrollView zamiast tego, aby uzyskać wynik, który wygląda i wydaje się identyczny z UITableView.

To było bolesne "rozwiązanie" dla mnie, po tym, jak włożyłem dosłownie 20+ bardzo frustrujące godziny, próbując zbudować coś takiego, co zasugerował smileyborg i zawodząc przez wiele miesięcy i trzy wersje wydań App Store.

Moim zdaniem, jeśli naprawdę potrzebujesz wsparcia dla iOS 7 (dla nas jest to niezbędne), technologia jest po prostu zbyt kruche i będziesz ciągnąć włosy próbując. I że UITableView jest kompletnym przesadą, chyba że używasz niektórych zaawansowanych funkcji edycji wierszy i / lub naprawdę potrzebujesz obsługi 1000 + "wierszy" (w naszej aplikacji, to realistycznie nigdy nie więcej niż 20 wierszy).

Dodatkową zaletą jest to, że kod staje się szalenie prosty w porównaniu z całym gównem delegatów i z powrotem, które pochodzi z UITableView. To tylko jedna pętla kodu w viewOnLoad, która wygląda elegancko i jest łatwa do Zarządzaj.

Oto kilka wskazówek jak to zrobić:

1) używając Storyboard lub pliku nib, Utwórz kontroler widoku i powiązany z nim widok główny.

2) przeciągnij UIScrollView do widoku głównego.

3) Dodaj ograniczenia góra, dół, lewo i prawo do widoku najwyższego poziomu tak, aby UIScrollView wypełnił cały widok główny.

4) Dodaj UIView wewnątrz UIScrollView i nazwij go "kontenerem". Dodaj górne, dolne, lewe i prawe ograniczenia do widoku UIScrollView (jego rodzica). Kluczowy TRICK: Dodaj również ograniczenia "równe szerokości", aby połączyć UIScrollView i UIView.

Pojawi się błąd "widok przewijania ma niejednoznaczną wysokość przewijanej zawartości" i że Twój kontener UIView powinien mieć wysokość 0 pikseli. Żaden błąd nie ma znaczenia, gdy aplikacja jest uruchomiona.

5) twórz pliki nib i kontrolery dla każdej z twoich "komórek". Użyj UIView, a nie UITableViewCell.

5) w głównym kontrolerze ViewController, zasadniczo dodajesz wszystkie "wiersze" do kontener UIView i programowo dodają ograniczenia łączące ich lewą i prawą krawędź z widokiem kontenera, ich górne krawędzie z widokiem kontenera na górze (dla pierwszego elementu) lub poprzedniej komórki. Następnie połącz ostatnią komórkę z dnem pojemnika.

Dla nas, każdy "wiersz" jest w pliku stalówki. Więc kod wygląda mniej więcej tak:

class YourRootViewController {

    @IBOutlet var container: UIView! //container mentioned in step 4

    override func viewDidLoad() {

        super.viewDidLoad()

        var lastView: UIView?
        for data in yourDataSource {

            var cell = YourCellController(nibName: "YourCellNibName", bundle: nil)
            UITools.addViewToTop(container, child: cell.view, sibling: lastView)
            lastView = cell.view
            //Insert code here to populate your cell
        }

        if(lastView != nil) {
            container.addConstraint(NSLayoutConstraint(
                item: lastView!,
                attribute: NSLayoutAttribute.Bottom,
                relatedBy: NSLayoutRelation.Equal,
                toItem: container,
                attribute: NSLayoutAttribute.Bottom,
                multiplier: 1,
                constant: 0))
        }

        ///Add a refresh control, if you want - it seems to work fine in our app:
        var refreshControl = UIRefreshControl()
        container.addSubview(refreshControl!)
    }
}

A oto kod do UITools.addViewToTop:

class UITools {
    ///Add child to container, full width of the container and directly under sibling (or container if sibling nil):
    class func addViewToTop(container: UIView, child: UIView, sibling: UIView? = nil)
    {
        child.setTranslatesAutoresizingMaskIntoConstraints(false)
        container.addSubview(child)

        //Set left and right constraints so fills full horz width:

        container.addConstraint(NSLayoutConstraint(
            item: child,
            attribute: NSLayoutAttribute.Leading,
            relatedBy: NSLayoutRelation.Equal,
            toItem: container,
            attribute: NSLayoutAttribute.Left,
            multiplier: 1,
            constant: 0))

        container.addConstraint(NSLayoutConstraint(
            item: child,
            attribute: NSLayoutAttribute.Trailing,
            relatedBy: NSLayoutRelation.Equal,
            toItem: container,
            attribute: NSLayoutAttribute.Right,
            multiplier: 1,
            constant: 0))

        //Set vertical position from last item (or for first, from the superview):
        container.addConstraint(NSLayoutConstraint(
            item: child,
            attribute: NSLayoutAttribute.Top,
            relatedBy: NSLayoutRelation.Equal,
            toItem: sibling == nil ? container : sibling,
            attribute: sibling == nil ? NSLayoutAttribute.Top : NSLayoutAttribute.Bottom,
            multiplier: 1,
            constant: 0))
    }
}

Jedyną "gotcha" jaką znalazłem z tym podejściem do tej pory jest to, że UITableView ma ładną funkcję "pływających" nagłówków sekcji u góry widoku podczas przewijania. Powyższe rozwiązanie tego nie zrobi, jeśli nie dodasz więcej programowania, ale w naszym konkretnym przypadku ta funkcja nie była w 100% niezbędna i nikt nie zauważył, kiedy odeszła.

Jeśli chcesz dzielniki między komórkami, po prostu dodaj 1 piksel wysoki UIView na dole niestandardowej "komórki", która wygląda jak dzielnik.

Pamiętaj, aby włączyć "bounces" i "bounce vertical", aby Kontrola odświeżania działała i więc wydaje się bardziej jak widok tabeli.

TableView pokazuje kilka pustych wierszy i dzielników pod Twoją zawartością, jeśli nie wypełnia pełnego ekranu, gdzie to rozwiązanie nie. ale osobiście wolę, jeśli te puste wiersze nie były tam i tak - przy zmiennej wysokości komórki zawsze wydawało mi się" buggy", aby mieć puste wiersze tam.

Mam nadzieję, że jakiś inny programista czyta mój post, zanim zmarnuje 20 + godzin, próbując to rozgryźć za pomocą widoku tabeli w swojej własnej aplikacji. :)

tableView.estimatedRowHeight = 343.0
tableView.rowHeight = UITableViewAutomaticDimension

Musiałem użyć dynamicznych widoków (widoki konfiguracji i ograniczenia według kodu) i kiedy chciałem ustawić preferredMaxLayoutWidth szerokości etykiety było 0. Więc mam złą wysokość komórki.

Potem dodałem

[cell layoutSubviews];

Przed wykonaniem

[cell setNeedsUpdateConstraints];
[cell updateConstraintsIfNeeded];

Po tej etykiecie szerokość była zgodna z oczekiwaniami, a dynamiczna wysokość była obliczana prawidłowo.

Załóżmy, że masz komórkę z subviewem i chcesz, aby jej wysokość była wystarczająco wysoka, aby obejmowała subview + padding.

1) Ustaw dolne ograniczenie subview równe komórce.contentView minus padding, który chcesz. Nie ustawiaj ograniczeń na komórce lub komórce.contentView itself.

2) ustaw właściwość tableView rowHeight LUB tableView:heightForRowAtIndexPath: na UITableViewAutomaticDimension.

3) Ustaw albo Właściwość tableView estimatedRowHeight albo tableView:estimatedHeightForRowAtIndexPath:, Aby najlepiej zgadnąć wysokość.

To to.

Jeśli układasz programowo, oto, co należy wziąć pod uwagę w przypadku iOS 10 za pomocą kotwic w języku Swift.

Istnieją trzy zasady / kroki

Numer 1: Ustaw te dwie właściwości tableview na viewDidLoad, pierwsza mówi do tableview, który powinien oczekiwać dynamicznych rozmiarów na swoich komórkach, druga jest po prostu pozwolić aplikacji obliczyć rozmiar wskaźnika paska przewijania, więc pomaga to w wydajności.

    tableView.rowHeight = UITableViewAutomaticDimension
    tableView.estimatedRowHeight = 100

Numer 2: jest to ważne, musisz dodać podgląd zawartości komórki nie do widoku, a także użyj jej layoutsmarginguide do zakotwiczenia podglądów na górze i na dole, jest to roboczy przykład, jak to zrobić.

override init(style: UITableViewCellStyle, reuseIdentifier: String?) {
    super.init(style: style, reuseIdentifier: reuseIdentifier)
    setUpViews()
}

private func setUpViews() {

    contentView.addSubview(movieImageView)
    contentView.addSubview(descriptionLabel)
    let marginGuide = contentView.layoutMarginsGuide

    NSLayoutConstraint.activate([
        movieImageView.heightAnchor.constraint(equalToConstant: 80),
        movieImageView.widthAnchor.constraint(equalToConstant: 80),
        movieImageView.leftAnchor.constraint(equalTo: marginGuide.leftAnchor),
        movieImageView.topAnchor.constraint(equalTo: marginGuide.topAnchor, constant: 20),

        descriptionLabel.leftAnchor.constraint(equalTo: movieImageView.rightAnchor, constant: 15),
        descriptionLabel.rightAnchor.constraint(equalTo: marginGuide.rightAnchor),
        descriptionLabel.bottomAnchor.constraint(equalTo: marginGuide.bottomAnchor, constant: -15),
        descriptionLabel.topAnchor.constraint(equalTo: movieImageView.topAnchor)

        ])
}

Utwórz metodę, która doda Podglądy i wykona układ, wywołując go w metodzie init.

NUMER 3: NIE WYWOŁAJ METODY:

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

Jeśli to zrobisz, nadpiszesz swoją implementację.

Postępuj zgodnie z tymi 3 regułami dla komórek dynamicznych w widoku tableviews.

Oto realizacja robocza https://github.com/jamesrochabrun/MinimalViewController

W moim przypadku muszę stworzyć własną komórkę z obrazem pochodzącym z serwera i może mieć dowolną szerokość i wysokość. I dwa Uilabele o dynamicznym rozmiarze (zarówno szerokość jak i wysokość)

To samo osiągnąłem tutaj w odpowiedzi z autolayout i programowo:

Zasadniczo powyżej @smileyBorg odpowiedź pomogła, ale systemLayoutSizeFittingSize nigdy nie działał dla mnie, w moim podejściu:

1. Brak użycia właściwości automatycznego obliczania wysokości wiersza. 2.No zastosowanie szacowanej wysokości 3.No potrzeba niepotrzebnych updateConstraints. 4.No zastosowanie automatycznej preferowanej maksymalnej szerokości układu. 5. No use of systemLayoutSizeFittingSize (should have use but not working for me, I dont know what it is doing internally), but instead my method - (float)getViewHeight working and I know what it ' s doing internally.

Czy można mieć różną wysokość w komórce UITableView, gdy używam kilku różnych sposobów wyświetlania komórki?

W moim przypadku padding był spowodowany wysokością sectionHeader i sectionFooter, gdzie storyboard pozwolił mi zmienić go na minimum 1. Tak więc w metodzie viewDidLoad:

tableView.sectionHeaderHeight = 0
tableView.sectionFooterHeight = 0

Zrobiłem jakąś głupią próbę i błąd z 2 wartościami rowHeight i estimatedRowHeight i pomyślałem, że może to dostarczyć trochę debugowania:

Jeśli ustawisz oba lub tylko estimatedRowHeight, otrzymasz pożądane zachowanie:

tableView.rowHeight = UITableViewAutomaticDimension
tableView.estimatedRowHeight = 1.00001 // MUST be greater than 1

Sugeruje się, aby zrobić wszystko, co w twojej mocy, aby uzyskać poprawne oszacowanie, ale wynik końcowy nie jest inny. To tylko wpłynie na Twoją wydajność.

Jeśli ustawisz tylko rowHeight ie tylko do:

tableView.rowHeight = UITableViewAutomaticDimension

Twój efekt końcowy nie będzie taki, jak chcesz:

Jeśli ustawisz estimatedRowHeight na 1 lub mniejszy, tozawiesisz niezależnie od rowHeight.

tableView.rowHeight = UITableViewAutomaticDimension
tableView.estimatedRowHeight = 1 

I crashed with the following error message:

Terminating app due to uncaught exception
'NSInternalInconsistencyException', reason: 'table view row height
must not be negative - provided height for index path (<NSIndexPath:
0xc000000000000016> {length = 2, path = 0 - 0}) is -1.000000'
    ...some other lines...

libc++abi.dylib: terminating with uncaught exception of type
NSException

Odnośnie zaakceptowanej odpowiedzi przez @ smileyborg, znalazłem

[cell.contentView systemLayoutSizeFittingSize:UILayoutFittingCompressedSize]

Być nierzetelnym w niektórych przypadkach, gdy ograniczenia są niejednoznaczne. Lepiej wymusić na silniku układu obliczenie wysokości w jednym kierunku, używając kategorii helper na poniższym UIView:

-(CGFloat)systemLayoutHeightForWidth:(CGFloat)w{
    [self setNeedsLayout];
    [self layoutIfNeeded];
    CGSize size = [self systemLayoutSizeFittingSize:CGSizeMake(w, 1) withHorizontalFittingPriority:UILayoutPriorityRequired verticalFittingPriority:UILayoutPriorityFittingSizeLevel];
    CGFloat h = size.height;
    return h;
}

Gdzie w: jest szerokością widoku tabeli

Jeśli masz długi sznurek. np. taki, który nie ma przerwania linii. Wtedy możesz napotkać pewne problemy.

Poprawka jest wymieniona przez zaakceptowaną odpowiedź i kilka innych odpowiedzi. Wystarczy dodać

cell.myCellLabel.preferredMaxLayoutWidth = tableView.bounds.width

Choć nie wyjaśniają dlaczego . Zróbmy to.

Wrzuć poniższy kod do projektu.

import UIKit

class ViewController: UIViewController {

    lazy var label : UILabel = {
        let lbl = UILabel()
        lbl.translatesAutoresizingMaskIntoConstraints = false
        lbl.backgroundColor = .red
        lbl.textColor = .black
        return lbl
    }()

    override func viewDidLoad() {
        super.viewDidLoad()
        // step0: (0.0, 0.0)
        print("empty Text intrinsicContentSize: \(label.intrinsicContentSize)")
        // step1: (29.0, 20.5)
        label.text = "hiiiii"
        print("hiiiii intrinsicContentSize: \(label.intrinsicContentSize)")
        // step2: (328.0, 20.5)
        label.text = "translatesAutoresizingMaskIntoConstraints"
        print("1 translate intrinsicContentSize: \(label.intrinsicContentSize)")
        // step3: (992.0, 20.5)
        label.text = "translatesAutoresizingMaskIntoConstraints translatesAutoresizingMaskIntoConstraints translatesAutoresizingMaskIntoConstraints"
        print("3 translate intrinsicContentSize: \(label.intrinsicContentSize)")
        // step4: (328.0, 20.5)
        label.text = "translatesAutoresizingMaskIntoConstraints\ntranslatesAutoresizingMaskIntoConstraints\ntranslatesAutoresizingMaskIntoConstraints"
        print("3 translate w/ line breaks intrinsicContentSize: \(label.intrinsicContentSize)") 
        // step5: (328.0, 61.0)
        label.numberOfLines = 0
        print("3 translate w/ line breaks and '0' numberOfLines intrinsicContentSize: \(label.intrinsicContentSize)") 
        // step6: (98.5, 243.5)
        label.preferredMaxLayoutWidth = 100
        print("3 translate w/ line breaks | '0' numberOfLines | preferredMaxLayoutWidth: 100 intrinsicContentSize: \(label.intrinsicContentSize)") 

        setupLayout()
    }
    func setupLayout(){
        view.addSubview(label)
        label.centerXAnchor.constraint(equalTo: view.centerXAnchor).isActive = true
        label.centerYAnchor.constraint(equalTo: view.centerYAnchor).isActive = true
    }
}

Zauważ, że nie dodałem żadnych Rozmiar Dodałem tylko centerx, centery. Ale nadal etykieta będzie miała prawidłowy rozmiar dlaczego? Z powodu contentSize.

Aby lepiej to przetworzyć, najpierw zachowaj krok 0, a następnie skomentuj kroki 1-6. Niech setupLayout() zostanie. Obserwuj zachowanie.

Następnie odkomentuj Krok 1 i obserwuj.

Następnie odkomentuj Krok 2 i obserwuj.

Rób to, dopóki nie skomentujesz wszystkich 6 kroków i nie zaobserwujesz ich zachowań.

Co można wywnioskować ze wszystkich to? Jakie czynniki mogą zmienić contenSize?

1. Długość tekstu: jeśli masz dłuższy tekst, to wewnętrzny rozmiar Szerokość zwiększy
2. podziały linii: jeśli dodasz \n, to szerokość intrinsicContentSize będzie maksymalną szerokością wszystkich linii. Jeśli jedna linia ma 25 znaków, inna ma 2 znaki, a inna ma 21 znaków, wtedy szerokość zostanie obliczona na podstawie 25 znaków
3. liczba dozwolonych linie: musisz ustawić numberOfLines na 0 w przeciwnym razie nie będziesz miał wielu linii. Twój numberOfLines dostosuje swój wewnętrzny rozmiar wysokość

4. Dokonywanie korekt: wyobraź sobie, że na podstawie Twojego tekstu, szerokość twojego wewnętrznego contentsize wynosiła 200, A Wysokość 100, ale chciałeś ograniczyć szerokość do pojemnika etykiety co zamierzasz zrobić? Rozwiązaniem jest ustawienie go na żądaną szerokość. Robisz to ustawiając preferredMaxLayoutWidth do 130 wtedy twój nowy intrinsicContentSize będzie miał szerokość mniej więcej 130. Wysokość byłaby oczywiście większa niż 100, ponieważ potrzebowałbyś więcej linii. Mając to na uwadze, jeśli Twoje ograniczenia są ustawione poprawnie, nie będziesz musiał tego w ogóle używać! Więcej na ten temat można znaleźć w ta odpowiedź i jej komentarze. Musisz tylko użyć preferredMaxLayoutWidth, jeśli nie masz ograniczeń ograniczających szerokość/wysokość, jak w jednym może powiedzieć " nie zawijaj tekstu, chyba że przekracza preferredMaxLayoutWidth". Ale ze 100% pewnością jeśli Ustaw początek / koniec i numberOfLines na {[7] } wtedy jesteś dobry! długa historia krótka większość odpowiedzi tutaj, które zalecają korzystanie z niego są błędne! Nie potrzebujesz tego. Potrzeba to znak, że Twoje ograniczenia nie są ustawione poprawnie lub po prostu nie masz ograniczeń

5. Rozmiar czcionki: zauważ również, że jeśli zwiększysz wielkość czcionki, wzrośnie wewnętrzna wysokość czcionki . Nie pokazałem tego w kodzie. Możesz spróbować na swoim własne.

Więc wróć do przykładu tableViewCell:

Wszystko, co musisz zrobić, to ustawić numberOfLines na 0 i ustawić preferredMaxLayoutWidth na tableView'S width.

Po prostu dodaj te dwie funkcje do kontrolera viewcontroller to rozwiąże twój problem. Tutaj list jest tablicą łańcuchów, która zawiera twój ciąg każdego wiersza.

 func tableView(_ tableView: UITableView, 
   estimatedHeightForRowAt indexPath: IndexPath) -> CGFloat {
        tableView.rowHeight = self.calculateHeight(inString: list[indexPath.row])

    return (tableView.rowHeight) 
}

func calculateHeight(inString:String) -> CGFloat
{
    let messageString = input.text
    let attributes : [NSAttributedStringKey : Any] = [NSAttributedStringKey(rawValue: NSAttributedStringKey.font.rawValue) : UIFont.systemFont(ofSize: 15.0)]

    let attributedString : NSAttributedString = NSAttributedString(string: messageString!, attributes: attributes)

    let rect : CGRect = attributedString.boundingRect(with: CGSize(width: 222.0, height: CGFloat.greatestFiniteMagnitude), options: .usesLineFragmentOrigin, context: nil)

    let requredSize:CGRect = rect
    return requredSize.height
}

Jeszcze jedno rozwiązanie iOs7+iOs8 w języku Swift

var cell2height:CGFloat=44

override func viewDidLoad() {
    super.viewDidLoad()
    theTable.rowHeight = UITableViewAutomaticDimension
    theTable.estimatedRowHeight = 44.0;
}

func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
    let cell =  tableView.dequeueReusableCellWithIdentifier("myTableViewCell", forIndexPath: indexPath) as! myTableViewCell
    cell2height=cell.contentView.height
    return cell
}

func tableView(tableView: UITableView, heightForRowAtIndexPath indexPath: NSIndexPath) -> CGFloat {
    if #available(iOS 8.0, *) {
        return UITableViewAutomaticDimension
    } else {
        return cell2height
    }
}