¿Debo usar dequeReusableCellWithIdentifier?

Sé que esta pregunta es tonta. Pero de repente se quedó atascado con esta pregunta.

Cuando uso dequeReusableCellWithIdentifier , las celdas se reutilizan. Para ser más específico, se reutiliza el primer set de celdas 'n' junto con sus references

Como las mismas references se reutilizan, no puedo almacenar las variables locales en las celdas. De hecho, tengo que asignarlos cada vez en cellForRowAtIndexPath

Supongamos que estoy usando un complejo personalizado UITableviewcell. (Sé que deberíamos networkingucir la complejidad. Pero aún así …)

Algunas vistas deben agregarse a la celda.

El mejor ejemplo que se me ocurre es un control deslizante de image.

Por lo tanto, el número de imágenes en el slider de imágenes difiere según la fuente de datos. Por lo tanto, necesito agregar las vistas en cellForRowAtIndexPath. No puedo evitarlo

Como se reutiliza la misma reference de celdas, necesito agregar estas vistas cada vez que se invoca cellForRowAtIndexPath. Creo que es un poco pesado.

Pensé en utilizar el método drawRect , pero no funciona con UITableViewAutomaticDimension

Si no uso dequeReusableCell, tendré celdas referencedas individuales, pero le costará la memory y el performance.

Entonces, ¿cuál es la mejor solución? ¿Puedo usar dequeReusableCell y aún no necesito reescribir su contenido?

Edit 1: Al mencionar dequeReusableCell, mencioné dequeueReusableCellWithIdentifier – forIndexPath. Siento la confusión.

Edición 2: me siento, no estoy tan claro en mi pregunta.

Consideremos que tengo una matriz en mi viewcontroller. Estoy configurando mi celda en cellForRowAtIndexPath con dequeueReusableCellWithIdentifier – forIndexPath

Entonces, lo que sucede es que cada vez que me desploop, cuando las filas invisibles se vuelven visibles, se invoca cellForRowAtIndexPath.

Digamos que tengo un control deslizante de image con n vistas de imágenes. Para cada celda, esta 'n' difiere. Así que me veo obligado a dibujar la vista de la celda en function de su dataSource.

Por lo tanto, cada vez que tableView llama a cellForRowAtIndexPath, la celda se configura una y otra vez.

Quiero evitar esto para mejorar el performance.

Lo que hago en este caso es el siguiente:

  1. Siempre utilizo dequeReusableCell: por razones que ya dijiste
  2. Escribo un método cleanCell en la class UITableViewCell personalizada para limpiar todo lo que ya se ha configurado en la celda (solo para que esté listo para su reutilización)
  3. luego en el cellForRowAtIndexPath: configuro mi celda como se desee

Eso es lo que haría: movería la lógica de agregar esas pesadas vistas dentro de la class de la célula misma. Entonces, en cellForRowAtIndexPath , simplemente establecería un object que debía mostrarse dentro de la celda, y la celda crearía todas las vistas necesarias por sí misma (es una capa de vista, después de todo). Entonces dentro de cellForRowAtIndexPath se vería algo como esto:

 cell = [tableView dequeueReusableCellWithIdentifier...forIndexPath...]; cell.modelObject = myModelObject; 

y eso es.

Luego, dentro de la class de celda, implementaré optimizaciones para cambiar entre diferentes objects de model. Al igual que, puede diferir la liberación de las vistas pesadas y reutilizarlas cuando se reutilice la celda.

Para ser honesto, no consigo su ejemplo con el control deslizante, pero supongamos que tiene una sorting de estrellas de 5 estrellas, que puede ser visible o no. Hay varias forms de hacerlo, pero supongamos que acaba de agregar / eliminar un UIImageView para cada estrella. La forma en que lo haces ahora, tendría una celda vacía y crearía / agregará vistas en cellForRow . Lo que estoy sugiriendo es tener 5 UIImageView s como parte de su celda y, dentro de la celda, establecer su visibilidad en base a modelObject.rating . Algo como eso. Espero que ayude a ilustrar mi punto 🙂

ACTUALIZACIÓN : cuando su celda puede tener un número arbitrario de imágenes dentro de él, probablemente los creo dentro de la class de la celda. Entonces, por ejemplo, para el primer object model necesitamos 3 vistas de imágenes. Entonces los creamos. Pero luego no los prepareForReuse en prepareForReuse , esperamos a que venga el siguiente model de object. Y si tiene, digamos, 1 image, lanzamos 2 vistas de imágenes (o no, para no tener que volver a crearlas más tarde, depende de lo más crítico: performance o uso de memory) y Si necesita 5, creamos dos más. Y si necesita 3, ya estamos listos.

En su caso, debe utilizar el dequeueReusableCellWithIdentifier(_ identifier: String, forIndexPath indexPath: NSIndexPath) . Este método decide automáticamente si la celda debe crearse o eliminarse.

Necesito agregar estas vistas cada vez que se invoca cellForRowAtIndexPath. Creo que es un poco pesado.

No es necesario que agregue esas vistas cada vez que se cellForRowAtIndexPath . Esas vistas ya deberían agregarse una vez que se cree una celda. En cellForRowAtIndexPath , solo asigna imágenes y otros valores a esas vistas.

En caso de que si usas storyboards y celdas de prototypes, tu código debería verse así:

 var items = [UIImage]() func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell { let cell = tableView.dequeueReusableCellWithIdentifier("ImageCell", forIndexPath: indexPath) let item = items[indexPath.row] let recipient = item.recipients.first // I have given my UIImageView tag = 101 to easily access it from the view controller. // This allows me to avoid defining a custom UITableViewCell subclass for simple cells. if let imageView = cell.viewWithTag(101) as? UIImageView { imageView.image = item } return cell } 

1) Creo que necesitas usar "carga perezosa" de celdas. http://www.theappguruz.com/blog/ios-lazy-loading-images (por ejemplo)

2) Puede crear una propiedad en su viewController y crear una propiedad NSMutableDictionary, que almacenará algunos datos mediante la key de algunos, si su model tiene cosas como "ID" de las celdas o puede usar indexPath.row para ello, entonces puede cargarlo solo una vez, y la próxima vez cuando se llame -cellForRow, puede recuperar los datos de su dictionary mediante

[self.dataDictionary objectForKey: @ "cellID"];

Y con esto, resuelve su carga repetitiva. En -cellForRow puede configurar el cheque, como.

 if ([self.dataDictionary objectForKey:@"cellID"]) { cell.cellImage = [self.dataDictionary objectForKey:@"cellID"]; } else { UIImage *img = [uiimage load_image]; cell.cellImage = img; [self.dataDictionary setObject:img forKey:@"cellID"]; } 

Y así. Es como ejemplo, el tipo de datos que puede elegir usted mismo, es ejemplo.

Gracias por todos ayudándome. Creo que la mejor respuesta fue de @Eiko.

Cuando utiliza celdas reutilizables, debe ser completamente reutilizable. Si va a cambiar sus vistas según los datos, tendrá que usar un nuevo identificador o evitar el uso de celdas reutilizables.

Pero evitar las celdas reutilizables, tomará una carga. Por lo tanto, debe usar diferentes identificadores para celdas similares o como dijo @FreeNickName: puede usar una configuration intermedia y modificarla según sus necesidades.