德尔福事件处理，如何创建自己的事件

Question

我是新来的Delphi开发。我必须创建一个事件并传递一些属性作为参数。有人可以分享一些演示程序，展示如何从头开始。我几乎在每个网站上搜索了一下，他们都给了一段代码，但我需要的是一个简单易懂的完整的程序。

Answer 1

您可以使用一个事件处理反应过来的时候什么事情发生（例如AfterCreation之前关闭）。

为了使用事件自己的类，您需要定义事件类型。更改所需参数的类型和数量。

type 
    TMyProcEvent = procedure(const AIdent: string; const AValue: Integer) of object; 
    TMyFuncEvent = function(const ANumber: Integer): Integer of object; 

在该类中，您可以添加一个DoEvent（为适当的事件重命名）。所以你可以在内部调用DoEvent。 DoEvent处理未分配事件的可能性。

type 
    TMyClass = class 
    private 
    FMyProcEvent : TMyProcEvent; 
    FMyFuncEvent : TMyFuncEvent; 
    protected 
    procedure DoMyProcEvent(const AIdent: string; const AValue: Integer); 
    function DoMyFuncEvent(const ANumber: Integer): Integer; 

    public 
    property MyProcEvent: TMyProcEvent read FMyProcEvent write FMyProcEvent; 
    property MyFuncEvent: TMyFuncEvent read FMyFuncEvent write FMyFuncEvent; 
    end; 

procedure TMyClass.DoMyProcEvent(const AIdent: string; const AValue: Integer); 
begin 
    if Assigned(FMyProcEvent) then 
    FMyProcEvent(AIdent, AValue); 
    // Possibly add more general or default code. 
end; 


function TMyClass.DoMyFuncEvent(const ANumber: Integer): Integer; 
begin 
    if Assigned(FMyFuncEvent) then 
    Result := FMyFuncEvent(ANumber) 
    else 
    Result := cNotAssignedValue; 
end; 

Answer 2

下面是一个简短但很完整的控制台应用程序，演示如何创建在Delphi自己的事件。包括从类型声明到调用事件的所有内容。阅读代码中的注释以了解发生了什么。

program Project23; 

{$APPTYPE CONSOLE} 

uses 
    SysUtils; 

type 
    // Declare an event type. It looks allot like a normal method declaration except 
    // it suffixed by "of object". That "of object" tells Delphi the variable of this 
    // type needs to be assigned a method of an object, not just any global function 
    // with the correct signature. 
    TMyEventTakingAStringParameter = procedure(const aStrParam:string) of object; 

    // A class that uses the actual event 
    TMyDummyLoggingClass = class 
    public 
    OnLogMsg: TMyEventTakingAStringParameter; // This will hold the "closure", a pointer to 
               // the method function itself + a pointer to the 
               // object instance it's supposed to work on. 
    procedure LogMsg(const msg:string); 
    end; 

    // A class that provides the required string method to be used as a parameter 
    TMyClassImplementingTheStringMethod = class 
    public 
    procedure WriteLine(const Something:string); // Intentionally using different names for 
               // method and params; Names don't matter, only the 
               // signature matters. 
    end; 

    procedure TMyDummyLoggingClass.LogMsg(const msg: string); 
    begin 
    if Assigned(OnLogMsg) then // tests if the event is assigned 
     OnLogMsg(msg); // calls the event. 
    end; 

    procedure TMyClassImplementingTheStringMethod.WriteLine(const Something: string); 
    begin 
    // Simple implementation, writing the string to console 
    Writeln(Something); 
    end; 

var Logging: TMyDummyLoggingClass; // This has the OnLogMsg variable 
    LoggingProvider: TMyClassImplementingTheStringMethod; // This provides the method we'll assign to OnLogMsg 

begin 
    try 
    Logging := TMyDummyLoggingClass.Create; 
    try 

     // This does nothing, because there's no OnLogMsg assigned. 
     Logging.LogMsg('Test 1'); 

     LoggingProvider := TMyClassImplementingTheStringMethod.Create; 
     try 
     Logging.OnLogMsg := LoggingProvider.WriteLine; // Assign the event 
     try 

      // This will indirectly call LoggingProvider.WriteLine, because that's what's 
      // assigned to Logging.OnLogMsg 
      Logging.LogMsg('Test 2'); 

     finally Logging.OnLogMsg := nil; // Since the assigned event includes a pointer to both 
             // the method itself and to the instance of LoggingProvider, 
             // need to make sure the event doesn't out-live the LoggingProvider            
     end; 
     finally LoggingProvider.Free; 
     end; 
    finally Logging.Free; 
    end; 
    except 
    on E: Exception do 
     Writeln(E.ClassName, ': ', E.Message); 
    end; 
end. 

Answer 3

完整的项目回答是好。但是，这是一个备选答案，以您已经拥有的形式展示如何去做你想做的事。

进入您的形式，并转到接口部分，在二类地区，表单的类定义之外，并添加一个类型：

interface 
type 
    TMyEvent = procedure(Sender:TObject;Param1,Param2,Param3:Integer) of object; 

    TMyForm = class(TForm) 
      .... 

这是传统的，但不是必需的，第一项在你的事件中是发送它的对象，但要使用基类TObject而不是表单的实际类类型。
上面的其他参数完全不需要，但显示你将如何声明自己的附加数据。如果你不需要它们，那么只需使用发件人：TObject。 在这种情况下，您不必定义TMyEvent，只需使用TNotifyEvent类型即可。

现在宣布使用该类型，在你的表单字段：

TMyForm = class(TForm) 
private 
    FMyEvent : TMyEvent; 
    ... 

现在宣布访问该字段，在窗体的属性部分属性：

// this goes inside the class definition just before the final closing end 
property MyEvent:TMyEvent read FMyEvent write FMyEvent 

现在去哪里你想要那个事件“火”（如果设置被调用），并写：

// this goes inside a procedure or function, where you need to "fire" the event. 
procedure TMyForm.DoSomething; 
begin 
    ... 
    if Assigned(FMyEvent) then FMyEvent(Self,Param1,Param2,Param3); 
end; 

Answer 4

在将“事件”成DLL的方面，我描述了使用界面的概念，一步一步...也许这有助于以不同的方式：Using event listeners in a non-gui environment (DLL) (Delphi)