La solución correcta es la siguiente:

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

Registro

Después de iOS 7, este proceso se ha simplificado hasta ( 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")

( Nota ) Esto también se puede lograr mediante la creación de las células en las .xibo .stroyboardlos archivos, como las células de prototipo. Si necesita adjuntar una clase de ellos, se puede seleccionar el prototipo de células y añadir la clase correspondiente (debe ser un descendiente de UITableViewCell, por supuesto).

Quitar de la cola

Y más tarde, quitado de la cola usando ( 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
}

La diferencia es que este nuevo método no sólo Retiros de cola de la célula, sino que también crea si no existente (que significa que usted no tiene que hacer if (cell == nil)travesuras), y la célula está listo para usar al igual que en el ejemplo anterior.

( Advertencia ) tableView.dequeueReusableCell(withIdentifier:for:)tiene el nuevo comportamiento, si se llama a la otra (sin indexPath:) se obtiene el comportamiento anterior, en la que usted necesita para comprobar nile instancia usted mismo, se dio cuenta del UITableViewCell?valor de retorno.

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

Y, por supuesto, del tipo de la clase asociada de la célula es la que se define en el archivo .xib para la UITableViewCellsubclase, o, alternativamente, mediante el método de registro de otra.

Configuración

Lo ideal es que sus células han sido ya configurada en términos de apariencia y posicionamiento de contenido (como etiquetas y vistas de imágenes) en el momento en que éstos fueron registrados, y en el cellForRowAtIndexPathmétodo que simplemente rellenar.

Todos juntos

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

Y, por supuesto, todo esto es disponible en ObjC con los mismos nombres.

Tomó la respuesta de Shawn Craver y limpiado un poco.

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

Hago todas las subclases de BBCell de mi UITableViewCell, y luego vuelva a colocar la norma

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

con:

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

Solía del bentford Método # 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;
}

Funciona, pero cuidado con las conexiones a del propietario del archivo en su archivo personalizado de UITableViewCell .xib.

Con la aprobación owner:selfen su loadNibNameddeclaración, se establece el UITableViewControllercomo el dueño del Archivo de la UITableViewCell.

Si arrastra y suelta en el fichero de cabecera en el IB para establecer acciones y puntos de venta, será configurarlas como el propietario del archivo por defecto.

En loadNibNamed:owner:options, el código de Apple tratará de establecer las propiedades de su UITableViewController, ya que es el propietario. Pero usted no tiene esas propiedades que se definen, por lo que se obtiene un error de ser valor de la clave de codificación compatible con :

*** 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 evento se desencadena en su lugar, obtendrá un 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

Una solución fácil es señalar las conexiones Interface Builder en el UITableViewCellpropietario del lugar de Archivo:

1. Haz clic derecho sobre el archivo de propietario para tirar de la lista de conexiones
2. Tomar una captura de pantalla con Comando-Shift-4 (arrastre para seleccionar el área a ser capturado)
3. x cabo las conexiones del propietario del archivo
4. Haga clic derecho en el UITableCell en la jerarquía de objetos y volver a agregar las conexiones.

Me he decidido a publicar, ya que no me gusta ninguna de estas respuestas - las cosas siempre pueden ser más sencilla y esto es, con mucho, la forma más concisa que he encontrado.

1. Construir su Xib en Interface Builder a su gusto

• Establecer propietario del archivo de clase NSObject
• Añadir un UITableViewCell y establecer su clase con el MyTableViewCellSubclass - si se bloquea IB (que ocurre en Xcode> 4 partir de este escrito), sólo tiene que utilizar un UIView de hacer la interfaz en Xcode 4 si todavía lo tienes por ahí
• La disposición de su subvistas dentro de esta célula y se unen sus conexiones IBOutlet a su @interface en el .h o .m (.m es mi preferencia)

2. En la subclase UIViewController o 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. En sus MyTableViewCellSubclass

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

    return self;
}

Si está usando el Interface Builder para crear células, compruebe que ha configurado el identificador en el Inspector. A continuación, compruebe que es el mismo al llamar dequeueReusableCellWithIdentifier.

Accidentalmente se olvidó de establecer algunos identificadores en un proyecto de tabla-pesado, y el cambio en el rendimiento era como la noche y el día.

Cargar UITableViewCells desde XIB ahorra una gran cantidad de código, pero generalmente da como resultado una velocidad de desplazamiento horrible (en realidad, no es el XIB sino el uso excesivo de UIViews el que causa esto).

Te sugiero que le eches un vistazo a esto: referencia del enlace

Este es el método de clase que he estado usando para crear celdas personalizadas a partir de XIB:

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

Luego, en el XIB, configuro el nombre de clase y reutilizo el identificador. Después de eso, puedo llamar a ese método en mi controlador de vista en lugar de

[[UITableViewCell] alloc] initWithFrame:]

Es lo suficientemente rápido y se usa en dos de mis aplicaciones de envío. Es más confiable que llamar [nib objectAtIndex:0]y, en mi opinión, al menos, más confiable que el ejemplo de Stephan Burlot, porque está garantizado que solo obtendrá una vista de un XIB que sea del tipo correcto.

Solución correcta es esta

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

Mira esto - http://eppz.eu/blog/custom-uitableview-cell/ - forma muy conveniente usando una clase pequeña que termina una línea en la implementación del controlador:

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

Volver a cargar la SEMILLA es caro. Mejor para cargarlo una vez, luego instanciar los objetos cuando se necesita una célula. Tenga en cuenta que puede agregar UIImageViews etc a la punta, incluso varias células, utilizando este método (de Apple "registerNIB" IOS5 permite sólo un objeto de alto nivel - Bug 10580062 "IOS5 tableView registerNib: excesivamente restrictivo"

Así que mi código es abajo - se lee en la SEMILLA una vez (en initialize como lo hice o en viewDidLoad -.. Todo lo partir de entonces, se ejemplariza la punta en objetos a continuación, elegir el que necesita Esto es mucho más eficiente que la carga de la punta una y otra vez.

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

En primer lugar importar el archivo de celda personalizado #import "CustomCell.h"y luego cambiar el método de delegado como se menciona a continuación:

- (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 forma correcta de hacerlo es crear una subclase UITableViewCell aplicación, encabezado y XI ter. En el XI ter quitar cualquier vista y sólo tiene que añadir una celda de tabla. Establecer la clase como el nombre de la subclase UITableViewCell. Para el propietario del fichero, que sea el nombre de la clase subclase UITableViewController. Conectar el propietario del archivo a la célula utilizando la salida tableViewCell.

En el archivo de cabecera:

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

En el archivo de implementación:

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

Lo que hago para esto es declarar una IBOutlet UITableViewCell *cellen tu clase de controlador. Luego invoque el NSBundle loadNibNamedmétodo de clase, que alimentará UITableViewCella la celda declarada anteriormente.

Para el xib, crearé un xib vacío y agregaré el UITableViewCellobjeto en IB, donde se puede configurar según sea necesario. Esta vista luego se conecta a la celda IBOutleten la clase de controlador.

- (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 agrega loadNibNamed (inicio de sesión de ADC)

Artículo de cocoawithlove.com. Obtuve el concepto desde (obtenga la aplicación de muestra de números de teléfono).

En Swift 4,2 y Xcode 10

Tengo tres archivos de células XIB

en viewDidLoad registrar sus archivos XIB como este ...

Este es el primer enfoque

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

Segundo enfoque se registra directamente los archivos XIB en cellForRowAt indexPath:

Se trata de mis funciones de delegado 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. Crear su propia clase personalizada AbcViewCellsubclase de UITableViewCell(Asegúrese de que el nombre de archivo de la clase y el nombre de archivo de la semilla son los mismos)

2. Cree este método de clase de extensión.

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

3. Usarlo.

   let cell: AbcViewCell = UITableViewCell.fromNib()

No sé si hay una manera canónica, pero este es mi método:

• Crea un xib para un ViewController
• Establezca la clase Propietario de archivo en UIViewController
• Eliminar la vista y agregar una UITableViewCell
• Establezca la clase de su UITableViewCell en su clase personalizada
• Establezca el Identificador de su UITableViewCell
• Establezca la salida de su vista de controlador de vista a su UITableViewCell

Y usa este código:

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

En tu ejemplo, usando

[nib objectAtIndex:0]

puede romperse si Apple cambia el orden de los elementos en el 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

}

Aquí es un enfoque universal para el registro de las células en 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)
    }
}

Explicación:

1. Reusableprotocolo genera ID de célula a partir de su nombre de la clase. Asegúrese de seguir la convención:cell ID == class name == nib name .
2. UITableViewCellse ajusta a Reusableprotocolo.
3. UITableView extensión abstrae la diferencia en el registro de células a través de la semilla o clase.

Ejemplo de uso:

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
}

Esta extensión requiere 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
    }
}

Crear un archivo Xib que contiene sólo 1 UITableViewCell personalizada.

Cárgalo.

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;

Aquí está mi método para que: Cargando UITableViewCells personalizada de archivos XI ter ... Sin embargo, otro método

La idea es crear una subclase de la SampleCell UITableViewCellcon una IBOutlet UIView *contentpropiedad y una propiedad para cada encargo subvista necesita configurar a partir del código. A continuación, para crear un archivo SampleCell.xib. En este archivo semilla, cambiar el propietario del archivo a SampleCell. Añadir un contenido de UIViewtamaño para adaptarse a sus necesidades. Agregar y configurar todos los subvistas (etiqueta, vistas de imágenes, botones, etc) que desea. Por último, vincular la vista de contenido y los subvistas al propietario del archivo.