Caricamento di un UITableViewCell riutilizzabile da un pennino

Sono in grado di progettare UITableViewCells personalizzati e caricarli correttamente utilizzando la tecnica descritta nel thread trovato su http://forums.macrumors.com/showthread.php?t=545061 . Tuttavia, l'utilizzo di quel metodo non ti consente più di inizializzare la cella con un reuseIdentifier, il che significa che devi creare istanze completamente nuove di ogni cella ad ogni chiamata. Qualcuno ha trovato un buon modo per memorizzare nella cache determinati tipi di celle per il riutilizzo, ma essere comunque in grado di progettarli in Interface Builder?

Basta implementare un metodo con la firma del metodo appropriata:

- (NSString *) reuseIdentifier {
  return @"myIdentifier";
}

In realtà, dato che stai costruendo la cella in Interface Builder, imposta l'identificatore di riutilizzo lì:

Oppure, se stai utilizzando Xcode 4, controlla la scheda Inspector Attributi:

(Modifica: dopo che il tuo XIB è stato generato da XCode, contiene un UIView vuoto, ma abbiamo bisogno di un UITableViewCell; quindi devi rimuovere manualmente UIView e inserire una cella di visualizzazione tabella. Ovviamente, IB non mostrerà alcun parametro UITableViewCell per un UIView.)

Ora, in iOS 5 esiste un metodo UITableView appropriato per questo:

- (void)registerNib:(UINib *)nib forCellReuseIdentifier:(NSString *)identifier

Non ricordo dove ho trovato originariamente questo codice, ma finora ha funzionato benissimo per me.

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

    static NSString *CellIdentifier = @"CustomTableCell";
    static NSString *CellNib = @"CustomTableCellView";

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

    // perform additional custom work...

    return cell;
}

Esempio di configurazione di Interface Builder ...

Guarda la risposta che ho dato a questa domanda:

È possibile progettare sottoclassi NSCell in Interface Builder?

Non solo è possibile progettare un UITableViewCell in IB, è auspicabile perché altrimenti tutto il cablaggio manuale e il posizionamento di più elementi è molto noioso. La performance va bene fintanto che stai attento a rendere tutti gli elementi opachi quando possibile. Il reuseID è impostato in IB per le proprietà di UITableViewCell, quindi si utilizza l'ID di riutilizzo corrispondente nel codice quando si tenta di rimuovere dalla coda.

Ho anche sentito da alcuni dei relatori al WWDC l'anno scorso che non dovresti creare celle di visualizzazione tabella in IB, ma è un carico di cuccette.

A partire da iOS 4.0 circa, ci sono istruzioni specifiche nei documenti iOS che rendono questo lavoro super veloce:

http://developer.apple.com/library/ios/#documentation/UserExperience/Conceptual/TableView_iPhone/TableViewCells/TableViewCells.html#//apple_ref/doc/uid/TP40007451-CH7

Scorri verso il basso fino a dove si parla di sottoclasse UITableViewCell.

Ecco un'altra opzione:

NSString * cellId = @"reuseCell";  
//...
NSArray * nibObjects = [[NSBundle mainBundle] loadNibNamed:@"CustomTableCell" owner:nil options:nil];

for (id obj in nibObjects)
{
    if ([obj isKindOfClass:[CustomTableCell class]])
    {
        cell = obj;
        [cell setValue:cellId forKey:@"reuseIdentifier"];
        break;
    }
}

Creo le mie celle di visualizzazione personalizzate in modo simile, tranne per il fatto che collego la cella tramite un IBOutlet.

L' [nib objectAt...]approccio è suscettibile di modifiche alle posizioni degli elementi nella matrice.

L' UIViewControllerapproccio è buono: l'ho appena provato e funziona abbastanza bene.

MA...

In tutti i casi il initWithStylecostruttore NON viene chiamato, quindi non viene eseguita alcuna inizializzazione predefinita.

Ho letto vari punti sull'utilizzo di initWithCodero awakeFromNib, ma nessuna prova conclusiva che uno di questi sia il modo giusto.

Oltre a chiamare esplicitamente un metodo di inizializzazione nel cellForRowAtIndexPathmetodo, non ho ancora trovato una risposta a questo.

Qualche tempo fa ho trovato un ottimo post sul blog su questo argomento su blog.atebits.com e da allora ho iniziato a utilizzare la classe ABTableViewCell di Loren Brichter per eseguire tutte le mie UITableViewCell.

Ti ritroverai con un semplice contenitore UIView per mettere tutti i tuoi widget e lo scorrimento è velocissimo.

Spero che questo sia utile.

Questa tecnica funziona anche e non richiede un ivar funky nel controller della vista per la gestione della memoria. Qui, la cella della vista tabella personalizzata risiede in un xib denominato "CustomCell.xib".

 static NSData *sLoadedCustomCell = nil;

 cell = [tableView dequeueReusableCellWithIdentifier:@"CustomCell"];
 if (cell == nil) 
 {
   if (sLoadedCustomCell == nil) 
   {        
      // Load the custom table cell xib
      // and extract a reference to the cell object returned
      // and cache it in a static to avoid reloading the nib again.

      for (id loadedObject in [[NSBundle mainBundle] loadNibNamed:@"CustomCell" owner:nil options:nil]) 
      {
        if ([loadedObject isKindOfClass:[UITableViewCell class]]) 
        {
          sLoadedCustomCell = [[NSKeyedArchiver archivedDataWithRootObject: loadedObject] retain];
          break;
        }
    }
    cell = (UITableViewCell *)[NSKeyedUnarchiver unarchiveObjectWithData: sLoadedCustomCell];
  }

Il metodo Louis ha funzionato per me. Questo è il codice che utilizzo per creare UITableViewCell dal pennino:

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

    if (cell == nil) 
    {
        UIViewController *c = [[UIViewController alloc] initWithNibName:@"CustomCell" bundle:nil];
        cell = (PostCell *)c.view;
        [c release];
    }

    return cell;
}

- (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 soluzione gustavogb non funziona per me, quello che ho provato è:

ChainesController *c = [[ChainesController alloc] initWithNibName:@"ChainesController" bundle:nil];
[[NSBundle mainBundle] loadNibNamed:@"ChaineArticleCell" owner:c options:nil];
cell = [c.blogTableViewCell retain];
[c release];

Sembra funzionare. BlogTableViewCell è l'IBOutlet per la cella e ChainesController è il proprietario del file.

Dai documenti di UITableView riguardanti dequeueWithReuseIdentifier: "Una stringa che identifica l'oggetto cella da riutilizzare. Per impostazione predefinita, l'identificatore di una cella riutilizzabile è il nome della sua classe, ma puoi cambiarlo con qualsiasi valore arbitrario."

Ignorare -reuseIdentifer è rischioso. Cosa succede se hai due sottoclassi della tua sottoclasse di celle e le utilizzi entrambe in un'unica vista tabella? Se inviano la chiamata all'identificatore di riutilizzo su super, rimuoverai dalla coda una cella del tipo sbagliato .............. Penso che sia necessario sovrascrivere il metodo reuseIdentifier, ma deve restituire un identificatore soppiantato corda. Oppure, se non ne è stato specificato uno, fare in modo che restituisca la classe come stringa.

Per quello che vale, ho chiesto informazioni a un ingegnere di iPhone in uno degli iPhone Tech Talks. La sua risposta è stata: "Sì, è possibile usare l'IB per creare cellule. Ma non farlo. Per favore, non farlo".

Ho seguito le istruzioni di Apple come linkato da Ben Mosher (grazie!) Ma ho scoperto che Apple ha omesso un punto importante. L'oggetto che progettano in IB è solo un UITableViewCell, così come la variabile che caricano da esso. Ma se lo imposti effettivamente come una sottoclasse personalizzata di UITableViewCell e scrivi i file di codice per la sottoclasse, puoi scrivere dichiarazioni IBOutlet e metodi IBAction nel codice e collegarli ai tuoi elementi personalizzati in IB. Quindi non è necessario utilizzare i tag di visualizzazione per accedere a questi elementi e puoi creare qualsiasi tipo di cella pazza che desideri. È il paradiso Cocoa Touch.