La bonne solution est la suivante:

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

registre

Après iOS 7, ce processus a été simplifié jusqu'à ( 3.0 rapide ):

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

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

( Remarque ) Il est également possible en créant des cellules dans les .xibou les .stroyboardfichiers, comme des cellules prototypes. Si vous devez joindre une classe à eux, vous pouvez sélectionner le prototype de cellule et ajouter la classe correspondante (doit être un descendant de UITableViewCell, bien sûr).

dequeue

Et plus tard, à l' aide dequeued ( 3.0 rapide ):

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

    cell.textLabel?.text = "Hello"

    return cell
}

La différence étant que cette nouvelle méthode dequeues non seulement la cellule, il crée également si inexistant (cela signifie que vous ne devez pas faire if (cell == nil)manigances), et la cellule est prête à l' emploi comme dans l'exemple ci - dessus.

( Avertissement ) tableView.dequeueReusableCell(withIdentifier:for:)a le nouveau comportement, si vous appelez l'autre (sans indexPath:) , vous obtenez l'ancien comportement, dans lequel vous devez vérifier nilet par exemple vous iT, notez la UITableViewCell?valeur de retour.

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

Et bien sûr, le type de la classe associée de la cellule est celui défini dans le fichier .xib pour la UITableViewCellsous - classe, ou bien, en utilisant l'autre méthode de registre.

Configuration

Idéalement, vos cellules ont déjà été configurés en termes d'apparence et le positionnement du contenu (comme des étiquettes et des vues d'image) au moment où vous les avez enregistrés, et sur la cellForRowAtIndexPathméthode que vous les remplissez simplement.

Tous ensemble

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

Et bien sûr, tout cela est disponible en ObjC avec les mêmes noms.

A pris la réponse de Shawn Craver et nettoyé un peu.

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

Je fais toutes les sous-classes de mon UITableViewCell de BBCell, puis remplacer la norme

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

avec:

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

J'ai utilisé de bentford Méthode # 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;
}

Il fonctionne, mais attention pour les connexions au propriétaire du fichier dans votre fichier .xib UITableViewCell personnalisé.

En passant owner:selfdans votre loadNibNamedvous définissez la déclaration, en UITableViewControllertant que propriétaire de votre fichier de UITableViewCell.

Si vous faites glisser et déposez le fichier d'en-tête dans le Bureau international de mettre en place des actions et des points de vente, il les mettre en place en tant que propriétaire de fichier par défaut.

Dans loadNibNamed:owner:options, le code d'Apple essayera de définir les propriétés de votre UITableViewController, puisque c'est le propriétaire. Mais vous n'avez pas ces propriétés définies là, vous obtenez une erreur d'être de codage conforme à la valeur clé :

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

Si un événement se déclenche à la place, vous aurez une NSInvalidArgumentException:

-[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

Une solution de contournement simple est de pointer vos connexions Interface Builder au UITableViewCellPropriétaire de la place du fichier:

1. Faites un clic droit sur le propriétaire du fichier pour tirer la liste des connexions
2. Prenez une capture d'écran avec Commande-Maj-4 (faites glisser pour sélectionner la zone à capturer)
3. x les connexions de propriétaire du fichier
4. Faites un clic droit sur le UITableCell dans la hiérarchie d'objets et ajouter à nouveau les connexions.

J'ai décidé de poster depuis que je n'aime pas l'une de ces réponses - les choses peuvent toujours être plus simple et c'est de loin la façon la plus concise que j'ai trouvé.

1. Créez votre Xib dans Interface Builder comme vous l'aimez

• Définir propriétaire du fichier à la classe NSObject
• Ajouter un UITableViewCell et définir sa classe à MyTableViewCellSubclass - si vos accidents IB (qui se passe dans Xcode> 4 de cette écriture), il suffit d'utiliser un UIView de faire l'interface dans Xcode 4 si vous avez encore autour de la pose
• La disposition de votre intérieur subviews cette cellule et attachez vos connexions IBOutlet à votre @interface dans le .h ou .m (.m est ma préférence)

2. Dans votre sous-classe UIViewController ou UITableViewController

@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. Dans votre MyTableViewCellSubclass

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

    return self;
}

Si vous utilisez Interface Builder pour fabriquer des cellules, vérifiez que vous avez défini l'identificateur dans l'inspecteur. Ensuite, vérifiez qu'il est la même chose lors de l'appel dequeueReusableCellWithIdentifier.

J'ai oublié accidentellement de fixer des identifiants dans un projet de table-lourd, et le changement de performance était comme la nuit et le jour.

UITableViewCells Chargement de XIBs enregistre beaucoup de code, mais les résultats habituellement la vitesse de défilement horribles (en fait, ce n'est pas, mais l'utilisation XIB excessive de UIViews qui causent ce sujet).

Je vous suggère de jeter un oeil à ceci: Lien de référence

Voici la méthode de classe que je l'ai utilisé pour créer des cellules personnalisées sur XIBs:

+ (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;
}

Puis, dans le XIB, je mets le nom de classe, et l'identificateur de réutilisation. Après cela, je peux appeler cette méthode dans mon contrôleur de vue au lieu de

[[UITableViewCell] alloc] initWithFrame:]

Il est beaucoup assez rapide, et utilisé dans deux de mes applications maritimes. Il est plus fiable que d' appeler [nib objectAtIndex:0], et dans mon esprit au moins, plus fiable que l'exemple de Stephan Burlot parce que vous êtes assuré de saisir seulement une vue d'un qui est le XIB bon type.

La solution est correcte cette

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

Cochez cette - http://eppz.eu/blog/custom-uitableview-cell/ - façon très pratique à l' aide d' une petite classe qui finit par une ligne dans la mise en œuvre du contrôleur:

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

Rechargement le NIB est cher. Il vaut mieux charger une fois, puis instancier les objets lorsque vous avez besoin d'une cellule. Notez que vous pouvez ajouter UIImageViews etc à la pointe, même plusieurs cellules, en utilisant cette méthode ( « registerNIB » iOS5 ne permet qu'un seul objet supérieur de niveau d'Apple - Bug 10580062 « iOS5 tableView registerNib: trop restrictive »

Donc, mon code est ci-dessous - vous lisez dans la NIB une fois (en initialize comme je l'ai fait ou viewDidLoad -.. Tout A partir de là, vous instanciez la plume en objets choisir alors celui dont vous avez besoin Ceci est beaucoup plus efficace que le chargement de la pointe encore et encore.

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

Tout d' abord importer votre fichier de cellule personnalisé #import "CustomCell.h", puis changer la méthode déléguée comme mentionné ci - dessous:

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

La bonne façon de le faire est de créer une implémentation de la sous-classe UITableViewCell, en-tête et XIB. Dans le supprimer toutes les vues XIB et il suffit d'ajouter une cellule de table. Définissez la classe comme le nom de la sous-classe UITableViewCell. Pour le propriétaire du fichier, en faire le nom de la classe de sous-classe UITableViewController. Connectez le propriétaire du fichier à la cellule en utilisant la sortie tableViewCell.

Dans le fichier d'en-tête:

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

Dans le fichier de mise en œuvre:

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

Ce que je fais pour cela est déclarer un IBOutlet UITableViewCell *celldans votre classe contrôleur. Ensuite , invoquer la NSBundle loadNibNamedméthode de classe, qui va nourrir le UITableViewCellà la cellule déclarée ci - dessus.

Pour le xib je vais créer un vide et ajouter xib l' UITableViewCellobjet IB où il peut être configuré en fonction des besoins. Ce point de vue est ensuite reliée à la cellule IBOutletdans la classe du contrôleur.

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

additions NSBundle loadNibNamed (login ADC)

article cocoawithlove.com I provient du concept de (obtenir l'application des numéros de téléphone de l'échantillon)

Dans Swift 4,2 et 10 Xcode

J'ai trois fichiers de cellules XIB

dans viewDidLoad enregistrer vos fichiers comme celui-ci ... XIB

C'est la première approche

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

Deuxième approche registre directement les fichiers dans XIB cellForRowAt indexPath:

Ceci est mon fonctions de délégué tableview

//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
    }

}

1. Créez votre propre classe personnalisée AbcViewCellsous - classe de UITableViewCell(Assurez - vous que votre nom de fichier de classe et le nom du fichier nib sont les mêmes)

2. Créer cette méthode de classe d'extension.

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

3. Utilise le.

   let cell: AbcViewCell = UITableViewCell.fromNib()

Je ne sais pas s'il y a une façon canonique, mais voici ma méthode:

• Créer un xib pour un ViewController
• Définissez la classe du propriétaire du fichier à UIViewController
• Supprimer la vue et ajouter un UITableViewCell
• Définissez la classe de votre UITableViewCell à votre classe personnalisée
• Réglez l'identifiant de votre UITableViewCell
• Réglez la sortie de votre point de vue vue du contrôleur à votre UITableViewCell

En utilisant ce code:

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

Dans votre exemple, en utilisant

[nib objectAtIndex:0]

peut casser si Apple change l'ordre des éléments dans la xib.

 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

}

Voici une approche universelle pour l' enregistrement des cellules dans UITableView:

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

Explication:

1. Reusableprotocole génère ID de cellule à partir de son nom de classe. Assurez - vous que vous suivez la convention: cell ID == class name == nib name.
2. UITableViewCellest conforme au Reusableprotocole.
3. UITableView l'extension fait abstraction de la différence dans l'enregistrement des cellules via nib ou classe.

Exemple d'utilisation:

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
}

Cette extension nécessite 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
    }
}

Créez un fichier Xib qui contient UITableViewCell juste 1 personnalisé.

Charge le.

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

 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;

Voici ma méthode pour cela: Chargement personnalisé UITableViewCells de fichiers ... XIB Une autre méthode

L'idée est de créer une sous - classe SampleCell de la UITableViewCellavec une IBOutlet UIView *contentpropriété et une propriété pour chaque commande sous - vue vous devez configurer à partir du code. Ensuite , pour créer un fichier SampleCell.xib. Dans ce fichier nib, changer le propriétaire du fichier à SampleCell. Ajouter un contenu de UIViewtaille pour répondre à vos besoins. Ajouter et configurer tous les sous - vues (étiquette, vues d'image, boutons, etc.) que vous voulez. Enfin, relier la vue du contenu et les sous - vues au propriétaire du fichier.