Clase Serializable

[luismolina]

Hola Amigos soy nuevo en esto del OOP en delphi y tengo experiencia en java, y me gustaria saber como puedo crear una clase en delphi, y luego guardarla en un archivo.

Public class Ecuaciones implements Serializable {
  /**
   * Ecuaciones
   */
  public Ecuaciones() {
  }

  private String nombre;
  private String apellido;

  public void setNombre(String nombre) {
    this.nombre = nombre;
  }

  public void setApellido(String apellido) {
    this.apellido = apellido;
  }

  public String getNombre() {
    return this.nombre;
  }

  public String getApellido() {
    return this.apellido;
  }

Quisiera saber como puedo hacer esto en delphi, y como podria guardar esta clase en un archivo para luego recuperarla, muchas gracias.

[waltergomez]

Podes usar TFileStream.WriteComponent y TFileStream.ReadComponent .
El formato es propietario si queres serializar en XML hay por la red algunas libreria libres.

Saludos,

[luismolina]

Gracias por la respuesta walter, pero lo que yo quiero es saber como puedo hacer la clase que escribi anteriormente en delphi, y como guardarla en un archivo. y me gustaria saber como utilizar esto con lo que tu me escribiste.

[waltergomez]

Tu clase debe derivar de TComponent.

Para grabar el component en un archivo;

Código Delphi [-]
procedure TForm1.SaveComponentToFile(sFilename: string);
var
  FS: TFileStream;
begin
  FS := nil;
  try
    FS := TFileStream.Create(sFileName, fmCreate);
    FS.WriteComponent(TuComponente);
  finally
    FS.Free;
  end;
end;

Y para leer desde el archivo,

Código Delphi [-]
procedure TForm1.ReadComponentFromFile(sFilename: string);
var
  FS: TFileStream;
begin
  FS := nil;
  try
    FS := TFileStream.Create( sFileName, fmOpenRead );
    FS.ReadComponent(TuComponente);
  finally
    FS.Free;
  end;
end;

Pero primero deberias pasar esa clase java a delphi.

Espero te sirva,

[dec]

Hola,

Una traducción del código que copiaste, pensando en derivar la clase de "TComponent" para hacer uso de lo que dice el compañero Walter, podría ser como sigue en Delphi:

Código Delphi [-]
unit UEcuaciones;

interface

uses
  Classes;

type
  TEcuaciones = class(TComponent)
  private
    FNombre, FApellido: string;
  public
    constructor Create(AOwner: TComponent); override;
    function GetNombre : string;
    function GetApellido : string;
    procedure SetNombre(nombre: string);
    procedure SetApellido(apellido: string);
  end;

implementation

{ TEcuaciones }

constructor TEcuaciones.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  { TODO }
end;

function TEcuaciones.GetNombre: string;
begin
  Result := Self.FNombre;
end;

function TEcuaciones.GetApellido: string;
begin
  Result := Self.FApellido;
end;

procedure TEcuaciones.SetNombre(nombre: string);
begin
  if (Self.FNombre <> nombre) then
    Self.FNombre := nombre;
end;

procedure TEcuaciones.SetApellido(apellido: string);
begin
  if (Self.FApellido <> apellido) then
    Self.FApellido := apellido;
end;

end.

Sin embargo, fíjate que los métodos "Gets" y "Sets" no hacen sino asignar un nuevo valor a las variables que nos interesan, por un lado, y por otro devolver el valor de dichas variables. Entonces podríamos simplicar un poco el código en Delphi, gracias a las "propiedades":

Código Delphi [-]
unit UEcuaciones2;

interface

uses
  Classes;

type
  TEcuaciones = class(TComponent)
  private
    FNombre, FApellido: string;
  public
    constructor Create(AOwner: TComponent); override;
    property Nombre: string read FNombre write FNombre;
    property Apellido: string read FApellido write FApellido;
  end;

implementation

{ TEcuaciones }

constructor TEcuaciones.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  { TODO }
end;

end.

[roman]

Sólo un comentario:

Para que el código de walter funcione con la clase de dec, la propiedades deben declararse como published en lugar de public.

// Saludos

[dec]

Hola,

Ea, pues ya sabemos otra cosa nueva. Gracias Román.

[waltergomez]

Si queres profundizar y tomarte algunas aspirinas podes serializar una clase que no derive de TComponent.
Delphi al igual que Java tiene funciones que te permiten acceder a las propiedades y metodos tanto public como published de otras clases.
En la unidad TypInfo.pas hay muchas funciones realizar esto.

Este ejercicio te permitira obtener conocimiento para despues crear Wizards o Expertos.

Aqui tenes buenos expertos http://www.gexperts.org/

Saludos,