Nos petits trucs utiles de développeurs

[TryExceptEnd]

Pour les raccourcis clavier : http://olance.developpez.com/article...accourcis-ide/

[mick605]

Cool

Dommage que certains de ces raccourcis ne soient pas disponibles dans la version personnelle .... Je pense principalement au Ctrl+Shift+C qui a l'air super utile !!

[Droïde Système7]

Ça faisait longtemps que je n'avais eu l'occasion, à chatouiller du code en rapport avec la gestion des exceptions.

Hé oui en général, dès que l'on s'approche de près où de loin vers ces méthodes, c'est que ça devient chaud quelque part.

J'ai donc ajouté du code aux bons endroits et testé...

J'ai testé et re testé... mais sans jamais avoir un résultat positif ; comme si tout code ajouté ne servait rigoureusement à rien.

J'ai consulté scrupuleusement des tutos, mais en vain, toujours le même résultat

Au bout de plusieurs heures, si si... j'ai eu comme un flash

Bon sang mais c'est bien sûr !!!

Si ça vous arrive, pensez à moi.

Heuuuuuu, j'oubliais : pensez à tester votre exe hors EDI hein.

Enfin je suis sous D7, peut-être que les choses sont gérées désormais de façon différente sous d'autres versions de Delphi ?

[Andnotor]

Et si tu nous disais la différence de comportement constatée en et hors EDI...

[Droïde Système7]

Envoyé par Andnotor

Et si tu nous disais la différence de comportement constatée en et hors EDI...

Comme inscrit plus haut, j'ose me citer :

J'ai testé et re testé... mais sans jamais avoir un résultat positif ; comme si tout code ajouté ne servait rigoureusement à rien.

Comme si tout code ajouté se servait strictement à rien = EDIT en colère avec message genre "Violation d'adresse...".

Autrement dit l'EDI garde la main et détecte le souci en amont du code soulevant l'exception. Donc le code en question ne peut être exécuté.

Mais je suis toujours sous D7, ceci expliquant peut-être cela

Tandis qu'hors EDI, l'exception est effectivement bien gérée, du nickel chrôme quoi

[Linkin]

Dans l'EDI, la gestion d'exception est gérée en débugage, encore heureux.

Par contre, il lève l'exception et "arrête" le programme. Il faut acquitter l'exception puis continuer l'exécution.

[Droïde Système7]

Envoyé par Linkin

[...]
Par contre, il lève l'exception et "arrête" le programme. Il faut acquitter l'exception puis continuer l'exécution.

Je peux t'assurer que dans mon cas (doit pas être le seul) qu'une fois les F7 passés, ça plante dans l'appli (pas l'EDI) et que le code n'est pas exécuté.

Sinon je ne pense pas que, l'autre fois, j'aurais passé des heures à tourner en rond.

[ouiouioui]

Pour ceux qui ne connaisse pas il existe de merveilleux petit addon pour Delphi


Voila ceux que j'utilise :
http://www.gexperts.org/ rajoute des fonctions très utile, celle que j'utilise le plus c'est "components to code" tu pose ton composants sur ta fiche tu le règle et "components to code" te donne le code pour le créer en runtime avec les réglages choisi, il reste plus qu'a supprimer le composants de la fiche.

http://andy.jgknet.de/blog/ IDE Fix Pack qui existe pour Delphi 7, 2007, ... XE
la liste est trop longue aller voir le site, c'est un boost pour le démarrage, la complétition de code, la compilation, la recherche, ...
Je l'utilise depuis Delphi 2007 j'ai jamais eu de souci avec. Le site a d'autre outils sympa.

vidéo de démarrage de mon Delphi avec JVCL, FastReport, DevExpress VCL. 9sec
c'est un redémarrage en fait le 1er démarrage est légèrement plus long.

YouTube - Démarrage Delphi XE + IDE Fix Pack

YouTube - Démarrage Delphi XE + IDE Fix Pack

[Andnotor]

Le bloc d'exception n'est pas traité, soit. Mais qu'est-ce qui devrait générer l'exception ? Utilises-tu un FindWindow par exemple ?

Pourquoi FindWindow ? Simplement parce que la fiche en conception à toute les caractéristiques d'une fiche en exécution. On a l'impression que FindWindow devrait échoué parce que notre fenêtre n'est pas (encore) créée depuis notre exe, mais en fait FindWindow nous renvoi la fiche ouverte dans l'EDI...

Il y a peut être d'autres cas, d'où le besoin dans savoir plus. Dire que le code n'est pas exécuté si lancé depui l'EDI n'est pas suffisant

[Droïde Système7]

Envoyé par Andnotor

Le bloc d'exception n'est pas traité, soit. Mais qu'est-ce qui devrait générer l'exception ? Utilises-tu un FindWindow par exemple ?

Pourquoi FindWindow ? Simplement parce que la fiche en conception à toute les caractéristiques d'une fiche en exécution. On a l'impression que FindWindow devrait échoué parce que notre fenêtre n'est pas (encore) créée depuis notre exe, mais en fait FindWindow nous renvoi la fiche ouverte dans l'EDI...

Il y a peut être d'autres cas, d'où le besoin dans savoir plus. Dire que le code n'est pas exécuté si lancé depui l'EDI n'est pas suffisant

Le cas traité en soit n'est pas bien méchant, c'est dans l'esprit du titre de ce thread : pour aider les débutants

Voici en gros mon code qui chatouille et provoque...

Code :

1
2
3
4
5
6
7
8
9
10
    TRY
    GetConvert(StrToInt(D));
    EXCEPT
    on EconvertError do
    begin
      //ShowMessage('Ça va péter !');
      WarnCapa10;
      exit;
      end;
    END;

Ensuite plus loin je préserve et assure le code par des : StrToIntDef(...).

ouiouioui, intéressant aussi ton message merci, je vais éplucher ça. Par la même ça en aidera certainement plus d'un.

[Caribensila]

Salut à tous,

Deux petits trucs utiles en conception comme en utilisation :

1) Lorsque l'Application doit afficher un nombre de lignes assez important dans des contrôles comme par exemple le TMemo ou le TListBox, la vitesse d'affichage dépend de la fonte choisie. Par exemple, MS Sans Serif s'affiche 4 fois plus vite que Times New Roman.

2) Heureusement, il n'est pas nécessaire de s'imposer certaines fontes plutôt que d'autres. Il suffit d'encadrer le code d'affichage par BeginUpdate et EndUpdate (contrôles utilisant TStrings).

EXEMPLE :

Code :

1
2
3
4
Memo1.Lines.BeginUpdate;
try
  {[code d'affichage]}
finally  Memo1.Lines.EndUpdate;  end;

Valeurs relevées avec un test d'affichage de 400 lignes dans un TMemo (D7):
- Times New Roman => 4s.
- MS Sans Serif => 1s.
- Avec BeginUpdate/EndUpdate (pour les deux fontes ci-dessus) => 0,05 s (!)

[CapJack]

Avec Outils/Configurer les outils/Ajouter...





(testé avec Delphi 2009 sous Win 7).

Créeront deux outils ouvrant un explorateur de fichiers, le premier dans le répertoire du fichier sélectionné dans l'éditeur, le deuxième dans le répertoire cible du projet. Explo électronique, toujours pratique.



Déterminer la taille d'un fichier en toutes circonstances, même s'il est ouvert dans une autre application :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function DTFileSize
        (
        const APath             : string
        ) : Int64;
 var S : TFileStream;
 begin
  Result := 0;
  if not(FileExists(APath)) then exit;
  S := nil;
  try
   S := TFileStream.Create( ExpandFileName( APath ),
                            fmOpenRead or fmShareDenyNone );
   Result := S.Size;
  finally
   if assigned(S) then S.Free;
  end;
 end;

Résoudre le problème du warning "Char in SetOfChar" sous Delphi 2009 et +, en conservant un code universel :

Se compile sous toutes les versions de Delphi, Ansi ou Unicode, et paf ! le warning.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
type
        {$IFDEF UNICODE}
        SetOfChar = TSysCharSet;
        {$ELSE}
        SetOfChar = set of Char;
        {$ENDIF UNICODE}
 
Function  DTCharInSet(C:Char;const CharSet:SetOfChar):Boolean;
 begin
  {$IFDEF UNICODE}
  Result := CharInSet(C,CharSet)
  {$ELSE}
  Result := C in CharSet
  {$ENDIF UNICODE}
 end;

[CapJack]

Spécial Delphi XE2

Il n'y a pas de directive pour savoir si on est dans un "contexte VCL" ou dans un "contexte FMX", ce qui est logique puisque cette notion n'a pas de sens : en effet il est possible d'avoir au sein de la même application des fiches VCL et des fiches FMX (même si cela est déconseillé par Embarcadero).

Par contre il est tout à fait possible, dans le cadre d'une procédure opérant sur un composant, ou d'une méthode dudit composant, de savoir si ce composant est sur une fiche FMX ou sur une fiche VCL :

Les fiches VCL dérivent de VCL.Forms.TCustomForm
Les fiches FMX dérivent de FMX.Forms.TCommonCustomForm;

Je vous propose un squelette de code pour un composant non visuel qui aurait besoin de connaître le contexte dans lequel il est instancié, et qui pourrait se compiler sous n'importe quelle version de Delphi (et de Lazarus, avec quelques ajouts simples) :

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
uses 
  {$IFDEF DCC}
  WinAPI.Windows, System.SysUtils, WinAPI.Messages,
  System.Classes, VCL.Forms, VCL.Dialogs, FMX.Forms;
  {$ELSE}
  Windows, SysUtils, Messages, Classes, Forms, Dialogs;
  {$ENDIF DCC} // C'est juste un exemple
 
...
 
procedure TMyComponent.DoSomethingContextDependent;
 var 
     lO : TComponent;
     {$IFDEF DCC}
     lF : VCL.Forms.TCustomForm;
     lX : FMX.Forms.TCommonCustomForm;
     {$ELSE}
     lF : TCustomForm;
     {$ENDIF DCC}
 
 begin
 
  ...
  {$IFDEF DCC}
 
  lO := lC.Owner;
  while assigned(lO)
    and not (LO is VCL.Forms.TCustomForm)
    and not (lO is FMX.Forms.TCommonCustomForm)
     do lO := lO.Owner;
 
  if (lO is VCL.Forms.TCustomForm)
   then
    begin
     lF := VCL.Forms.TCustomForm(lO);
     // Faire des trucs VCL avec la fiche lF, dans Delphi XE2
    end;
 
  if (lO is FMX.Forms.TCommonCustomForm)
   then
    begin
     lX := FMX.Forms.TCommonCustomForm(lO);
     // Faire des trucs FMX avec la fiche lX, dans Delphi XE2
    end;
 
  {$ELSE}
 
  lO := lC.Owner;
  while  assigned(lO)
     and not (LO is TCustomForm)
     do lO := lO.Owner;
 
  if (lO is TCustomForm)
   then begin
         lF := TCustomForm(lO);
         // Faire des trucs VCL avec la fiche lF, dans Delphi XE ou inférieur
        end;
 
  {$ENDIF DCC}
 
 end;

S'agissant toujours de la FMX et de Windows (uniquement), les handles des composants FMX sont des handles "propriétaire" internes à la FMX, et qui n'ont rien à voir avec les handles de Windows. Mais alors, comment utiliser l'API de Windows si on en a besoin ?

Il existe une fonction pour ça, elle est dans l'unité Fmx.Platform.Win :

Code :

WinHandle := FmxHandleToHWND(lX.Handle);

Je suppose qu'il faut l'utiliser avec prudence, mais il est potentiellement possible alors d'appeler n'importe quelle fonction de WinAPI.Windows en utilisant la valeur renvoyée par cette fonction.

Enjoy!

[Droïde Système7]

Merci mon capitaine pour ces précieuses infos

Mais... ne pas oublier ni dévier du sujet de ce thread...

En effet, demande à un débutant ce qu'il pense de la réalisation de composants. Sans parler s'il fait le distinguo entre un "contexte VCL" et FMX".

@+

[CapJack]

Hum. Oui. Désolé...

Je m'étais focalisé sur le titre "nos petits trucs utiles..." en oubliant que c'était avant tout destiné aux débutants.

Dont acte.

[Droïde Système7]

Envoyé par CapJack

Hum. Oui. Désolé...

Je m'étais focalisé sur le titre "nos petits trucs utiles..." en oubliant que c'était avant tout destiné aux débutants.

Dont acte.

Pas de mal, l'intention était fort louable

En échange ; peux-tu nous donner stp un autre truc plus accessible aux débutants ?

Merci pour eux

[Whiler]

Raccourcis clavier : http://docwiki.embarcadero.com/RADSt...ar_d%C3%A9faut

On remarque au passage que la doc est disponible en ligne... (depuis la version D7)

Sinon, je ne peux plus me passer de cnpack, entre autre pour la coloration des indentations...
Pour illustrer :

[dehorter olivier]

Je viens d'essayer, et il y a plein de choses intéressantes

MERCI

[Droïde Système7]

Envoyé par dehorter olivier

Je viens d'essayer, et il y a plein de choses intéressantes

MERCI

http://www.cnpack.org/images/cnwizards.gif

[CapJack]

Polymorphisme, static et virtual...

Je ne définirai pas ces termes, des tutoriels bien faits existent pour ça sur developpez.net.

Ce que je propose là n'entre pas dans la catégorie des trucs utiles, mais plutôt des trucs "pédagogiques"... par contre, c'est bien pour les débutants.

Pour la petite histoire, quand j'ai commencé à étudier la programmation objet il y a... enfin voilà, quoi, j'ai beaucoup ramé au début pour comprendre les notions de polymorphisme, d'héritage, tout ça. Avec le recul, j'ai compris que c'était lié au fait que par défaut, les méthodes de Delphi sont déclarées static, donc, par défaut, Delphi ne gère pas le polymorphisme. Ceci pour des raisons techniques de performance qui étaient sans doute valables sous un 486 cadencé à 33 MHz, mais qui ne sont peut-être plus vraiment d'actualité aujourd'hui.

Je trouve que c'est quand on passe une classe ancêtre comme paramètre d'une fonction qu'on comprend de façon limpide ces notions.

Voici une unité, à copier/coller et à sauvegarder sous le nom ExemplePolymorphismeU :

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
unit ExemplePolymorphismeU;
 
interface
 
type
 TPepe = class
          function QuiJeSuis  : string;virtual;
          function CeQueJAime : string;
         end;
 
 TPapa = class(TPepe)
             function QuiJeSuis  : string;override;
             function CeQueJAime : string;
            end;
 
 TFill = class(TPapa)
             function QuiJeSuis  : string;override;
             function CeQueJAime : string;
            end;
 
 TFils = class(TPapa)
             function QuiJeSuis  : string;override;
             function CeQueJAime : string;
            end;
 
 TTest = class(TFils)
             function QuiJeSuis  : string;override;
            end;
 
implementation
 
function TPepe.QuiJeSuis;
 begin
  Result := 'Je suis l''ancêtre.';
 end;
 
function TPepe.CeQueJAime;
 begin
  Result := 'J''aime les trucs de vieux.'
 end;
 
 
 
function TPapa.QuiJeSuis;
 begin
  Result := 'Je suis le père.';
 end;
 
function TPapa.CeQueJAime;
 begin
  Result := 'J''aime les trucs de papa.'
 end;
 
 
 
function TFils.QuiJeSuis;
 begin
  Result := 'Je suis le fils.';
 end;
 
function TFils.CeQueJAime;
 begin
  Result := 'J''aime les trucs de jeune garçon.'
 end;
 
 
 
function TFill.QuiJeSuis;
 begin
  Result := 'Je suis la fille.';
 end;
 
function TFill.CeQueJAime;
 begin
  Result := 'J''aime les trucs de jeune fille.'
 end;
 
 
 
function TTest.QuiJeSuis;
 begin
  Result := 'Je suis le test.';
 end;
 
end.

Maintenant, créez une nouvelle application VCL, collez sur la fiche principale un TMemo et un TButton, et adaptez-y le code suivant :

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
unit ExemplePolymorphismeF;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExemplePolymorphismeU, StdCtrls;
 
type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
    procedure Presentation(Personne:TPepe);
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
 
procedure TForm1.Presentation(Personne:TPepe);
 begin
  Memo1.Lines.Add(Personne.QuiJeSuis);
  Memo1.Lines.Add(Personne.CeQueJAime);
  Memo1.Lines.Add('');
 end;
 
procedure TForm1.Button1Click(Sender: TObject);
var Pepe : TPepe;
    Papa : TPapa;
    Fill : TFill;
    Fils : TFils;
    Test : TTest;
begin
 Pepe := TPepe.Create;
 Papa := TPapa.Create;
 Fill := TFill.Create;
 Fils := TFils.Create;
 Test := TTest.Create;
 
 Presentation(Pepe);
 Presentation(Papa);
 Presentation(Fill);
 Presentation(Fils);
 Presentation(Test);
 
 Test.Free;
 Fils.Free;
 Fill.Free;
 Papa.Free;
 Pepe.Free;
end;
 
end.

Compilez, cliquez... étonnant, non ?

Maintenant, modifiez le code de la première unité en :

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
type
 TPepe = class
          function QuiJeSuis  : string;virtual;
          function CeQueJAime : string;virtual;
         end;
 
 TPapa = class(TPepe)
             function QuiJeSuis  : string;override;
             function CeQueJAime : string;override;
            end;
 
 TFill = class(TPapa)
             function QuiJeSuis  : string;override;
             function CeQueJAime : string;override;
            end;
 
 TFils = class(TPapa)
             function QuiJeSuis  : string;override;
             function CeQueJAime : string;override;
            end;
 
 TTest = class(TFils)
             function QuiJeSuis  : string;override;
            end;

Compilez, cliquez... comparez, observez, méditez, comprenez.