reynosa - delphi technologies mexico

Constantes de clase/estáticas en Delphi

Question

En Delphi, quiero poder crear un objeto privado asociado a una clase y acceder desde todas las instancias de esa clase. En Java, usaría:

public class MyObject {
    private static final MySharedObject mySharedObjectInstance = new MySharedObject();
}

O, si MySharedObject necesitaba una inicialización más complicada, en Java podría instanciarla e inicializarla en un bloque de inicializador estático.

(Tal vez hayas adivinado ... Conozco mi Java pero soy bastante nuevo para Delphi ...)

De todos modos, no quiero instanciar un nuevo MySharedObject cada vez que creo una instancia de MyObject, pero sí quiero que se pueda acceder a MySharedObject desde cada instancia de MyObject. (En realidad, el registro me ha impulsado a tratar de resolver esto; estoy usando Log4D y quiero almacenar un TLogLogger como una variable de clase para cada clase que tenga funcionalidad de registro).

¿Cuál es la mejor forma de hacer algo como esto en Delphi?

Answer 1

Aquí es cómo lo haré usando una variable de clase, un procedimiento de clase y un bloque de inicialización:

unit MyObject;

interface

type

TMyObject = class
   private
     class var FLogger : TLogLogger;
   public
     class procedure SetLogger(value:TLogLogger);
     class procedure FreeLogger;
   end;

implementation

class procedure TMyObject.SetLogger(value:TLogLogger);
begin
  // sanity checks here
  FLogger := Value;
end;

class procedure TMyObject.FreeLogger;
begin
  if assigned(FLogger) then 
    FLogger.Free;
end;

initialization
  TMyObject.SetLogger(TLogLogger.Create);
finalization
  TMyObject.FreeLogger;
end.

Answer 2

El año pasado, Hallvard Vassbotn blogueó sobre un Delphi-hack que había hecho para esto, se convirtió en un artículo de dos partes:

1. Hack # 17: Variables de clases virtuales, Parte I
2. Hack # 17: Variables de clase virtual, Parte II

Sí, es una lectura larga, pero muy gratificante.

En resumen, he reutilizado la entrada VMT (en desuso) llamada vmtAutoTable como variable. Esta ranura en el VMT se puede usar para almacenar cualquier valor de 4 bytes, pero si desea almacenar, siempre puede asignar un registro con todos los campos que desee.

Answer 3

En Delphi, las variables estáticas se implementan como constantes de tipos variables :)

Esto podría ser algo engañoso.

procedure TForm1.Button1Click(Sender: TObject) ;
const
   clicks : Integer = 1; //not a true constant
begin
  Form1.Caption := IntToStr(clicks) ;
  clicks := clicks + 1;
end;

Y sí, otra posibilidad es usar la variable global en la parte de implementation de su módulo.

Esto solo funciona si el conmutador del compilador "Consts asignables" está activado, globalmente o con sintaxis de {$J+} (tnx Lars).

Answer 4

Las palabras clave que está buscando son "clase var": esto inicia un bloque de variables de clase en su declaración de clase. Debe finalizar el bloque con "var" si desea incluir otros campos después de él (de lo contrario, el bloque puede terminar con un especificador "privado", "público", "procedimiento", etc.). P.ej

(Editar: volví a leer la pregunta y moví el recuento de referencias a TMyClass, ya que es posible que no puedas editar la clase TMySharedObjectClass que deseas compartir, si proviene de la biblioteca de otra persona)

  TMyClass = class(TObject)
  strict private
    class var
      FMySharedObjectRefCount: integer;
      FMySharedObject: TMySharedObjectClass;
    var
    FOtherNonClassField1: integer;
    function GetMySharedObject: TMySharedObjectClass;
  public
    constructor Create;
    destructor Destroy; override;
    property MySharedObject: TMySharedObjectClass read GetMySharedObject;
  end;


{ TMyClass }
constructor TMyClass.Create;
begin
  if not Assigned(FMySharedObject) then
    FMySharedObject := TMySharedObjectClass.Create;
  Inc(FMySharedObjectRefCount);
end;

destructor TMyClass.Destroy;
begin
  Dec(FMySharedObjectRefCount);
  if (FMySharedObjectRefCount < 1) then
    FreeAndNil(FMySharedObject);

  inherited;
end;

function TMyClass.GetMySharedObject: TMySharedObjectClass;
begin
  Result := FMySharedObject;
end;

Tenga en cuenta que lo anterior no es seguro para subprocesos, y puede haber mejores formas de contar referencias (como el uso de interfaces), pero este es un ejemplo simple que debe comenzar. Tenga en cuenta que TMySharedObjectClass puede ser reemplazado por TLogLogger o lo que quiera.

Answer 5

Por lo que quiero hacer (una constante de clase privada), la mejor solución que puedo encontrar (basada en las respuestas hasta ahora) es:

unit MyObject;

interface

type

TMyObject = class
private
  class var FLogger: TLogLogger;
end;

implementation

initialization
  TMyObject.FLogger:= TLogLogger.GetLogger(TMyObject);
finalization
  // You''d typically want to free the class objects in the finalization block, but
  // TLogLoggers are actually managed by Log4D.

end.

Tal vez un poco más orientado a objetos sería algo así como:

unit MyObject;

interface

type

TMyObject = class
strict private
  class var FLogger: TLogLogger;
private
  class procedure InitClass;
  class procedure FreeClass;
end;

implementation

class procedure TMyObject.InitClass;
begin
  FLogger:= TLogLogger.GetLogger(TMyObject);
end;

class procedure TMyObject.FreeClass;
begin
  // Nothing to do here for a TLogLogger - it''s freed by Log4D.
end;

initialization
  TMyObject.InitClass;
finalization
  TMyObject.FreeClass;

end.

Eso podría tener más sentido si hubiera múltiples constantes de clase.

Answer 6

 TMyObject = class
    private
      class var FLogger : TLogLogger;
      procedure SetLogger(value:TLogLogger);
      property Logger : TLogLogger read FLogger write SetLogger;
    end;

procedure TMyObject.SetLogger(value:TLogLogger);
begin
  // sanity checks here
  FLogger := Value;
end;

Tenga en cuenta que esta variable de clase se podrá escribir desde cualquier instancia de clase, por lo tanto, puede configurarla en otro lugar del código, generalmente en función de alguna condición (tipo de registrador, etc.).

Editar: También será el mismo en todos los descendientes de la clase. Cámbielo en uno de los elementos secundarios y cambie para todas las instancias descendientes. También puede configurar el manejo de instancias predeterminado.

 TMyObject = class
    private
      class var FLogger : TLogLogger;
      procedure SetLogger(value:TLogLogger);
      function GetLogger:TLogLogger;
      property Logger : TLogLogger read GetLogger write SetLogger;
    end;

function TMyObject.GetLogger:TLogLogger;
begin
  if not Assigned(FLogger)
   then FLogger := TSomeLogLoggerClass.Create;
  Result := FLogger;
end;

procedure TMyObject.SetLogger(value:TLogLogger);
begin
  // sanity checks here
  FLogger := Value;
end;

Answer 7

Antes de la versión 7, Delphi no tenía variables estáticas, tendrías que usar una variable global.

Para que sea lo más privado posible, colóquelo en la sección de implementation de su unidad.

Answer 8

Bueno, no es belleza, pero funciona bien en Delphi 7:

TMyObject = class
pulic
    class function MySharedObject: TMySharedObject; // I''m lazy so it will be read only
end;

implementation

...

class function MySharedObject: TMySharedObject;
{$J+} const MySharedObjectInstance: TMySharedObject = nil; {$J-} // {$J+} Makes the consts writable
begin
    // any conditional initialization ...
   if (not Assigned(MySharedObjectInstance)) then
       MySharedObjectInstance = TMySharedOject.Create(...);
  Result := MySharedObjectInstance;
end;

Lo estoy utilizando para construir objetos únicos.

Answer 9

Dos preguntas que creo que deben ser respondidas antes de llegar a una solución "perfecta".

• El primero es si TLogLogger es seguro para subprocesos. ¿Se puede llamar al mismo TLogLogger desde múltiples hilos sin llamadas a "syncronize"? Incluso si es así, lo siguiente puede aplicarse
• ¿Las variables de clase son intrínsecas o verdaderamente globales?
• Si las variables de clase son verdaderamente globales, y TLogLogger no es seguro para subprocesos, puede que sea mejor usar un threadvar unit-global para almacenar el TLogLogger (tanto como no me gusta usar vars "globales" en cualquier forma), por ejemplo

Código:

interface
type
  TMyObject = class(TObject)
  private
    FLogger: TLogLogger; //NB: pointer to shared threadvar
  public
    constructor Create;
  end;
implementation
threadvar threadGlobalLogger: TLogLogger = nil;
constructor TMyObject.Create;
begin
  if not Assigned(threadGlobalLogger) then
    threadGlobalLogger := TLogLogger.GetLogger(TMyObject); //NB: No need to reference count or explicitly free, as it''s freed by Log4D
  FLogger := threadGlobalLogger;
end;

Editar: parece que las variables de clase están almacenadas globalmente, en lugar de una instancia por subproceso. Vea esta pregunta para más detalles.