Objeto global a la aplicación

[[Al González]]

Empezado por noob

Perdona mi ignorancia pero, ¿cómo puedo adaptarlo a mi programa?

Supongamos que tengo un formulario y dos clases: Form1, cClase2, cClase3...

Parece que sólo te faltaría agregar las secciones de inicialización y finalización en la unidad Unit3, que sería como la unidad Menus.pas del ejemplo que te di.

[noob]

Lo tengo y funciona, muchas gracias.

Form1:

Código Delphi [-]
unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Unit2;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    Button2: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
    Clase2: cClase2;
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  Clase2 := cClase2.Create;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Clase2.anadir(Edit1.Text);
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  Clase2.mostrar;
end;

end.

Unit2:

Código Delphi [-]
unit Unit2;

interface

type
  cClase2 = class
              private
              public
                procedure anadir(Mensaje: string);
                procedure mostrar;
            end;

implementation

uses Unit3, Dialogs;

procedure cClase2.anadir(Mensaje: string);
begin
  with Clase3 do
    Contenido := Contenido + Mensaje;
end;

procedure cClase2.mostrar;
begin
  ShowMessage(Clase3.Contenido);
end;

end.

Unit3:

Código Delphi [-]
unit Unit3;

interface

type
  cClase3 = class
              private
              public
                Contenido: string;
            end;

var
  Clase3: cClase3;

implementation

initialization

  Clase3 := cClase3.Create;

finalization

  Clase3.Free;

end.

[[Al González]]

Empezado por noob

Lo tengo y funciona, muchas gracias.

De nada Noob, gracias a ti por hacer buenas preguntas. Así es como los foros de Club Delphi se han convertido en un deslumbrante acervo de información técnica.

Por cierto, te recomiendo usar Free en lugar de Destroy, por las razones que se explican en varios hilos que hablan de ello.

Un saludo.

Al.

[noob]

A veces pienso que mis preguntas son un tanto rebuscadas.

Empezado por Al González

Por cierto, te recomiendo usar Free en lugar de Destroy, por las razones que se explican en varios hilos que hablan de ello.

Edito y tomo nota.

[[Delphius]]

Formalmente lo que buscas es un Singleton. Y la forma en llevarlo a cabo es redefiniendo el método de clase NewInstance y el método FreeInstance.

Luego, debes tener una variable que se puede o no, mantener "oculta" que sea del tipo de la clase definida. ¿Para qué? Para que la implementación de NewInstance pueda chequear si existe una instancia de dicha clase, si existe se devuelve dicha instancia, en otro caso se crea.
FreeInstance liberará la instancia.

Más o menos la idea es algo como esto:

Código Delphi [-]
type
TSingleton = class //nuestra clase que será global
  public
    class function NewInstance: TObject; override;
    procedure FreeInstance; override;
end;

implementation

var Instancia: TSingleton; //Nota como esta variable se mantiene "oculta"

class function TSingleton.NewInstance: TObject;
begin
  if (NOT Assigned(Instancia))
     then begin
            Instancia := TSingleton (inherited NewInstance);
            // algo más que deba hacer....
          end;
  result := Instancia;
end;

procedure TSingleton.FreeInstance;
begin
  Instancia := nil;
  inherithed FreeInstance;
end;

Ahora si deseas puedes hacer que se cree y se libere dicha instancia en sus secciones Initialization y Finalization.

Luego puedes tener cuantas variables donde necesites, cuando hagas algo como:

Código Delphi [-]
Variable := TSingleton.Create;

Variable apuntará a "Instancia". Luego si haces,

Código Delphi [-]
Variable.Free;

Liberas al objeto global, es decir a "Instancia".

Se puede modificar un poco el código para no liberar de una, y llevar un contador de las veces que se referencie: NewInstance incrementa el contador, mientras que FreeInstance lo decrementa.

Nomás te cuento esto como alternativa. Hay muchas maneras de implementar un singleton.

La forma que comentó Al es una de ellas. Pero funcionará siempre y cuando usemos la variable que se declara en Interface. Si uno tiene otra variable de la misma clase, puede correr el riesgo de crearla y liberarla, por tanto habrá dos instancias y se rompe el esquema de la variable global (y única).
Ojo, que con el esquema que menciona Al, no hay que liberarla nunca sino dejar que el sistema al finalizar solito se encargue de ello.

Saludos,

[noob]

@Delphius he estado usando el esquema de Al pero voy a usar lo que me has recomendado por el tema de no crear más que una instancia.

Cuatro cosas:

1) ¿TSigleton ha de ser mi clase cClase3?

2) He visto que redefines los métodos NewInstance y FreeInstance pero la clase TSingleton no hereda de ninguna otra, ¿qué se redefine entonces?

3) ¿Variable := TSingleton.Create; y Variable.Free; lo he poner en las secciones de inicialización y finalización de mi clase singleton?

4) ¿Quedaría así?

Código Delphi [-]
unit Unit3;

interface

type
  cClase3 = class
              private
                Contenido: String;
                function ObtenerContenido: String;
                procedure EstablecerContenido(Contenido: String);
              public
                class function NewInstance: TObject; override;
                procedure FreeInstance; override;
                property PropContenido: String read ObtenerContenido
                                               write EstablecerContenido;  
            end;

implementation

var Clase3: cClase3; //Nota como esta variable se mantiene "oculta"

function cClase3.ObtenerContenido: String;
begin
  Result := Contenido;
end;

procedure cClase3.EstablecerContenido(Contenido: String);
begin
  Self.Contenido := Contenido;
end;

class function cClase3.NewInstance: TObject;
begin
  if (NOT Assigned(Clase3))
     then begin
            Clase3 := cClase3 (inherited NewInstance);
            // algo más que deba hacer....
          end;
  result := Clase3;
end;

procedure cClase3.FreeInstance;
begin
  Clase3 := nil;
  inherithed FreeInstance;
end;

initialization

  Clase3 := cClase3.Create;

finalization

  Clase3.Free;

end.

Saludos.

[[Delphius]]

Empezado por noob

@Delphius he estado usando el esquema de Al pero voy a usar lo que me has recomendado por el tema de no crear más que una instancia.

Cuatro cosas:

1) ¿TSigleton ha de ser mi clase cClase3?

Será la clase que deba ser... en tu caso es cClase3.
Por otro lado, sería oportuno que siguieras la nomenclatura que sigue Delphi: Anteponer T (que hace alusión a que se trata de un tipo) al nombre.
Si bien no estás cometiendo un delito y es a elección propia el seguir una nomenclatura, es recomendable mantener un código homogéneo.

Empezado por noob

2) He visto que redefines los métodos NewInstance y FreeInstance pero la clase TSingleton no hereda de ninguna otra, ¿qué se redefine entonces?

Toda clase desciende, directa o indirectamente, de la clase base TObject.
NewInstance y FreeInstance son dos métodos virtuales declarados en TObject.
En este caso TSingleton desciende de TObject (si uno no define la clase en class el compilador asume y entiende que se desciende de TObject).

Empezado por noob

3) ¿Variable := TSingleton.Create; y Variable.Free; lo he poner en las secciones de inicialización y finalización de mi clase singleton?

En donde gustes. Pero si leyeras con atención, "Variable" es una variable declarada fuera... es decir que no pertenece a la unidad en donde se declara el singleton. Es la variable que se usa para acceder al singleton.

En mi código claramente se ve que existe una variable "Instancia" que mantiene referencia al singleton. Esta variable no puede ser leída desde afuera. Luego, para hacer uso del singleton es que uno hace uso de "Variable" y de forma indirecta "Variable" apunta hacia "Instancia".

En tu caso, reemplazaste "Instancia" por "clase3".

Ahora yo te pregunto... ¿Y como usas al singleton?
¿Ves para que existe "Variable"?

Variable no debería (o tal vez... habría que ver) inicializarse en initialization, y liberarse en Finalization.
Variable "se crea" en donde se necesita emplear al singleton, y el tiempo de vida de "Variable" se ajustará a las necesidades. Recuerda que si haces Free de "Variable" estás liberando al objeto global Por ello indico que existen diferentes formas de como llevarlo.

Una forma típica es tener un contador de instancias. De ese modo en cada "Create" de "Variable" se incrementa, y en cada "Free" se decrementa. Al llegar a cero, se libera el objeto global. De este modo evitamos que cualquier Free que tengamos por allí libere al singleton.

Empezado por noob

4) ¿Quedaría así?

Si, así podría quedar.
Recuerda que necesitarás tener una "Variable" afuera, si no la publicas.

Una variación de mi TSingleton puede ser hacer público a "Instancia", de este modo nos evitamos tener "Variables". Pero en caso de hacerla pública, debe recordarse de que en ningún momento liberarla ya que el trabajo se hará al finalizar el sistema.

Espero que con esto se entienda la idea.
Por si no se entiende, lee éste artículo.

Es más, como muestra de que hay diferentes enfoques de como llevar un singleton (cada uno tiene sus pros y contras y deben analizarse cual es conveniente en cada caso) se puede concebir un modelo mixto entre el ejemplo de Al y el "mío" (Digo mío entre comillas porque he seguido (y sigo) el artículo):

Declarar el singleton en una unidad, y tener otra unidad, global, con "Variable" de forma global. Pero claro... este enfoque puede resultar un poco... inpráctico puesto que se está elevando el acoplamiento. Ahora bien, si en dicha unidad... por denominarla de un modo... UGlobal se emplea para acoplar otros objetos que también merezcan un carácter global si es recomendable.
De este modo se independiza (y se permite cierta reutilización) un poco las declaraciones de posibles objetos Singleton de las variables singleton.

Bueno, creo que esto ya complementa desde diferentes ángulos el tema, y me hizo reanalizar este penúltimo párrafo (no había visto hasta el momento ésa opción). Creo que añadiré esta observación y punto de vista en mi hoja de observaciones de éste patrón. Te agradezco noob por hacerme descubrir que este patrón da para más de lo que creía.

Saludos,