Depuis que j'ai appris Delphi en 1999, j'ai été fasciné par son développement rapide. A cette époque, je venais d'entrer en contact avec la programmation et j'étais particulièrement intéressé par le développement visuel. La raison en est qu'il peut être implémenté plus rapidement que le C. Ces dernières années, de Delphi C/S au B/S à trois couches, j'ai également écrit des logiciels, petits et grands. , je pense que ce Delphi n'a que ces fonctions. Depuis que j'ai récemment reçu un livre "Com Essence" et étudié le code source de la VCL, j'ai trouvé qu'il est vraiment puissant (je ne sais pas quels mots utiliser pour le décrire récemment). , certaines avancées sont partagées ici avec tout le monde. Veuillez me dire s'il y a des erreurs.
Pour parler franchement, les composants n'incluent que deux types de membres : les propriétés et les méthodes (les méthodes dont je parle incluent des événements)
Il est divisé en quatre parties :
Privé
protégé
publique
publié
Les significations des quatre parties ci-dessus seront présentées dans des livres généraux de développement visuel. Voici seulement un bref aperçu relatif à Delphi.
Privé : tous les membres privés sont placés ici et ne sont accessibles que par les propres méthodes de la classe, pas par les sous-classes, et sont transparents pour les sous-classes. On peut également dire qu'il n'est accessible que par les méthodes de l'unité elle-même.
protected : sauf qu'il peut être hérité par les sous-classes, le reste est identique à private. Non accessible aux étrangers.
public : Public, les propriétés et méthodes déclarées ici peuvent être appelées par les utilisateurs.
publié : apparaît dans la barre de propriétés de l'environnement de développement Delphi.
Commençons par créer le contrôle le plus simple. En moins de cinq minutes, vous comprendrez comment sont créés les composants du panneau de composants de Delphi.
Nouveau->Nouveau->Composant et appuyez sur Entrée.
Sélectionnez ensuite la classe parent dont vous souhaitez hériter dans Type Ancestor :. Ici, nous choisissons TComponent. Cela signifie hériter de toutes les propriétés et méthodes de TComponent.
Nom de classe : saisissez le nom de classe du composant à créer. (Nous entrons dans TShowText)
Page Palette : sur quel panneau Delphi le composant sera installé. (Nous choisissons Échantillons, vous pouvez également saisir un nouveau nom)
Je n’ai pas besoin de dire ce qui suit.
Cliquez sur le bouton OK et Delphi génère automatiquement un contrôle de base hérité de TComponent. On peut également comprendre que nous avons développé un contrôle aussi puissant que TComponent, mais ce n'est pas ce dont nous avons besoin.
Ce qui suit explique les méthodes de lecture et d'écriture des variables privées du composant lui-même :
Par exemple, nous avons écrit le court paragraphe suivant :
privé
FTexte : chaîne ;
....
/*Les variables privées ne peuvent pas être utilisées par le monde extérieur, alors comment pouvons-nous faire fonctionner cette variable de chaîne FText ? */
Nous devons également ajouter ce paragraphe après Publié :
propriété Texte : chaîne lire FText écrire FText ;
Cela signifie ici que cette propriété Text apparaîtra dans la barre de propriétés de delphiSDK. Les utilisateurs qui modifient le texte dans la barre de propriétés modifient en fait la variable de chaîne FText. read signifie que l'utilisateur lit l'attribut Text et lit réellement FText. Write, bien sûr, signifie que l'utilisateur attribue une valeur à Text et la stocke dans la variable de chaîne FText.
Si vous l'enregistrez à ce moment-là et l'installez dans Delphi, alors notre composant le plus basique sera terminé. (La méthode d'installation des composants est présentée à la fin)
Haha, n'est-ce pas très simple ? C'est juste que notre composant n'a aucune utilité spécifique.
Nous venons d'introduire les attributs ici, nous allons maintenant continuer à ajouter des fonctions pour introduire l'utilisation des méthodes.
Nous ajoutons ce qui suit après Public :
procédure ShowText();
Appuyez ensuite sur Ctrl + Alt + C, le système ajoute automatiquement le code d'implémentation de certaines méthodes pour vous.
Ensuite, nous écrivons :
procédure TShowText.ShowText();
commencer
AfficherMessage(FTexte);
fin;
Comme vous pouvez le voir, le ShowMessage ci-dessus affiche la valeur de la variable privée de la classe. Vous devez maintenant comprendre que les variables privées ne sont accessibles que dans la méthode de la classe elle-même. Ici, vous devez ajouter l'unité Dialogs après utilisation, car ShowMessage est inclus dans l'unité Dialogs, sinon il ne passera pas.
Bien entendu, les événements ci-dessus ne peuvent être utilisés que dans le contrôle et ne peuvent pas apparaître dans la barre d'événements de la zone de propriétés. Pourquoi ? Parce que la méthode déclarée ici est uniquement Public, une méthode pure, et n'est pas déclarée comme un événement.
Grâce à l’étude ci-dessus, savez-vous déjà comment rédiger et ajuster les propriétés et méthodes des contrôles ?
Cependant, un véritable contrôle est indissociable des événements, et l'invocation d'événements doit être pilotée par des messages, qui seront introduits dans mon prochain article.
Les propriétés et les méthodes d’un contrôle puissant ne sont pas si simples. Cela nécessite plus de pratique et plus d’applications.
Vous trouverez ci-dessous un contrôle DBGridToExcel que j'ai écrit, dont la fonction est d'exporter les données du DBGrid vers Excel. Vous pouvez en tirer des leçons et l’utiliser comme référence. Ce contrôle inclut l'utilisation de propriétés, de méthodes et d'« événements » dont nous parlerons dans le prochain article.
Annexe 1 : Comment installer des contrôles faits maison :
(1). Dans le menu Composant, sélectionnez "Installer le composant...".
(2). Cliquez sur "..." après le nom du fichier unité, sélectionnez le fichier unité du contrôle "*.pas", puis cliquez sur OK. Cliquez sur "installer" dans la fenêtre qui apparaît et l'installation est terminée.
Le contrôle nouvellement installé apparaît dans votre panneau.
Pièce jointe 2 : copiez l'intégralité du code source du contrôle TDBGridToExcel dans le Bloc-notes et enregistrez-le en tant que fichier .pas.
unité DBGridToExcel ;
{************************************************* * ***********************}
{* *}
{* Exporter la grille vers le contrôle Word VCL pour D5 et D6 *}
{* Copyright(C) xiangding 2003.10.1 Tous droits réservés *}
{* Rapport de bug : [email protected] *}
{* Auteur : Petit Ours*}
{* *}
{************************************************* * ***********************}
{* *}
{* Ceci est une version simple *}
{* *}
{************************************************* * ***********************}
{* *}
{* Installer: *}
{* Veuillez enregistrer sous le fichier GridToExcel.pas puis ouvrez le fichier *}
{* Cliquez sur l'élément de menu [Composant] --> [Installer le composant] *}
{* Cliquez sur le bouton [Installer] dans la boîte de dialogue Installer le composant *}
{* après l'installation, vous pouvez trouver le contrôle sur le composant *}
{* page [exemple] *}
{* *}
{************************************************* * ***********************}
{* *}
{* Installer: *}
{* Enregistrez la pièce jointe, puis ouvrez le fichier GridToExcel.Pas avec Delphi, *}
{* Sélectionnez le menu Delphi -> Composant -> Installer le composant, *}
{* Sélectionnez ensuite Installer. Après l'installation, sur la page Exemples du panneau de configuration, *}
{* Une fois que vous vous y êtes familiarisé, vous pouvez essayer de définir certains attributs complexes et d'explorer les autres par vous-même, *}
{************************************************* * ***********************}
interface
utilise
Windows, StdCtrls, ComCtrls, Messages, DBGrids, Graphiques, ExtCtrls,
Formulaires, DB, ComObj, Contrôles, SysUtils, Classes ;
Chaîne de ressources
SPromptExport = 'Veuillez patienter, les données sont en cours d'exportation...';
SConnectExcel = 'Démarrage d'Excel, veuillez patienter...';
SConnectExcelError= 'Échec de la connexion à Excel. Excel n'est peut-être pas installé et ne peut pas être exporté.';
SAnnuler = '&Annuler';
SErreur = 'erreur';
SConfirm = 'Voulez-vous vraiment mettre fin à l'export des données ? ';
SCaption = 'Confirmer';
SGridError = 'Aucun ensemble de données spécifié, veuillez spécifier le contrôle de l'ensemble de données ! ';
taper
TDBGridToExcel = classe (TComponent)
privé
Formulaire de progression : TForm ;
FShowProgress : booléen ;
ExcelApp : Variante ;
FTitre : chaîne ;
Quitter : booléen ;
FOnProgress : TNotifyEvent ;
FGrid : TDBGrid ; {La grille source}
ProgressBar : TProgressBar ;
Invite : TLabel ;
FAutoExit : booléen ;
FAutoSize : booléen ;
FDBGrille : TDBGrille ;
procédure SetShowProgress (valeur const : booléenne);
procédure CreateProgressForm ;
procédure ButtonClick (Expéditeur : TObject);
Fonction ConnectToExcel : booléenne ;
procédure ExportDBGrid ;
{Déclarations privées}
protégé
{ Déclarations protégées }
publique
Constructeur Create(AOwner : TComponent);
Remplacement du destructeur Destroy();
Procédure ExportToExcel ; {Exporter la grille vers Excel}
{Déclarations publiques}
publié
{ Déclarations publiées }
propriété DBGrid : TDBGrid lit FDBGrid écrit FDBGrid ;
titre de la propriété : chaîne lue FTitle écriture FTitle ;
propriété ShowProgress : booléen lecture FShowProgress écriture SetShowProgress ;
propriété OnProgress : TNotifyEvent lecture FOnProgress écriture FOnProgress ;
fin;
registre de procédure ;
mise en œuvre
registre de procédure ;
commencer
RegisterComponents('Échantillons', [TDBGridToExcel]);
fin;
{TDBGridVersExcel}
procédure TDBGridToExcel.ButtonClick(Expéditeur : TObject);
commencer
Quitter := MessageBox(ProgressForm.Handle, pchar(SConfirm), pchar(SCaption),
MB_OKCANCEL + MB_ICONINFORMATION) = IDOK ;
fin;
fonction TDBGridToExcel.ConnectToExcel : booléen ;
commencer
Résultat := vrai ;
Essayer
ExcelApp := CreateOleObject('Excel.application');
ExcelApp.Visible := Faux ;
si Titre<>'' alors ExcelApp.Caption := Titre;
ExcelApp.WorkBooks.Add ;
sauf
MessageBox(GetActiveWindow,PChar(SConnectExcelError),PChar(SError),Mb_OK+MB_IconError);
résultat := faux;
fin;
fin;
constructeur TDBGridToExcel.Create(AOwner : TComponent);
commencer
hérité;
FShowProgress := True ; {La valeur par défaut était Afficher la progression}
FAutoExit := Faux;
FAutoSize := Vrai ;
fin;
procédure TDBGridToExcel.CreateProgressForm ;
var
Panneau : TPanel ;
Bouton : T Button ;
commencer
si assigné (ProgressForm), alors quittez ; {Aready Create ?}
ProgressForm := TForm.Create(Propriétaire);
Avec ProgressForm, faites
commencer
Font.Name := '宋体';
Taille de police := 10 ;
BorderStyle := bsAucun;
Largeur := 280;
Hauteur := 120;
Largeur de bordure := 1 ;
Couleur := clBackground;
Position := poOwnerFormCenter ;
fin;
Panneau := TPanel.Create(ProgressForm);
avec Panel, faites {Créer un panneau}
commencer
Parent := ProgressForm;
Aligner := alClient;
BevelInner := bvNone;
BevelOuter := bvRaised;
Légende := '';
fin;
Invite := TLabel.Create(Panel);
avec l'invite, faites {Créer une étiquette}
commencer
Parent := Panneau ;
Gauche := 20;
Haut := 25 ;
Légende := SConnectExcel;
fin;
ProgressBar := TProgressBar.Create(panneau);
avec ProgressBar, faites { Créer ProgressBar }
commencer
Étape := 1 ;
Parent := Panneau ;
Lisse := vrai ;
Gauche := 20;
Haut := 50 ;
Hauteur := 18;
Largeur := 260;
fin;
Bouton := TButton.Create(Panel);
avec le bouton faire { Créer un bouton Annuler }
commencer
Parent := Panneau ;
Gauche := 115;
Haut := 80 ;
Légende := SCAnnuler ;
OnClick := BoutonClick ;
fin;
ProgressForm.Show ;
ProgressForm.Update ;
fin;
destructeur TDBGridToExcel.Destroy ;
commencer
hérité;
fin;
procédure TDBGridToExcel.ExportDBGrid ;
var
Données : TDataSet ;
ADBGrid : TDBGrid ;
je, j : entier ;
CurrentPoint : Pointeur ;
OldBeforeScroll, OldAfterScroll : TDataSetNotifyEvent ;
commencer
Screen.Cursor := crHourGlass;
essayer
essayer
TForm(Propriétaire).Enabled := False;
ExcelApp.DisplayAlerts := false;
ExcelApp.ScreenUpdating := false;
Quitter := faux;
si ShowProgress alors Prompt.Caption := SPromptExport;
ADBGrid := DBGrid;
Données := ADBGrid.DataSource.DataSet;
avec ADBGrid, faites {Insérer un en-tête de tableau}
pour i := 1 à Columns.Count faire
si Colonnes[i - 1].Visible alors
ExcelApp.Cells[1,i].Value :=Columns[i - 1].Title.Caption;
CurrentPoint := Data.GetBookmark ; {Enregistrer la position actuelle}
OldBeforeScroll := Data.BeforeScroll; { Enregistrer l'ancien handle d'événement avant le défilement }
OldAfterScroll := Data.AfterScroll; { Enregistrer l'ancien handle d'événement AfterScroll }
Data.DisableControls ; { Désactiver le contrôle }
Data.BeforeScroll := néant ;
Data.AfterScroll := néant ;
si ShowProgress alors ProgressBar.Max := Data.RecordCount;
je := 2;
Données.Première ;
alors que ce n'est pas Data.Eof do { Traiter tous les enregistrements }
commencer
avec ADBGrid faire { Traiter un enregistrement }
pour j := 1 à Columns.Count do
si Colonnes[j - 1].Visible alors
ExcelApp.Cells[i,j].Value := Colonnes[j - 1].Field.DisplayText;
Inc(i);
Données.Suivant ;
si assigné (FOnProgress) alors FOnProgress (Self);
si ShowProgress alors { Mettre à jour l'interface utilisateur de progression }
commencer
ProgressBar.StepIt ;
Application.ProcessMessages ;
si quitter, quittez ;
fin;
fin;
sauf
MessageBox(GetActiveWindow,PChar(SConnectExcelError),Pchar(SError),MB_OK+MB_ICONERROR);
fin;
ExcelApp.Visible := Faux ;
TForm(Propriétaire).Enabled := True;
Screen.Cursor := crDefault;
if ShowProgress then FreeAndNil(ProgressForm); {Formulaire de progression gratuit}
ExcelApp.DisplayAlerts := True ;
ExcelApp.ScreenUpdating := True ;
enfin
Data.BeforeScroll := OldBeforeScroll; { Restaurer l'ancien handle d'événement }
Data.AfterScroll := OldAfterScroll;
Data.GotoBookmark(CurrentPoint);
Data.FreeBookmark(CurrentPoint);
Data.EnableControls ;
Screen.Cursor := crDefault;
fin;
fin;
procédure TDBGridToExcel.ExportToExcel ;
commencer
si DBGrid = nil, alors déclenchez Exception.Create (SGridError); {No DataSource, then Error}
if ShowProgress then CreateProgressForm ; {Afficher ou non le ProgressForm}
sinon ConnectToExcel alors { Quitter lorsqu'une erreur se produit }
commencer
si ShowProgress alors FreeAndNil(ProgressForm); {formulaire de version}
sortie;
fin;
ExportDBGrid ; {début de l'exportation des données}
fin;
procédure TDBGridToExcel.SetShowProgress(const Value: Boolean);
commencer
FShowProgress := Valeur ;
fin;
fin.