Wie Sie benutzerdefinierte UITableViewCells aus Xib Dateien laden?

StackOverflow https://stackoverflow.com/questions/540345

Frage

Die Frage ist einfach: Wie laden Sie benutzerdefinierte UITableViewCell aus Xib Dateien? Dadurch können Sie Interface Builder verwenden, um Ihre Zellen zu entwerfen. Die Antwort ist offensichtlich nicht einfach aufgrund Speicherverwaltung Fragen. Dieser Thread das Problem erwähnt und schlägt eine Lösung vor, ist aber vor NDA-Release und es fehlt Code. Hier ist ein langer Faden , das das Problem diskutiert, ohne eine definitive Antwort zu geben.

Hier ist ein Code, den ich verwendet habe: 

static NSString *CellIdentifier = @"MyCellIdentifier";

MyCell *cell = (MyCell *)[tableView dequeueReusableCellWithIdentifier:CellIdentifier];
if (cell == nil) {
    NSArray *nib = [[NSBundle mainBundle] loadNibNamed:CellIdentifier owner:self options:nil];
    cell = (MyCell *)[nib objectAtIndex:0];
}

Um diesen Code zu verwenden, erstellen MyCell.m / .h, eine neue Unterklasse von UITableViewCell und fügt IBOutlets für die Komponenten, die Sie wollen. Dann erstellen Sie eine neue „Empty XIB“ -Datei. Öffnen Sie die Datei Xib in IB, fügen Sie ein UITableViewCell Objekt, legen Sie die Kennung „MyCellIdentifier“, und legen Sie seine Klasse MyCell und fügen Sie Ihre Komponenten. Schließlich verbindet die IBOutlets zu den Komponenten. Beachten Sie, dass wir nicht auf die Datei Besitzer in IB festgelegt haben.

Andere Methoden befürworten die Datei Besitzer Einstellung und Speicherlecks warnen, wenn der Xib nicht über eine zusätzliche Fabrik Klasse geladen wird. Getestet habe ich die oben unter Instrumenten / Leaks und sah keine Speicherlecks.

Also, was ist der üblicher Weg, Zellen aus Xibs zu laden? Setzen wir Datei-Besitzer? Haben wir eine Fabrik benötigen? Wenn ja, was ist der Code für die wie Fabrik aussehen? Wenn es mehrere Lösungen gibt, lassen Sie uns die Vor- und Nachteile eines jeden von ihnen klären ...

War es hilfreich?

Lösung

Hier sind zwei Methoden, die die ursprüngliche Autor Staaten wurde von einem IB-Ingenieur empfohlen.

Sehen Sie die tatsächliche Post für weitere Details. Ich ziehe Methode # 2, wie es scheint einfacher.

Methode # 1: 

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"BDCustomCell"];
    if (cell == nil) {
        // Create a temporary UIViewController to instantiate the custom cell.
        UIViewController *temporaryController = [[UIViewController alloc] initWithNibName:@"BDCustomCell" bundle:nil];
        // Grab a pointer to the custom cell.
        cell = (BDCustomCell *)temporaryController.view;
        [[cell retain] autorelease];
        // Release the temporary UIViewController.
        [temporaryController release];
    }

    return cell;
}

Methode # 2: 

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"BDCustomCell"];
    if (cell == nil) {
        // Load the top-level objects from the custom cell XIB.
        NSArray *topLevelObjects = [[NSBundle mainBundle] loadNibNamed:@"BDCustomCell" owner:self options:nil];
        // Grab a pointer to the first object (presumably the custom cell, as that's all the XIB should contain).
        cell = [topLevelObjects objectAtIndex:0];
    }

    return cell;
}

Update (2014): Methode 2 ist immer noch gültig, aber es gibt keine Dokumentation für sie mehr. Früher war es in der offizielle Dokumentation sein aber jetzt entfernt zugunsten von Storyboards.

Ich stellte ein funktionsfähiges Beispiel auf Github:
https://github.com/bentford/NibTableCellExample

Bearbeiten für Swift 4.2 

override func viewDidLoad() {
    super.viewDidLoad()

    // Do any additional setup after loading the view.
    self.tblContacts.register(UINib(nibName: CellNames.ContactsCell, bundle: nil), forCellReuseIdentifier: MyIdentifier)
}

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {

    let cell = tableView.dequeueReusableCell(withIdentifier: MyIdentifier, for: indexPath) as! ContactsCell

    return cell
}

Andere Tipps

Die richtige Lösung ist folgende: 

- (void)viewDidLoad
{
    [super viewDidLoad];
    UINib *nib = [UINib nibWithNibName:@"ItemCell" bundle:nil];
    [[self tableView] registerNib:nib forCellReuseIdentifier:@"ItemCell"];
}

-(UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    // Create an instance of ItemCell
    PointsItemCell *cell = [tableView dequeueReusableCellWithIdentifier:@"ItemCell"];

    return cell;
}

Register

Nach dem iOS 7, wobei dieses Verfahren vereinfacht wurde bis auf ( swift 3.0 ): 

// For registering nib files
tableView.register(UINib(nibName: "MyCell", bundle: Bundle.main), forCellReuseIdentifier: "cell")

// For registering classes
tableView.register(MyCellClass.self, forCellReuseIdentifier: "cell")
  

( Hinweis ) Dies ist auch erreichbar ist, indem die Zellen in den .xib oder .stroyboard Dateien erstellen, als Prototyp Zellen.   Wenn Sie eine Klasse, um sie befestigen müssen, können Sie die Zelle Prototyp auswählen und die entsprechende Klasse hinzufügen (muss ein Nachkomme von UITableViewCell sein, natürlich).

Dequeue

Und später, aus der Warteschlange entfernt mit ( swift 3.0 ): 

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell
{
    let cell : UITableViewCell = tableView.dequeueReusableCell(withIdentifier: "cell", for: indexPath)

    cell.textLabel?.text = "Hello"

    return cell
}

Der Unterschied bestand darin, dass diese neue Methode nicht nur die Zelle aus der Warteschlange entfernt, schafft es auch, wenn nicht existierend (das bedeutet, dass Sie müssen nicht if (cell == nil) Spielereien tun), und die Zelle ist genauso wie im Beispiel verwenden, oben.

  

( Warnung ) tableView.dequeueReusableCell(withIdentifier:for:) das neue Verhalten hat, wenn Sie die andere nennen (ohne indexPath:) Sie das alte Verhalten bekommen, in dem Sie benötigen für nil zu überprüfen und die Instanz es sich, bemerken die UITableViewCell? Rückgabewert. 

if let cell = tableView.dequeueReusableCell(withIdentifier: "cell", for: indexPath) as? MyCellClass
{
    // Cell be casted properly
    cell.myCustomProperty = true
}
else
{
    // Wrong type? Wrong identifier?
}

Und natürlich ist die Art der zugehörigen Klasse der Zelle diejenige, die Sie für die UITableViewCell Unterklasse in der .xib Datei definiert ist, oder alternativ die anderen Registerverfahren.

Konfiguration

Idealerweise haben Sie Ihre Zellen bereits in Bezug auf Aussehen und Inhalt Positionierung konfiguriert (wie Etiketten und Bildansichten) von der Zeit, die Sie registriert und auf der cellForRowAtIndexPath Methode füllen Sie sie einfach in.

Alle zusammen 

class MyCell : UITableViewCell
{
    // Can be either created manually, or loaded from a nib with prototypes
    @IBOutlet weak var labelSomething : UILabel? = nil
}

class MasterViewController: UITableViewController 
{
    var data = ["Hello", "World", "Kinda", "Cliche", "Though"]

    // Register
    override func viewDidLoad()
    {
        super.viewDidLoad()

        tableView.register(MyCell.self, forCellReuseIdentifier: "mycell")
        // or the nib alternative
    }

    override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int
    {
        return data.count
    }

    // Dequeue
    override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell
    {
        let cell = tableView.dequeueReusableCell(withIdentifier: "mycell", for: indexPath) as! MyCell

        cell.labelSomething?.text = data[indexPath.row]

        return cell
    }
}

Und natürlich ist das alles in ObjC mit dem gleichen Namen.

Nahm Shawn Craver Antwort und reinigte ihn ein wenig.

BBCell.h: 

#import <UIKit/UIKit.h>

@interface BBCell : UITableViewCell {
}

+ (BBCell *)cellFromNibNamed:(NSString *)nibName;

@end

BBCell.m: 

#import "BBCell.h"

@implementation BBCell

+ (BBCell *)cellFromNibNamed:(NSString *)nibName {
    NSArray *nibContents = [[NSBundle mainBundle] loadNibNamed:nibName owner:self options:NULL];
    NSEnumerator *nibEnumerator = [nibContents objectEnumerator];
    BBCell *customCell = nil;
    NSObject* nibItem = nil;
    while ((nibItem = [nibEnumerator nextObject]) != nil) {
        if ([nibItem isKindOfClass:[BBCell class]]) {
            customCell = (BBCell *)nibItem;
            break; // we have a winner
        }
    }
    return customCell;
}

@end

Ich mache alle meine UITableViewCell die Subklassen von BBCell und dann den Standard ersetzen 

cell = [[[BBDetailCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:@"BBDetailCell"] autorelease];

mit: 

cell = (BBDetailCell *)[BBDetailCell cellFromNibNamed:@"BBDetailCell"];

Ich habe bentford Methode # 2 : 

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:@"BDCustomCell"];
    if (cell == nil) {
        // Load the top-level objects from the custom cell XIB.
        NSArray *topLevelObjects = [[NSBundle mainBundle] loadNibNamed:@"BDCustomCell" owner:self options:nil];
        // Grab a pointer to the first object (presumably the custom cell, as that's all the XIB should contain).
        cell = [topLevelObjects objectAtIndex:0];
    }

    return cell;
}

Es funktioniert, aber achten Sie auf Verbindungen zu Datei-Besitzer in Ihrem benutzerdefinierten UITableViewCell .xib Datei.

owner:self in Ihrer loadNibNamed Anweisung Durch die Übergabe stellen Sie die UITableViewController als Datei-Besitzer Ihres UITableViewCell.

Wenn Sie per Drag & Drop in die Header-Datei in IB einzurichten Aktionen und Auslässen, wird es sie als Datei Besitzer standardmäßig eingerichtet.

In loadNibNamed:owner:options, Code von Apple wird versuchen, Eigenschaften auf Ihrem UITableViewController zu setzen, da, dass der Eigentümer ist. Aber Sie müssen nicht diese Eigenschaften dort definiert haben, so erhalten Sie einen Fehler über das Sein Schlüsselwert Codierung-konformen : 

*** Terminating app due to uncaught exception 'NSUnknownKeyException', reason:     '[<MyUITableViewController 0x6a383b0> setValue:forUndefinedKey:]: this class is not key value coding-compliant for the key myLabel.'

Wenn ein Ereignis statt ausgelöst wird, erhalten Sie eine NSInvalidArgumentException bekommen: 

-[MyUITableViewController switchValueDidChange:]: unrecognized selector sent to instance 0x8e9acd0
*** Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[MyUITableViewController switchValueDidChange:]: unrecognized selector sent to instance 0x8e9acd0'
*** First throw call stack:
(0x1903052 0x15eed0a 0x1904ced 0x1869f00 0x1869ce2 0x1904ec9 0x5885c2 0x58855a 0x62db76 0x62e03f 0x77fa6c 0x24e86d 0x18d7966 0x18d7407 0x183a7c0 0x1839db4 0x1839ccb 0x1f8b879 0x1f8b93e 0x585a9b 0xb904d 0x2c75)
terminate called throwing an exceptionCurrent language:  auto; currently objective-c

Eine einfache Abhilfe ist Ihre Interface Builder Verbindungen am UITableViewCell statt Datei Besitzer Punkt:

  1. Rechtsklick auf Datei-Besitzer die Liste der Verbindungen zu ziehen
  2. Nehmen Sie einen Screenshot mit Befehl-Umschalt-4 (drag den Bereich auszuwählen, werden erfasst)
  3. x aus den Verbindungen von Datei-Besitzer
  4. Rechtsklick auf der UITableCell in der Objekthierarchie und erneut hinzufügen, die Verbindungen.

Ich habe beschlossen, posten, da ich eine dieser Antworten nicht mögen - Dinge können immer einfacher sein, und dies ist bei weitem der knappste Art, wie ich gefunden habe

.

1. Erstellen Sie Ihre Xib im Interface Builder, wie es Ihnen gefällt

  • Stellen Sie Datei Besitzer Klasse NSObject
  • Fügen Sie eine UITableViewCell und legen Sie seine Klasse MyTableViewCellSubclass - wenn Ihr IB Abstürze (geschieht in Xcode> 4 als dies geschrieben wurde), benutzen Sie einfach eine UIView von tun die Schnittstelle in Xcode 4, falls Sie es noch haben rumliegen
  • Layout Ihre Subviews innerhalb dieser Zelle und legen Sie Ihren IBOutlet Verbindungen zu Ihrem @interface in der .h oder .m (.m ist meine Präferenz)

2. In Ihrem UIViewController oder UITableViewController Unterklasse 

@implementation ViewController

static NSString *cellIdentifier = @"MyCellIdentier";

- (void) viewDidLoad {

    ...
    [self.tableView registerNib:[UINib nibWithNibName:@"MyTableViewCellSubclass" bundle:nil] forCellReuseIdentifier:cellIdentifier];
}

- (UITableViewCell*) tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    MyTableViewCellSubclass *cell = [tableView dequeueReusableCellWithIdentifier:cellIdentifier];

    ...

    return cell;
}

3. In Ihrem MyTableViewCellSubclass 

- (id) initWithCoder:(NSCoder *)aDecoder {
    if (self = [super initWithCoder:aDecoder]) {
        ...
    }

    return self;
}

Wenn Sie Interface Builder verwenden Zellen zu machen, überprüfen Sie, dass Sie den Identifier im Inspektor festgelegt haben. Dann prüfen Sie, ob es das gleiche beim Aufruf dequeueReusableCellWithIdentifier.

Ich habe vergessen, versehentlich einige Kennungen in einer Tabelle schwerer Projekt festgelegt und die Leistungsänderung war wie Tag und Nacht.

Laden UITableViewCells von XIBs spart eine Menge Code, sondern führt in der Regel schrecklich Scroll-Geschwindigkeit (eigentlich ist es nicht der XIB aber die übermäßige Verwendung von UIViews, die dies verursachen).

Ich schlage vor, Sie nehmen einen Blick auf diese: Link Referenz

Hier ist die Klassenmethode, die ich für das Erstellen von benutzerdefinierten Zellen aus XIBs verwendet habe: 

+ (CustomCell*) createNewCustomCellFromNib {

    NSArray* nibContents = [[NSBundle mainBundle]
                            loadNibNamed:@"CustomCell" owner:self options:NULL];

    NSEnumerator *nibEnumerator = [nibContents objectEnumerator];
    CustomCell *customCell= nil;
    NSObject* nibItem = nil;

    while ( (nibItem = [nibEnumerator nextObject]) != nil) {

        if ( [nibItem isKindOfClass: [CustomCell class]]) {
            customCell = (CustomCell*) nibItem;

            if ([customCell.reuseIdentifier isEqualToString: @"CustomCell"]) {
                break; // we have a winner
            }
            else
                fuelEntryCell = nil;
        }
    }
    return customCell;
}

Dann wird in der XIB, habe ich die Klassennamen und Wiederverwendung Bezeichner. Danach kann ich diese Methode in meiner Ansicht-Controller rufen Sie einfach anstelle der 

[[UITableViewCell] alloc] initWithFrame:]

Es ist viel schnell genug, und in zwei meiner Versandanwendungen verwendet wird. Es ist zuverlässiger als [nib objectAtIndex:0] nennen, und in meinem Kopf zumindest zuverlässiger als Stephan Burlot des Beispiel, weil Sie nur aus einem XIB garantiert sind, eine Ansicht zu ergreifen, die die richtige Art ist.

Die richtige Lösung ist dies 

- (void)viewDidLoad
{
    [super viewDidLoad];
    [self.tableView registerNib:[UINib nibWithNibName:@"CustomCell" bundle:[NSBundle mainBundle]] forCellReuseIdentifier:@"CustomCell"];
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath{
    UITableViewCell  *cell = [tableView dequeueReusableCellWithIdentifier:@"CustomCell"];
    return cell; 
    }

die NIB Nachladen ist teuer. Besser einmal zu laden, dann die Objekte instanziiert, wenn Sie eine Zelle benötigen. Beachten Sie, dass Sie UIImageViews usw. an die Spitze, auch mehrere Zellen hinzufügen können, mit dieser Methode (Apples „registerNIB“ iOS5 erlaubt nur eine Top-Level-Objekt - Bug 10580062 "IOS5 Tableview registerNib: zu restriktiv"

So ist mein Code unten - Sie habe einmal gelesen, in der NIB (in initialize wie ich es tat oder in viewDidLoad -.., Was von nun an Sie die Spitze in Objekte instanziiert dann wählen Sie die, die Sie brauchen Dies ist viel effizienter als Laden die Spitze über und über. 

static UINib *cellNib;

+ (void)initialize
{
    if(self == [ImageManager class]) {
        cellNib = [UINib nibWithNibName:@"ImageManagerCell" bundle:nil];
        assert(cellNib);
    }
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *cellID = @"TheCell";

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:cellID];
    if(cell == nil) {
        NSArray *topLevelItems = [cellNib instantiateWithOwner:nil options:nil];
        NSUInteger idx = [topLevelItems indexOfObjectPassingTest:^BOOL(id obj, NSUInteger idx, BOOL *stop)
                            {
                                UITableViewCell *cell = (UITableViewCell *)obj;
                                return [cell isKindOfClass:[UITableViewCell class]] && [cell.reuseIdentifier isEqualToString:cellID];
                            } ];
        assert(idx != NSNotFound);
        cell = [topLevelItems objectAtIndex:idx];
    }
    cell.textLabel.text = [NSString stringWithFormat:@"Howdie %d", indexPath.row];

    return cell;
}

Überprüfen Sie das - http://eppz.eu/blog/custom-uitableview-cell / - wirklich bequeme Möglichkeit, eine kleine Klasse verwenden, die eine Zeile in Controller-Implementierung endet: 

-(UITableViewCell*)tableView:(UITableView*) tableView cellForRowAtIndexPath:(NSIndexPath*) indexPath
{
    return [TCItemCell cellForTableView:tableView
                          atIndexPath:indexPath
                      withModelSource:self];
}

eingeben Bild Beschreibung hier

Der richtige Weg, es zu tun ist, eine UITableViewCell Unterklasse Implementierung, Kopf- und XIB zu erstellen. In der XIB alle Ansichten entfernen und nur eine Tabellenzelle hinzufügen. Stellen Sie die Klasse, wie der Name der UITableViewCell-Unterklasse. Für Dateieigentümer, machen die Unterklasse Klassenname UITableViewController es. Schließen Sie den Dateieigentümer an die Zelle die tableViewCell Steckdose.

In der Header-Datei: 

UITableViewCell *_tableViewCell;
@property (assign) IBOutlet UITableViewCell *tableViewCell;

In der Implementierungsdatei: 

@synthesize tableViewCell = _tableViewCell;

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
    static NSString *kCellIdentifier = @"reusableCell";

    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:kCellIdentifier];
    if (cell == nil) {
        [[NSBundle mainBundle] loadNibNamed:kCellIdentifier owner:self options:nil];
        cell = _tableViewCell;
        self.tableViewCell = nil;
    }

    return cell;
}

Was ich dafür tun, ist eine IBOutlet UITableViewCell *cell in Ihrer Controller-Klasse deklariert. Dann rufen Sie die NSBundle loadNibNamed Klassenmethode, die die UITableViewCell in der Zelle oben erklärt wird füttern.

Für die xib werde ich eine leere xib erstellen und das UITableViewCell Objekt in IB hinzufügen, wo es so eingerichtet werden, kann je nach Bedarf. Diese Ansicht wird dann in der Zelle IBOutlet in der Controller-Klasse verbunden ist. 

- (UITableViewCell *)tableView:(UITableView *)table
         cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    NSLog(@"%@ loading RTEditableCell.xib", [self description] );

    static NSString *MyIdentifier = @"editableCellIdentifier";
    cell = [table dequeueReusableCellWithIdentifier:MyIdentifier];

    if(cell == nil) {
        [[NSBundle mainBundle] loadNibNamed:@"RTEditableCell"
                                      owner:self
                                    options:nil];
    }

    return cell;
}

NSBundle Ergänzungen loadNibNamed (ADC Login)

cocoawithlove.com Artikel sourced ich das Konzept von (Holen Sie sich die Telefonnummern Probe app)

Sie zuerst Ihre benutzerdefinierte Zelle Datei #import "CustomCell.h" importieren und dann die delegierte Methode ändern, wie unten erwähnt: 

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {

static NSString *simpleTableIdentifier = @"CustomCell";

CustomCell *cell = (CustomCell *)[tableView dequeueReusableCellWithIdentifier:simpleTableIdentifier];
if (cell == nil)
{
    NSArray *nib = [[NSBundle mainBundle] loadNibNamed:@"CustomCell" owner:self options:nil];
    cell = [nib objectAtIndex:0];

    [cell setSelectionStyle:UITableViewCellSelectionStyleNone];
}         

     return cell;
}

  1. Erstellen Sie Ihre eigene benutzerdefinierte Klasse AbcViewCell Unterklasse von UITableViewCell (Stellen Sie sicher, Ihre Klassendateinamen und nib Dateinamen identisch sind)

  2. Erstellen Sie diese Erweiterung Klassenmethode. 

    extension UITableViewCell {
    class func fromNib<T : UITableViewCell>() -> T {
        return Bundle.main.loadNibNamed(String(describing: T.self), owner: nil, options: nil)?[0] as! T
    }
}

  3. Verwenden Sie es.

    let cell: AbcViewCell = UITableViewCell.fromNib()

Swift 4.2 und Xcode 10

Ich habe drei XIB Zelle Dateien

in ViewDidLoad registrieren Ihre XIB Dateien wie diese ...

Dies ist die erste Ansatz 

tableView.register(UINib.init(nibName: "XIBCell", bundle: nil), forCellReuseIdentifier: "cell1")
tableView.register(UINib.init(nibName: "XIBCell2", bundle: nil), forCellReuseIdentifier: "cell2")
//tableView.register(UINib.init(nibName: "XIBCell3", bundle: nil), forCellReuseIdentifier: "cell3")

Zweiter Ansatz direkt XIB Dateien in cellForRowAt indexPath registrieren:

Das ist meine Tableview delegieren Funktionen 

//MARK: - Tableview delegates
override func numberOfSections(in tableView: UITableView) -> Int {

    return 1
}

override func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {

    return 6
}

override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    //This is first approach
    if indexPath.row == 0 {//Load first XIB cell
        let placeCell = tableView.dequeueReusableCell(withIdentifier: "cell1") as! XIBCell
        return placeCell
    //Second approach
    } else if indexPath.row == 5 {//Load XIB cell3
        var cell = tableView.dequeueReusableCell(withIdentifier:"cell3") as? XIBCell3
        if cell == nil{
            let arrNib:Array = Bundle.main.loadNibNamed("XIBCell3",owner: self, options: nil)!
            cell = arrNib.first as? XIBCell3
        }

        //ADD action to XIB cell button
        cell?.btn.tag = indexPath.row//Add tag to button
        cell?.btn.addTarget(self, action: #selector(self.bookbtn1(_:)), for: .touchUpInside);//selector

        return cell!
    //This is first approach
    } else {//Load XIB cell2
        let placeCell = tableView.dequeueReusableCell(withIdentifier: "cell2") as! XIBCell2

        return placeCell
    }

}

Hier ist meine Methode dafür: Laden Individuelle UITableViewCells von XIB Dateien ... Noch ein anderes Verfahren

Die Idee ist es, eine SampleCell- Unterklasse der UITableViewCell mit einer IBOutlet UIView *content Eigenschaft und eine Eigenschaft für jeden benutzerdefinierten erstellen subview Sie aus dem Code zu konfigurieren. Dann eine SampleCell.xib Datei zu erstellen. In dieser Nib-Datei, ändern Sie die Datei Besitzer SampleCell-. Fügen Sie einen Inhalt UIView Größe an Ihre Bedürfnisse anzupassen. Hinzufügen und konfigurieren Sie alle Subviews (Label, Bildansichten, Knöpfe, etc.) Sie wollen. Schließlich verbindet die Inhaltsansicht und die Subviews den Eigentümer der Datei.

Hier ist ein universeller Ansatz für Zellen in UITableView Registrierung: 

protocol Reusable {
    static var reuseID: String { get }
}

extension Reusable {
    static var reuseID: String {
        return String(describing: self)
    }
}

extension UITableViewCell: Reusable { }

extension UITableView {

func register<T: UITableViewCell>(cellClass: T.Type = T.self) {
    let bundle = Bundle(for: cellClass.self)
    if bundle.path(forResource: cellClass.reuseID, ofType: "nib") != nil {
        let nib = UINib(nibName: cellClass.reuseID, bundle: bundle)
        register(nib, forCellReuseIdentifier: cellClass.reuseID)
    } else {
        register(cellClass.self, forCellReuseIdentifier: cellClass.reuseID)
    }
}

Erklärung:

  1. Reusable Protokoll erzeugt Zellen-ID von seinem Klassennamen. Stellen Sie sicher, dass Sie folgen der Konvention. cell ID == class name == nib name
  2. UITableViewCell entspricht Protokoll Reusable.
  3. UITableView Erweiterung abstrahiert die Differenz bei der Registrierung von Zellen über nib oder Klasse entfernt.

Anwendungsbeispiel: 

override func viewDidLoad() {
    super.viewDidLoad()
    let tableView = UITableView()
    let cellClasses: [UITableViewCell.Type] = [PostCell.self, ProfileCell.self, CommentCell.self]
    cellClasses.forEach(tableView.register)
}

override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: PostCell.self.reuseID) as? PostCell
    ...
    return cell
}

Ich weiß nicht, ob es ein üblicher Weg ist, aber hier bin meine Methode:

  • Erstellen Sie eine xib für einen Viewcontroller
  • , um die Datei-Besitzer Klasse UIViewController Set
  • die Ansicht löschen und füge eine UITableViewCell
  • Stellen Sie die Klasse Ihres UITableViewCell zu Ihrer benutzerdefinierten Klasse
  • Stellen Sie die Kennung Ihres UITableViewCell
  • Stellen Sie den Ausgang Ihrer View-Controller im Hinblick auf Ihre UITableViewCell

Und diesen Code verwenden: 

MyCustomViewCell *cell = (MyCustomViewCell *)[_tableView dequeueReusableCellWithIdentifier:CellIdentifier];
if (cell == nil) {
  UIViewController* c = [[UIViewController alloc] initWithNibName:CellIdentifier bundle:nil];
  cell = (MyCustomViewCell *)c.view;
  [c release];
}

In Ihrem Beispiel mit 

[nib objectAtIndex:0]

brechen kann, wenn Apple die Reihenfolge der Elemente in der xib ändert. 

 NSString *CellIdentifier = [NSString stringWithFormat:@"cell %ld %ld",(long)indexPath.row,(long)indexPath.section];


    NewsFeedCell *cell = (NewsFeedCell *)[tableView dequeueReusableCellWithIdentifier:CellIdentifier];
    cell=nil;

    if (cell == nil)
    {
        NSArray *topLevelObjects = [[NSBundle mainBundle] loadNibNamed:@"NewsFeedCell" owner:nil options:nil];

        for(id currentObject in topLevelObjects)
        {
            if([currentObject isKindOfClass:[NewsFeedCell class]])
            {
                cell = (NewsFeedCell *)currentObject;
                break;
            }
        }
}
return cell;

Diese Erweiterung erfordert Xcode7 beta6 

extension NSBundle {
    enum LoadViewError: ErrorType {
        case ExpectedXibToExistButGotNil
        case ExpectedXibToContainJustOneButGotDifferentNumberOfObjects
        case XibReturnedWrongType
    }

    func loadView<T>(name: String) throws -> T {
        let topLevelObjects: [AnyObject]! = loadNibNamed(name, owner: self, options: nil)
        if topLevelObjects == nil {
            throw LoadViewError.ExpectedXibToExistButGotNil
        }
        if topLevelObjects.count != 1 {
            throw LoadViewError.ExpectedXibToContainJustOneButGotDifferentNumberOfObjects
        }
        let firstObject: AnyObject! = topLevelObjects.first
        guard let result = firstObject as? T else {
            throw LoadViewError.XibReturnedWrongType
        }
        return result
    }
}

Eine Xib-Datei, die nur 1 benutzerdefinierte UITableViewCell enthält.

es laden. 

let cell: BacteriaCell = try NSBundle.mainBundle().loadView("BacteriaCell")

 func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {

            let cellReuseIdentifier = "collabCell"
            var cell:collabCell! = tableView.dequeueReusableCell(withIdentifier: cellReuseIdentifier) as? collabCell
            if cell == nil {
                tableView.register(UINib(nibName: "collabCell", bundle: nil), forCellReuseIdentifier: cellReuseIdentifier)
                cell = tableView.dequeueReusableCell(withIdentifier: cellReuseIdentifier) as! collabCell!
            }


            return cell

}
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top