Objeto global a la aplicación

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