Objeto global a la aplicación

[[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,

[noob]

Pienso que mi singleton no funciona porque puedo declarar más de una variable de mi clase singleton:

Unit1:

Código Delphi [-]
unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
    Clase2: TClase2;
    Clase2b: TClase2;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  Clase2 := TClase2.Create;
  Clase2b := TClase2.Create; // No debería dejarme crear esta instancia porque se supone que es un singleton
end;

end.

Unit2:

Código Delphi [-]
unit Unit2;

interface

type
  TClase2 = 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 Clase2: TClase2; //Nota como esta variable se mantiene "oculta"

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

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

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

procedure TClase2.FreeInstance;
begin
  Clase2 := nil;
  inherited FreeInstance;
end;

end.

[[Delphius]]

Hola noob, está bien. La cuestión es que puedes tener tantas variables como necesites. Pero si te fijas, todas "apuntan" a un mismo objeto. Por tanto, se trata de una única instancia que es referenciada desde diversos puntos.

La alternativa de Al evita estar definiendo variables, y trabajar con una única... la que se declara como pública en dicha unidad. Pero si la declaración de la clase es de acceso público (interface), nada impide declarar una nueva variable y crearla. Rompiendo así el principio de una única instancia (a menos claro que dicha clase redefina los métodos tal como los he señalado en mi ejemplo).

Obviamente, el peligro de tener muchas variables es el manejo de ciclo de vida. Si alguna de esas variables se libera, se libera el singleton. Pero lo bueno de ésto es que si uno aprovecha sabiamente el método de clase NewInstance y el método FreeInstance puede hacer que se ante un posible Free, no se libere el único objeto que existe.

Para entender apropiadamente como funciona el patrón añade muchas variables, y algunos breackpoint en el momento del Create... si vas siguiendo con F7 notarás que en el primer Create (si es que no se hace uso de un Create, en initialization) se crea la única instancia. En los sucesivos Create, lo que se hace es apuntar a dicha instancia. Esto es así debido a la simple condición:

Código Delphi [-]
if Assigned(Instancia) then ... result := Instancia

Lee el artículo que te he hecho llegar. Eso te permitirá comprender mejor el patrón.

No es por ser molesto, pero copiar por copiar no sirve. Hay que leer un poquito.

Saludos,