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, que haría uso:

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

O, si MySharedObject necesita más complicada de inicialización, en Java que pude crear una instancia e inicializar en un bloque inicializador estático.

(Es posible que haya adivinado ... Sé que mi Java, pero estoy bastante nuevo en Delphi ...)

De todos modos, no quiero crear una instancia de un nuevo MySharedObject cada vez que crear una instancia de MyObject, pero 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 manera de hacerlo? algo como esto en Delphi?

Answer 1

Aquí es cómo voy a hacer que el uso de una variable de clase, un procedimiento de la 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

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

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

Answer 3

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

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 implementation parte de su módulo.

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

Answer 4

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 clase será modificable desde cualquier instancia de clase, por lo tanto, se puede establecer en otro lugar en el código, por lo general sobre la base 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 podría 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 5

Las palabras clave que busca 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.). Por ejemplo

(Edit: volver a leer la pregunta y se trasladó recuento de referencia en TMyClass - ya que no puede ser capaz de modificar la clase TMySharedObjectClass que desee compartir, si se trata de otra persona de la biblioteca)

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 6

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

1. Hack#17: Virtual class variables, Part I
2. Hack#17: Virtual class variables, Part 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 7

Por lo que yo quiero hacer (una constante de clase privada), la solución más elegante que puedo llegar a (basado 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 habría algo 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 8

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

• La primera, 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í, puede aplicarse lo siguiente:
• ¿Las variables de clase tienen un alcance intrínseco o son realmente 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" de ninguna 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 se almacenan a nivel mundial, en lugar de una instancia por hilo. Ver this question para más detalles.

Answer 9

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; 

estoy Curently usarlo para construir objetos singletons.