Carregando um UITableViewCell reutilizável de um Nib

Eu sou capaz de projetar UITableViewCells customizados e carregá-los perfeitamente usando a técnica descrita no tópico encontrado em http://forums.macrumors.com/showthread.php?t=545061 . No entanto, o uso desse método não permite mais a inicialização da célula com um reuseIdentifier, o que significa que você deve criar instâncias inteiras de cada célula a cada chamada. Alguém descobriu uma boa maneira de ainda armazenar em cache determinados tipos de células para reutilização, mas ainda ser capaz de projetá-los no Interface Builder?

Basta implementar um método com a assinatura de método apropriada:

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

Na verdade, como você está construindo a célula no Interface Builder, basta definir o identificador de reutilização lá:

Ou se você estiver executando o Xcode 4, verifique a guia do inspetor de atributos:

(Editar: depois que seu XIB é gerado por XCode, ele contém um UIView vazio, mas precisamos de um UITableViewCell; portanto, você deve remover manualmente o UIView e inserir uma célula de visualização de tabela. Claro, IB não mostrará nenhum parâmetro UITableViewCell para um UIView.)

Agora, no iOS 5, há um método UITableView apropriado para isso:

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

Não me lembro onde encontrei esse código originalmente, mas tem funcionado muito bem para mim até agora.

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

Exemplo de configuração do Interface Builder ...

Veja a resposta que dei a esta pergunta:

É possível projetar subclasses NSCell no Interface Builder?

Não só é possível projetar um UITableViewCell em IB, como também é desejável porque, caso contrário, toda a fiação manual e a colocação de vários elementos são muito tediosas. A performance é boa, desde que você tome o cuidado de tornar todos os elementos opacos quando possível. O reuseID é definido em IB para as propriedades do UITableViewCell, então você usa o ID de reutilização correspondente no código ao tentar desenfileirar.

Eu também ouvi de alguns dos apresentadores da WWDC no ano passado que você não deveria fazer células de table view em IB, mas é um monte de besteira.

A partir do iOS por volta de 4.0, existem instruções específicas nos documentos do iOS que tornam este trabalho super rápido:

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

Role para baixo até onde ele fala sobre a subclasse de UITableViewCell.

Aqui está outra opção:

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

Eu crio minhas células de visualização personalizadas de maneira semelhante - exceto que conecto a célula por meio de um IBOutlet.

A [nib objectAt...]abordagem é suscetível a mudanças nas posições dos itens na matriz.

A UIViewControllerabordagem é boa - apenas experimentei e funciona bem.

MAS...

Em todos os casos, o initWithStyleconstrutor NÃO é chamado, portanto, nenhuma inicialização padrão é feita.

Eu li vários lugares sobre o uso de initWithCoderou awakeFromNib, mas nenhuma evidência conclusiva de que qualquer um deles seja o caminho certo.

Além de chamar explicitamente algum método de inicialização no cellForRowAtIndexPathmétodo, ainda não encontrei uma resposta para isso.

Há algum tempo, encontrei uma ótima postagem no blog sobre esse tópico em blog.atebits.com e, desde então, comecei a usar a classe Loren Brichter ABTableViewCell para fazer todos os meus UITableViewCells.

Você acaba com um UIView simples de contêiner para colocar todos os seus widgets, e a rolagem é extremamente rápida.

Espero que isso seja útil.

Essa técnica também funciona e não requer um ivar funky em seu controlador de visualização para gerenciamento de memória. Aqui, a célula de visualização de tabela customizada reside em um xib denominado "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];
  }

O método Louis funcionou para mim. Este é o código que uso para criar o UITableViewCell a partir da ponta:

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

A solução gustavogb não funciona para mim, o que tentei foi:

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

Parece funcionar. O blogTableViewCell é o IBOutlet para a célula e ChainesController é o proprietário do arquivo.

Dos documentos UITableView sobre dequeueWithReuseIdentifier: "Uma string que identifica o objeto de célula a ser reutilizado. Por padrão, o identificador de uma célula reutilizável é seu nome de classe, mas você pode alterá-lo para qualquer valor arbitrário."

Substituir -reuseIdentifer é arriscado. O que acontece se você tiver duas subclasses de sua subclasse de célula e usar ambas em uma única exibição de tabela? Se eles enviarem a chamada do identificador de reutilização para super, você retirará da fila uma célula do tipo errado .............. Eu acho que você precisa substituir o método reuseIdentifier, mas ele retornará um identificador suplantado corda. Ou, se um não foi especificado, faça com que ele retorne a classe como uma string.

Pelo que vale a pena, perguntei a um engenheiro do iPhone sobre isso em uma das iPhone Tech Talks. Sua resposta foi: "Sim, é possível usar o IB para criar células. Mas não faça isso. Por favor, não".

Segui as instruções da Apple vinculadas a Ben Mosher (obrigado!), Mas descobri que a Apple omitiu um ponto importante. O objeto que eles projetam em IB é apenas um UITableViewCell, assim como a variável que carregam dele. Mas se você realmente configurá-lo como uma subclasse customizada de UITableViewCell e escrever os arquivos de código para a subclasse, você pode escrever declarações IBOutlet e métodos IBAction no código e conectá-los aos seus elementos customizados em IB. Então não há necessidade de usar tags de visualização para acessar esses elementos e você pode criar qualquer tipo de célula maluca que desejar. É o paraíso Cocoa Touch.