Objeto global a la aplicación

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

[roman]

Siempre me ha llamado la atención el uso de este patrón. En cierta forma, creo yo, un singleton debe ser tan claro su uso que no pueda prestarse a confusión acerca de si se deben o no crear más instancias. Por ejemplo, el objeto Application en cualquier aplicación VCL de Delphi es un singleton, y aunque sería posible crear otro objeto de la clase TApplication, no conozco a nadie que lo haga, ni siquiera por error.

En todo caso, les doy mi versión del mismo patrón:

Código Delphi [-]
unit Singl;

interface

uses
  SysUtils;

type
  TSingleton = class
  private
    FAuthor: String;
    constructor CreateInstance;

  public
    property Author: String read FAuthor write FAuthor;

    constructor Create;
    class function GetInstance: TSingleton;
  end;

implementation

var
  Instance: TSingleton;

{ TSingleton }

constructor TSingleton.Create;
begin
  raise Exception.Create('Cannot instantiate this');
end;

constructor TSingleton.CreateInstance;
begin
end;

class function TSingleton.GetInstance: TSingleton;
begin
  Result := Instance;
end;

initialization
  Instance := TSingleton.CreateInstance;

finalization
  Instance.Free;
end.

Aquí, la clase TSingleton declara el constructor Create pero lo invalida lanzando una excepción. Con esto se evitaría que alguien intente crear un objeto de esta clase. El invalidar el constructor serviría para quitar la sensación de que pueden crearse más de una instancia, tal como pensó noob.

Ahora bien, debe haber un objeto de la clase, y éste se crea usando el constructor privado (que basta declarar, no hay nada necesario que implementar).

Para acceder a dicho objeto único se usa el método de clase GetInstance.

Claro que aquí queda el problema que menciona Delphius acerca de que alguien libere el objeto antes de tiempo.

Entonces les presento mi versión 2 del singleton, esta vez, uando interfaces:

Código Delphi [-]
unit Singl2;

interface

type
  ISingleton = interface
    function GetAuthor: String;
    procedure SetAuthor(Value: String);
    property Author: String read GetAuthor write SetAuthor;
  end;

function GetInstance: ISingleton;

implementation

var
  Instance: ISingleton;

type
  TSingleton = class(TInterfacedObject, ISingleton)
  private
    FAuthor: String;

  public
    { ISingleton }
    function GetAuthor: String;
    procedure SetAuthor(Value: String);
  end;

{ TSingleton }

function TSingleton.GetAuthor: String;
begin
  Result := FAuthor;
end;

procedure TSingleton.SetAuthor(Value: String);
begin
  FAuthor := Value;
end;

function GetInstance: ISingleton;
begin
  Result := Instance;
end;

initialization
  Instance := TSingleton.Create;
end.

En este caso, no hay ningún objeto al que pueda accederse directamente, vamos, ni siquiera la clase está visible al público, así que no podemos ni crear instancias ni destruirlas.

El singleton se accede a partir de la función GetInstance. Dado que la clase que implementa la interfaz desciende de TInterfacedObject, la destrucción del objeto se hará automáticamente cuando se pierda la última referencia. Así, podemos tener cuantas referencias queramos al singleton, sin preocuparnos por su tiempo de vida.

Bueno, esto no es para invalidar las otras opciones sino sólo para ofrecer un par de alternativas que pueden funcionar en algunas circunstancias.

// Saludos

[[Al González]]

¡Hola!

Bueno, continuando con la singletonmanía , ahí les va mi propuesta:

Código Delphi [-]
Unit UUnico;

Interface

  Type
    TUnico = Class
      Class Function NewInstance :TObject; Override;
      Procedure FreeInstance; Override;
    End;

  Function Unico :TUnico;  // Función global para acceder a la instancia

Implementation

  Uses
    SysUtils;

  Var
    Instancia :TUnico;  // Variable privada que apuntará a la instancia
    Bloqueado :Boolean;  // Bandera de control

  Class Function TUnico.NewInstance :TObject;
  Begin
    If Bloqueado Then
      Raise Exception.Create ('Intento de crear nuevamente objeto Unico.');

    Result := Inherited NewInstance;
  End;

  Procedure TUnico.FreeInstance;
  Begin
    If Bloqueado Then
      Raise Exception.Create (
        'Intento de destruir prematuramente objeto Unico.');

    Inherited FreeInstance;
  End;

  Function Unico :TUnico;
  Begin
    // a) Creamos la instancia cuando sea requerida por primera vez o...
    If Instancia = Nil Then
    Begin
      Instancia := TUnico.Create;
      Bloqueado := True;
    End;

    Result := Instancia;
  End;

Initialization
  // ...b) Creamos la instancia desde que inicie el programa
  Instancia := TUnico.Create;
  Bloqueado := True;

  // NOTA: Utilice la opción "a" o la opción "b", pero no ambas.

Finalization
  // Destruimos la instancia hasta que finalice el programa
  Bloqueado := False;
  Instancia.Free;

End.

Código Delphi [-]
Uses
  UUnico;

procedure TForm1.Button1Click(Sender: TObject);
Var
  U :TUnico;
begin
  ShowMessage (Unico.ClassName);

  // Imposible
  U := TUnico.Create;

  // Imposible
  Unico.Free;

  // Imposible
  U := Unico;
  U.Destroy;
end;

El problema que veo en el esquema sugerido por Marcelo es que permite nuevas sentencias de instanciación (TSingleton.Create), que darían lugar a re-ejecutar el código del constructor, a pesar de que no se crea una instancia nueva. Si el objeto ya existe, creo que no tendría por qué ser ejecutado el código de su constructor cada vez que alguna parte del programa vaya a usar ese objeto.

La solución con interfaz de Román es efectiva porque consigue que no pueda ser construido el objeto por segunda vez ni destruido prematuramente. El esquema que propuse ahora no es más que otra manera de lograr eso mismo.

Saludos.

Al González.

[[Delphius]]

¡Hola!

Vuelvo de una rica cena y me encuentro con esto de postre.

Debo decir que ambos postres son deliciosos.
En efecto, sus soluciones son más convenientes. Nomás yo me he limitado a dar lo "básico", en cierto modo, de como se puede enfocar el problema.

Mientras estaba realizando un estudio y análisis (hace ya unos meses) del patrón me dí cuenta de los problemas que implica el esquema que yo había estudiado. Por ello empecé a practicar diferentes enfoques y me dí cuenta de que hay muchas formas, algunas más "ingeniosas" que otras.

Llegué a opciones similares como la que han descrito, y una de las que más me convence a mi es tener una función GetSingleton o GetInstance como la de roman para acceder a un único objeto.

Mis prácticas me llevaron por interfaces, que es una opción bastante elegante y que no requiere de mucho lío y código ya que como bien señala roman, gracias al conteo de referencia es que se consigue liberar todo automáticamente. Y también practiqué llevandolo hacia herencia, es decir algo como:

Código Delphi [-]
Type
  TAbstractSingleton = class
   ...
   end;

  TConcreteSingleton = class(TAbstractaSingleton)
  ...
  end;

Detuve mis avances cuando quise meterme en un esquema thread-safe debido a que no domino el tema de los hilos, el uso de secciones críticas, mútex y cosas por el estilo. Encontré algunos artículos que mencionaban algo al respecto pero no termino de comprender el tema.
Si alguien se anima a enriquecer el hilo con una versión tread-safe les estaría agradecido (y también noob).

Saludos,

[noob]

Empezado por 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.

Pensé que se creaba más de una instancia, no cai en eso.

Muchas gracias a todos por dar estas ricas versiones del patrón Singleton.

Me gusta la opción de acceder al objeto global mediante la función GetInstance y no tener que llamar al método constructor.

Empezado por roman

debe haber un objeto de la clase, y éste se crea usando el constructor privado (que basta declarar, no hay nada necesario que implementar).

Dos dudas roman:

1) Cuando en la sección de inicialización de tu unidad Singl haces: Instance := TSingleton.CreateInstance; ¿se crea realmente una instacia? Lo digo porque el método constructor CreateInstance no está implementado.

2) ¿Los métodos GetAuthor y SetAuthor del interfaz ISingleton no deberían de ser virtuales y abstractos para luego ser redefinidos en TSingleton?

Saludos.

[roman]

Empezado por noob

1) Cuando en la sección de inicialización de tu unidad Singl haces: Instance := TSingleton.CreateInstance; ¿se crea realmente una instacia? Lo digo porque el método constructor CreateInstance no está implementado.

De hecho, TObject.Create está también implementado como un método vacío:

Código Delphi [-]
constructor TObject.Create;
begin
end;

No importa qué constructor uses, el mero hecho de serlo hace que el compilador inserte entre el begin y la primera instrucción (si la hay) una llamada a la función _ClassCreate que es la encargada de construir la base del objeto (mediante el método NewInstance).

En otras palabras, el efecto de Create y de CreateInstance es exactamente el mismo: ambos tienen implementación vacía, pero por estar etiquetados como constructores generan la llamada a _ClassCreate.

El único objetivo de introducir CreateInstance es el de invalidar el constructor público para que no pueda usarse externamente.

Empezado por noob

2) ¿Los métodos GetAuthor y SetAuthor del interfaz ISingleton no deberían de ser virtuales y abstractos para luego ser redefinidos en TSingleton?

En una interfaz el uso de la directivas virtual y abstract sería redundante, porque, de hecho, todos los métodos de una interfaz son virtuales y abstractos por naturaleza. Virtuales porque su implementación dependerá precisamente de la clase que implemente la interfaz y abstractos porque una interfaz no implementa nada por sí sola.

// Saludos

[noob]

En una interfaz el uso de la directivas virtual y abstract sería redundante, porque, de hecho, todos los métodos de una interfaz son virtuales y abstractos por naturaleza. Virtuales porque su implementación dependerá precisamente de la clase que implemente la interfaz y abstractos porque una interfaz no implementa nada por sí sola.

Pensé que era necesario indicarlo.

Roman más dudas:

1) Siempre me gusta separar cada clase en una unidad distinta, en el caso de la unidad Singl2 ¿lo has hecho en una sola unidad a propósito o lo has hecho así por tenerlo todo más visible a la hora de verlo en el foro?

2) ¿No puedo acceder al método Author por medio de una propiedad tal que así?

Código Delphi [-]
property PropAuthor: String read GetAuthor
                            write SetAuthor;

3) Otra cosa, para usar la instancia desde fuera del interfaz, sería así, ¿verdad?

Código Delphi [-]
ShowMessage(Singl2.GetInstance.GetAuthor);

Siento preguntar cosas que tal vez sean muy básicas.

Gracias.

[Kipow]

Interesante el tema, me tomo la libertad de contestarte tus ultimas preguntas noob.

1. Singl2 es la version 2 del ejemplo que roman coloco.
2 y 3. La forma de acceder al singleton seria en todo caso asi

Código Delphi [-]
uses 
   Singl2;

begin
     ShowMessage(GetInstance.Author);   
end

.

ya que GetInstance es una funcion que te retorna la clase. talvez un nombre mas practico podria ser

Código Delphi [-]
function Singleton : TSingleton

Que fue como Al Gonzalez lo recomendo en su propia version.

Saludos.

[Neftali [Germán.Estévez]]

Empezado por kikin

mira la guia de estilo

¿Y a qué viene eso?
Que conste que no estoy en contra de revisarla de vez en cuando¡, pero tanta insistencia... 1 y 2

Perece que se te quedó el teclado "atascado"...