6 respuestas en este tema

[Delphius]

Pues, eso... como dice el título. ¿Cuál es la manera más apropiada de manejar un TFileStream capturando y lanzando las excepciones de forma apropiada?

 

Actualmente tengo esta chapuza de código:

delphi

procedure TArrayConverter.LoadMatrix(AMatrix: TAMatrix; FileName: string);
var Header: TMatrixHeader;
    Fmt: TFileFormat;
    i, j, RM, CM, Err, ConvE: integer;
    Can: boolean;
begin
  Can := CheckMatrix(AMatrix, RM, CM, Err);
  if Can AND (Err = OPERATION_DONE)
     then begin
            try
              // Cargar el archivo
              FFile.Create(FileName, fmOpenRead or fmShareDenyWrite);
              // leemos formato
              FInUse := true;
              Fmt.SizeFile := FFile.Seek(0, soEnd);
              FFile.ReadBuffer(Fmt.IDIni, SizeOf(Fmt.IDIni)); // ID.Ini
              FFile.ReadBuffer(Header, SizeOf(Header));       // Header
              FFile.Seek(INI_ID_END, soFromEnd);
              FFile.ReadBuffer(Fmt.IDEnd, SizeOf(Fmt.IDEnd)); // ID.End
              // ¿Valido?
              if ISValidFormat(Fmt, Header)
                 then begin
                        // Supuesto tamaño de datos
                        if (Header.Rows = RM) AND (Header.Cols = CM)
                           then begin
                                  // Leemos data
                                  if Header.Orientation = aoCol
                                     then begin
                                            // ... por columnas
                                            for j := 0 to CM - 1 do
                                              for i := 0 to RM - 1 do
                                                FFile.ReadBuffer(AMatrix[i, j], SizeOf(TYPEDATA));
                                          end
                                     else begin
                                            // ... por filas
                                            for i := 0 to RM - 1 do
                                              for j := 0 to CM - 1 do
                                                FFile.ReadBuffer(AMatrix[i, j], SizeOf(TYPEDATA));
                                          end;
                                end
                           else ConvE := 3;
                      end
                 else ConvE := 2;
            finally
              FFile.Free;
              FInUse := false;
            end;
          end
     else ConvE := 1;
  // ¿Lanzamos excepción?
  case ConvE of
  1: raise EInconsistentArray.Create('Check of matrix failed', itCheck);
  2: raise EFileOperation.Create('Invalid matrix file format');
  3: raise EInconsistentArray.Create('The dimensions of the matrix and file data do not match',
     itDimNotMatch);
  end;
end;

Creería que el código se explica solo. Básicamente estoy leyendo un archivo matricial y cargando la data. Mi archivo está pensado con una estructura como la siguiente:

 

1) Viene una especie de identificador de archivo. Para el caso de matrices, tiene un valor y para vectores otro.

2) Seguidamente una cabecera que contiene la información relacionada con la dimensión de la estructura de datos.

3) Los datos propiamente dichos

4) Y por último un identificador de fin de archivo. Este es común para ambos tipos de archivos.

 

 

Se que puede ser mejorado. Pero ya tengo la cabeza muy hecha trizas, y se me confunden los tantos... Por un lado quisiera poder detectar posibles excepciones que arroje el FFileStream, desde su creación hasta cuando intenta leer y/o escribir y por el otro quisiera poder lanzar las excepciones propias que tengo definidas para el contexto de esta clase que estoy diseñando en base a mis pruebas. ¿Cómo debo proceder? ¿Un doble try anidado? ¿Cómo lo encararían ustedes?

 

Por si ayuda a comprender el código, adjunto la descripción de la clase:

delphi

TArrayConverter = class
    private
      FFile: TFileStream;
      FInUse: boolean;
      function IsValidFormat(AFormat: TFileFormat; AHeader: TMatrixHeader): boolean; overload;
      function ISValidFormat(AFormat: TFileFormat; AHeader: TVectorHeader): boolean; overload;
      function MakeHeader(Rows, Cols: integer; Orientation: TArrayOrientation): TMatrixHeader;
        overload;
      function MakeHeader(Dim: integer): TVectorHeader; overload;
    public
      constructor Create;
      destructor Destroy; override;
      procedure LoadMatrix(AMatrix: TAMatrix; FileName: string);
      procedure LoadVector(AVector: TAVector; FileName: string);
      procedure SaveMatrix(AMatrix: TAMatrix; OnDir: TArrayOrientation; FileName: string);
      procedure SaveVector(AVector: TAVector; FileName: string);
      property InUse: boolean read FInUse;
  end;

Los métodos MakeHeader() como IsValidFormat() creerían que no hace falta que adjunte. Se pueden hacer una idea de su uso. Básicamente se procede a armar la cabecera de cada archivo, y en los otros de realizar las comprobaciones de formato para asegurarse de que se ha leído un archivo correcto.

 

Leyendo la documentación, durante la creación del TFileStream es posible que se presente una excepción EFOpenError, y también puede presentarse excepciones durante el ReadBuffer y en el WriteBuffer... no dice la documentación cual. Aparentemente, de lo que estoy viendo en el código de la clase TStream parecen ser EReadError y EWriteError respectivamente.

 

Para el guardado de vectores el código sería algo similar. Las versiones Save() estimo que debieran de tener un código análogo, salvando el detalle de aplicar un WriteBuffer.

 

Cualquier ayuda y propuesta se les agradece.

Muchas gracias.

[Delphius]

De algunas búsquedas que he estado he notado que todos los códigos de ejemplo no protegen la creación del TFileStream dentro de un try, si en cambio asumen un código exitoso y proceden a aplicar un try-finally para asi liberar el TFileStream. Es decir:

php

FS := TFileStream.Create(...);
try
  // Usar el FS
finally
  FS.Free;
end;

Naturalmente, cuando se puede dar garantías de que el modo de apertura o creación del archivo nos permite un código seguro para una lectura o bien de la escritura no hay problemas con el código anterior (o al menos no esperaría algo tan problemático). Sobre todo si uno tiene separado lo que hace escritura de la lectura.

Me he estado cuestionando, ¿Y si espero que mis archivos sean de lectura Y escritura? ¿Que acaso no vale la pena proteger la creación del TFileStream?

 

Saludos,

[escafandra]

De algunas búsquedas que he estado he notado que todos los códigos de ejemplo no protegen la creación del TFileStream dentro de un try, si en cambio asumen un código exitoso y proceden a aplicar un try-finally para asi liberar el TFileStream. Es decir:

delphi

FS := TFileStream.Create(...);
try
  // Usar el FS
finally
  FS.Free;
end;

Tienes toda la razón. La estructura es buena pero no se comprueba que el archivo se ha abierto. Aunque un error de apertura, a mi juicio, no debería ser una excepción, si debe controlarse para evitar el error en el resto del código y no dejarlo hasta que salte la excepción en el bloque try.

 

 

Saludos.

[Delphius]

Yo ya estoy medio perdido.

 

Recuerdo la discusión debate que hubo en ClubDdelphi sobre algo relacionado con esto.

 

En él se comentó sobre el caso particular que plantea justamente: para el caso en donde un constructor eleva una excepción. Para ese entonces, el debate no hiló fino en ese caso y se abordó hacia un planteo general. La documentación de Delphi sugiere que un objeto es creado o no creado. Nada de a medias, que se invoca a Destroy implícitamente y no tendría sentido un Free por el lado de Finally.

Más me sigo cuestionando, ¿Y que hacemos como excepción?

Tu dices que debiera de controlarse efectivamente de que el recurso, en este caso, un archivo esté abierto.

 

Sabemos que entre Delphi y Lazarus tienen sus diferencias. ¿Aquí será un caso? Intenté llegar a algo que me aclare el punto, y llego a algo parecido a la discusión en CD pero para el caso de Lazarus, no hay una confirmación real si FPC se comporta igual que Delphi en esto. La gente que ha intervenido en el mailing list asume que SI.

 

¿Debiera de proteger con except? ¿con Finally? ¿emplear doble try como se ejemplifica acá?

 

Yo ya estoy confundido.

 

Suelo tener cuidado con los constructores y destructores. Me he valido varias veces del uso de excepciones, pero el emplear el TFileStream y el querer poder tanto capturar posibles excepciones de éste, como de lanzar algunas propias para el contexto de mi clase TConverter y que en última las clases que usen a ésta sepan valerse me ha vuelto a las bases para replantear estas cuestiones.

 

Saludos,

[Delphius]

¿Alguna pista o sugerencia?

 

Saludos,

[Delphius]

Bueno, les comento. Ya tengo una nueva versión de mi algoritmo. Y las pruebas que ya estuve haciendo parecen ir de manera satisfactoria. Adjunto el código, que aprovecha el diseño de un doble try aninado. El interior, un try-finally, se encarga de toda la operatoria; el try-except del exterior captura posibles excepciones que lanza la clase TFileStream y lanza las apropiadas siguiendo la buena práctica del patrón "Convertir Excepciones".

delphi

procedure TArrayConverter.LoadMatrix(AMatrix: TAMatrix; FileName: string);
var idx, i, j, RowsM, ColsM, ErrM: integer;
    AFile: TFileStream;
    Can: Boolean;
    Fmt: TFileFormat;
    Header: TMatrixHeader;
begin
  Can := CheckMatrix(AMatrix, RowsM, ColsM, ErrM);
  try
    AFile := TFileStream.Create(FileName, fmOpenRead or fmShareDenyWrite);
    Try
      FIsBusy := true;
      // Leemos formato y Header
      Fmt.SizeFile := AFile.Seek(0, soEnd);
      AFile.Seek(0, soFromBeginning);
      AFile.ReadBuffer(Fmt.IDIni, SizeOf(Fmt.IDIni)); // ID.Ini
      AFile.ReadBuffer(Header, SizeOf(Header));       // Header
      AFile.Seek(INI_ID_END, soFromEnd);
      AFile.ReadBuffer(Fmt.IDEnd, SizeOf(Fmt.IDEnd)); // ID.End
 
      // Posibles excepciones de formato y Header
      if NOT IsValidFormat(Fmt, Header)
         then raise EInvalidFileArrayFormat.Create(Format(sInvalidFormat,['matrix']));
      if (Header.Cols <> ColsM) OR (Header.Rows <> RowsM)
         then raise EInconsistArray.Create(sInconsistency);
 
      AFile.Seek(INI_DATA_M, soFromBeginning);
      // Operamos
      if Header.Orientation = aoCol
         then begin
                for Idx := 1 to (Header.Rows * Header.Cols) do
                begin
                  i := (Idx - 1) mod Header.Rows;
                  j := (Idx - 1) div Header.Rows;
                  AFile.ReadBuffer(AMatrix[i, j], SizeOf(TYPEDATA));
                end
              end
         else begin
                for Idx := 1 to (Header.Rows * Header.Cols) do
                begin
                  i := (Idx - 1) div Header.Cols;
                  j := (Idx - 1) mod Header.Cols;
                  AFile.ReadBuffer(AMatrix[i, j], SizeOf(TYPEDATA));
                end;
              end;
    finally
      Afile.Free;
      fIsBusy := false;
    end; // end-try-finally
  except
    on E: EFOpenError do
    begin
      raise EFileAccessDenied.Create(Format(sAccessDenied, [FileName, E.Message]));
    end;
    on E: EReadError do
    begin
      raise EConvertFailed.Create(Format(sConvertFailed, ['read', FileName, E.Message]));
    end;
    // ¿Este except captura las excepciones lanzadas en el try interno y debiera relanzarlas?
  end; // end-try-except
end;

Además he optimizado el indexado y posicionamiento dentro de la matriz. Inicialmente tenía dos ciclos para moverse sobre la posición [i, j]. Ahora, lo tengo con un único ciclo. Gracias a la matemática es que es posible determinar que posición ocupa dentro de la matriz un índice de los datos. Ya sea que la lectura se haga columna a columna o bien fila a fila.

 

Un proceso análogo se ha llevado para el LoadVector, y algo similar para sus respectivos Save's.

 

Lo que estoy estudiando en implementar ahora es si será necesario (y de utilidad) hacer una especie de Import/Transform para volcar el contenido de una matriz a un archivo vectorial, y desde un vector a un archivo matricial.

Lo que si veo que podría servirme es que de una matriz pueda guardar sus vectores columnas/filas en distintos archivos. Es decir, en lugar de tener un único archivo matricial, generar N archivos vectoriales, una especie de Particionado.

 

Se siguen aceptado sugerencias.

 

Saludos,

[Delphius]

Y bueno, las pruebas fueron encaminadas. Y parece andar todo bien. Les comento que desde CD el compañero Al González y mamx me estaban dando una manito.

La propuesta final que me llegó Al es una variación a 3 trys del que tengo implementada (yo uso una a 2 try), que si bien parezca un tanto anidada podría ser más "exception-friendly".

Por el momento mi propuesta es suficiente.

 

Lo que si he detectado es que deberé ampliar las funcionalidades de la clase. No me había percatado que si necesitaré añadir funcionalidad para realizar lecturas en "trozos" (es decir en lugar de toda la matriz/vector) leer una parte de éste (como por ejemplo, un área de 3x3 de una matriz original de 5x4, y  no necesariamente sea desde el origen), y que incluso en ocasiones necesito leer solamente un conjunto de filas/columnas y para el caso de vectores ciertas posiciones.

Así que habrá que estudiar como dar forma a esto.

 

Saludos,