Manejo de eventos Delphi, cómo crear un evento propio

Question

Soy nuevo en el desarrollo de delphi. Tengo que crear un evento y pasar algunas propiedades como parámetros. ¿Podría alguien compartir algún programa de demostración que muestre cómo hacerlo desde cero? Busqué en Google casi todos los sitios, todos dieron un código, pero lo que necesito es un programa completo que sea simple y comprensible.

Answer 1

Utiliza un controlador de eventos para reaccionar cuando sucede algo más (por ejemplo, AfterCreation y antes del cierre).

Para utilizar eventos para su propia clase, debe definir el tipo de evento. Cambia el tipo y la cantidad de parámetros necesarios.

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

En la clase, puede agregar un DoEvent (cambiar el nombre para el evento apropiado). ASÍ PUEDES llamar al DoEvent internamente. DoEvent maneja la posibilidad de que un evento no esté asignado.

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

Aquí hay una aplicación de consola breve pero completa que muestra cómo crear su propio evento en Delphi. Incluye todo, desde declaración de tipo hasta llamar al evento. Lee los comentarios en el código para entender lo que está pasando.

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

La respuesta del proyecto completo es buena. Pero esta es una respuesta alternativa que muestra cómo hacer lo que quiere, en una forma que ya tiene.

entrar en su forma, y ​​vaya a la sección de interfaz, en el área de tipos, fuera de la definición de clase de su forma y añadir un tipo:

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

    TMyForm = class(TForm) 
      .... 

Es tradicional, pero no se requiere, que el primer elemento en su caso, sea el objeto que lo envíe, pero use TObject de clase base en lugar del tipo de clase real de su formulario.
Los demás parámetros anteriores no son necesarios en absoluto, pero le muestran cómo declararía sus propios datos adicionales. si no los necesita, simplemente use Sender: TObject. Y en ese caso, no tiene que definir TMyEvent en absoluto, solo use el tipo TNotifyEvent.

Ahora declarar un campo que utiliza ese tipo, en su forma:

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

Ahora declarar una propiedad que tiene acceso a ese campo, en la sección de propiedades del formulario:

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

Ahora ve a donde desea que ese evento 'prenda' (se le llame si está configurado) y escriba esto:

// 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

in el contexto de colocar "eventos" en un archivo DLL. Describí un concepto usando interfaces, paso a paso ... quizás esto ayude de una manera diferente: Using event listeners in a non-gui environment (DLL) (Delphi)