16

在 Delphi 中，我希望能够创建一个与类关联的私有对象，并从该类的所有实例中访问它。在Java中，我会使用：

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

或者，如果 MySharedObject 需要更复杂的初始化，我可以在 Java 中实例化并在静态初始化块中初始化它。

（你可能已经猜到了……我知道我的 Java，但我对 Delphi 还很陌生……）

无论如何，我不想在每次创建 MyObject 实例时都实例化一个新的 MySharedObject，但我确实希望从 MyObject 的每个实例都可以访问一个 MySharedObject。（实际上是日志记录促使我尝试解决这个问题 - 我正在使用 Log4D，并且我想将 TLogLogger 作为每个具有日志记录功能的类的类变量存储。）

在 Delphi 中做这样的事情的最简洁的方法是什么？

4

9 回答 9

18

下面是我使用类变量、类过程和初始化块的方法：

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.
于 2008-09-16T13:14:43.997 回答
5

去年，Hallvard Vassbotn 写了一篇关于我为此制作的 Delphi hack 的博客，它分为两部分：

  1. 技巧 #17：虚拟类变量，第一部分
  2. 技巧 #17：虚拟类变量，第二部分

是的，读起来很长，但很有收获。

总之，我重用了（已弃用）名为 vmtAutoTable 的 VMT 条目作为变量。VMT 中的这个槽可以用来存储任何 4 字节的值，但是如果你想存储，你总是可以分配一个包含所有你想要的字段的记录。

于 2008-09-16T13:54:29.937 回答
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;

请注意，此类变量可以从任何类实例写入，因此您可以在代码中的其他位置设置它，通常基于某些条件（记录器的类型等）。

编辑：在班级的所有后代中也将是相同的。在其中一个孩子中更改它，它会为所有后代实例更改。您还可以设置默认实例处理。

 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;
于 2008-09-16T12:55:21.733 回答
2

您正在寻找的关键字是“class var” - 这会在您的类声明中启动一个类变量块。如果您希望在其后包含其他字段，则需要以“var”结束该块（否则该块可能以“private”、“public”、“procedure”等说明符结束）。例如

（编辑：我重新阅读了这个问题并将引用计数移到 TMyClass 中 - 因为如果它来自其他人的库，您可能无法编辑要共享的 TMySharedObjectClass 类）

  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;

请注意，上面不是线程安全的，可能有更好的引用计数方法（例如使用接口），但这是一个简单的示例，应该可以帮助您入门。注意 TMySharedObjectClass 可以替换为 TLogLogger 或任何你喜欢的。

于 2008-09-16T13:07:08.320 回答
2

好吧，这不是美，但在 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;

我目前正在使用它来构建单例对象。

于 2009-06-24T13:13:10.200 回答
1

对于我想做的事情（一个私有类常量），我能想出的最简洁的解决方案（基于迄今为止的响应）是：

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.

也许更面向对象会是这样的：

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.

如果有多个这样的类常量，这可能更有意义。

于 2008-09-16T15:20:38.950 回答
1

在提出“完美”解决方案之前，我认为需要回答两个问题。

  • 首先，是 TLogLogger 是否是线程安全的。可以从多个线程调用相同的 TLogLogger而不调用“同步”吗？即使是这样，以下内容仍可能适用
  • 类变量是线程范围内的还是真正全局的？
  • 如果类变量是真正的全局变量，并且 TLogLogger 不是线程安全的，则最好使用单元全局线程变量来存储 TLogLogger（尽管我不喜欢以任何形式使用“全局”变量），例如

代码：

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;

编辑：似乎类变量是全局存储的，而不是每个线程的实例。有关详细信息，请参阅此问题。

于 2008-09-17T09:23:48.770 回答
0

在版本 7 之前，Delphi 没有静态变量，您必须使用全局变量。

为了使其尽可能私密，请将其放在implementation您单位的部分。

于 2008-09-16T12:45:30.120 回答
0

在 Delphi 中，静态变量被实现为变量类型常量:)

这可能有点误导。

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

是的，另一种可能性是在implementation模块的一部分中使用全局变量。

这仅在全局或使用{$J+}语法 (tnx Lars) 打开编译器开关“Assignable Consts”时才有效。

于 2008-09-16T12:48:38.100 回答