Utiliser un timer dans une application console

Version imprimable

24/05/2005, 18h39
chavers

Utiliser un timer dans une application console

Bonsoir,

J'ai réalise une application shell qui liste les taches d'un serveur, calcule le checksum de la comande....

Sur certain serveur mon application freeze, je cherche donc une methode pour qu'elle se ferme toute seule.

Je teste l'utilisation de tread pour mes function, avec un timer qui ferme mon appli au bout de 1 mn (le traitement normal est beraucoup moin long).

bref, comment utiliser Timer1.OnTimer sans avoir d'objet ?

c'est une bonne blaque non :wink: ?

Renaud.

Pourquoi n'as-tu pas d'objets ? Qu'est-ce qui t'empêche d'utiliser un TTimer malgré tout ?

[EDIT]
Je précise :

Code:

1
2
3
4
5
6
7
8
9
10
 
Type
    TMonTimer = Class
    private
        FTimer : TTimer ;
    public    
         Constructor Create ;
         Procedure OnTimer (Sender: TObject) ;
        Property Timer : TTimer Read FTimer Write FTimer ;
    End ;

Puis :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
Constructor TMonTimer.Create ;
Begin
     FTimer:=TTimer.Create(Self) ;
     FTimer.OnTimer:=Self.OnTimer;
End;
 
Procedure TMonTimer.OnTimer (Sender: TObject) ;
Begin
     FTimer.Enabled:=False;
     // Mettre ici ce que tu veux faire sur le OnTimer, comme un appel de procédure par exemple.
End;

[/EDIT]

Sinon, tu peux passer via l'API Win32 et les fonctions SetTimer et KillTimer.

24/05/2005, 19h00
chavers

Merci de ta reponse je teste ca de suite :lol:

Bon je sais que je ne suis pas un developpeur...
mais j'ai une erreur de types incompatibles entre TCoponent et TMonTimer au niveau du Create(self).
voici le code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
program TestTimer;
 
{$APPTYPE CONSOLE}
 
uses
  SysUtils,
  classes,
  QExtCtrls;
 
Type
    TMonTimer = Class
    private
        FTimer : TTimer ;
    public
      Constructor Create ;
      Procedure OnTimer (Sender: TObject) ;
      Property Timer : TTimer Read FTimer Write FTimer ;
    End ;
 
var
  i: Integer;
 
Constructor TMonTimer.Create ;
Begin
     FTimer := TTimer.Create(Self);
     FTimer.OnTimer:=Self.OnTimer;
     FTimer.Interval := 1000;
     FTimer.Enabled := True;
End;
 
Procedure TMonTimer.OnTimer (Sender: TObject) ;
Begin
     FTimer.Enabled:=False;
     exit;
End;
begin
 
  for i := 0 to 100 do
  begin
    Writeln(IntToStr(i));
    Sleep(1000);
  end;
end.

Je retourne dans doc et me commande une formation. Le Turbo Pascal scolaire est vraiment loin :?

Essay de remplacer

Code:

1
2
3
4
5
6
7
8
9
Type
    TMonTimer = Class
    private
        FTimer : TTimer ;
    public
      Constructor Create ;
      Procedure OnTimer (Sender: TObject) ;
      Property Timer : TTimer Read FTimer Write FTimer ;
    End ;

par

Code:

1
2
3
4
5
6
7
8
9
Type
    TMonTimer = Class(TCoponent)
    private
        FTimer : TTimer ;
    public
      Constructor Create ;
      Procedure OnTimer (Sender: TObject) ;
      Property Timer : TTimer Read FTimer Write FTimer ;
    End ;

Le TTimer demande un TCoponent, ou un de ces enfants, pour s'initialiser... par contre, ta nouvelle classe demanderas un TCoponent au Create.

Ou alors, tu devrais pouvoir changer le create(self) par create(nil) ;)

25/05/2005, 10h34
Mac LAK

Oui, j'ai pas testé le code, j'ai fait ça rapidement de tête...

Citation:

Envoyé par /dev/null

Ou alors, tu doit pouvoir changer le create(self) par create(nil) ;)

C'était pour économiser un destructeur...

Si tu mets "Nil", tu n'as pas besoin de dériver de TComponent. Par contre, il faudra ajouter un destructeur pour détruire l'instance TTimer privée.

Pas de probleme Mac, c'est deja cool de me repondre :wink:

Voila la suite:

j'ai remplace

Code:

TMonTimer = Class

par

Code:

TMonTimer = Class(TTimer)

Mais la procedure TMonTimer.OnTimer ne s'execute pas ???

mon code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
program TestTimer;
 
{$APPTYPE CONSOLE}
 
uses
  SysUtils,
  classes,
  QExtCtrls;
 
Type
    TMonTimer = Class(TTimer)
    private
       FTimer : TTimer ;
    public
      Constructor Create ;
      Procedure OnTimer (Sender: TObject) ;
      Property Timer : TTimer Read FTimer Write FTimer ;
    End ;
 
var
  i: Integer;
 
Constructor TMonTimer.Create ;
Begin
     FTimer := TTimer.Create(Self);
     FTimer.OnTimer:=Self.OnTimer;
     FTimer.Interval := 3000;
     FTimer.Enabled := True;
End;
 
Procedure TMonTimer.OnTimer (Sender: TObject) ;
Begin
     Writeln('time');
     exit;
End;
begin
  TMonTimer.Create;
  for i := 0 to 12 do
  begin
    Writeln(IntToStr(i));
    Sleep(1000);
  end;
end.

Je rame grave :oops:

Citation:

Envoyé par chavers

Pas de probleme Mac, c'est deja cool de me repondre :wink:

Bah, je suis ici pour ça...

Citation:

Envoyé par chavers

j'ai remplace

Code:

TMonTimer = Class

par

Code:

TMonTimer = Class(TTimer)

Non, pas bon.
Je viens de tester, effectivement, ça ne marche pas... Et en plus, c'est pour une raison évidente : il n'y a pas de boucle de consommation de messages !! J'avais oublié ce "détail"...

Voilà un code qui marche nickel (testé, cette fois-ci) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
program TestTimer;
 
{$APPTYPE CONSOLE}
 
uses
  Windows, Messages, SysUtils ;
 
Type
    // Type procédural : fonction de callback pour timer.
    TTimerProc = Procedure ;
 
    // Structure de gestion d'un timer-thread.
    TTimerParam = Record
       Thread   : THandle    ;    // Handle du thread.
       ThreadID : Cardinal   ;    // Thread ID.
       Interval : Cardinal   ;    // Période du timer.
       OnTimer  : TTimerProc ;    // Procédure de callback.
       Running  : Boolean    ;    // Flag d'activation/acquittement de fermeture.
       End ;
 
// Exemple de procédure activée pour un timer.
Procedure OnTimer ;
Begin
     Writeln('time');
End;
 
{
   Thread d'un timer.
   lpParam : Pointeur sur une structure TTimerParam.
   Retour : Toujours 0.
}
Function TimerThread ( lpParam : Pointer ) : DWORD ; stdcall ;
Var
   Param : ^TTimerParam ;
Begin
     Result:=0;
     Param:=lpParam;
     While (Param^.Running) Do
           Begin
           Sleep(Param^.Interval);
           If (Param^.Running) Then
              Param^.OnTimer;
           End;
     // Acquittement.
     Param^.Running:=True;
End;
 
{
   Création d'un timer sous forme de thread.
   Interval : Période du timer, en millisecondes.
   OnTimer : Procédure (sans paramètres) appelée lors du déclenchement du timer.
   Result : Structure de timer (retournée).
}
Procedure CreateTimer ( Interval : Cardinal ; OnTimer : TTimerProc ; Out Result : TTimerParam ) ;
Begin
     // Initialisation des paramètres.
     Result.Interval:=Interval ;
     Result.OnTimer:=OnTimer ;
     Result.Running:=True ;
     // Création du thread.
     Result.Thread:=CreateThread(Nil,0,@TimerThread,@Result,0,Result.ThreadID);
End;
 
// Détruit un timer existant.
Procedure DestroyTimer ( Var TimerParam : TTimerParam ) ;
Begin
     // Demande de fermeture du thread.
     TimerParam.Running:=False;
     // Attente fermeture "réelle".
     Repeat
           Sleep(TimerParam.Interval);
     Until TimerParam.Running ;
     // Fin du thread.
     CloseHandle(TimerParam.Thread);
End;
 
Var
   I     : Integer     ;
   Timer : TTimerParam ;
 
begin
     // Création d'un timer.
     CreateTimer(300,@OnTimer,Timer);
 
     // Programme principal.
     for i := 0 to 12 do
         begin
         Writeln(IntToStr(i));
         Sleep(100);
         end;
 
     // Destruction du timer (bloquant)
     DestroyTimer(Timer);
end.

25/05/2005, 14h07
chavers

Ca marche nickel, Merci MAC.