Utilisez Delphi pour implémenter le chiffrement et la compression des fichiers
Auteur: E Mengyuan (WNHOO)
Mail: [email protected]
Amour et amour
Cliquez pour télécharger ce fichier de description détaillé
Aperçu:
Dans ce document, nous parlerons de la mise en œuvre du chiffrement des données, de la compression des données et de l'auto-décompression d'un seul fichier. De même, la compression de plusieurs fichiers ou dossiers peut être réalisée avec une légère modification.
Mots-clés: compression cryptée, zlib, flux, fichiers de ressources
introduction:
Dans la vie quotidienne, nous devons avoir utilisé des logiciels de compression célèbres tels que Winzip et Winrar, ce qui signifie que nous rencontrerons inévitablement des problèmes tels que le chiffrement des données et la compression des données pendant le processus de développement logiciel! Cet article traite de ce problème technique, et grâce à tous les internautes pour leurs compétences. Cet article utilise principalement de puissantes compétences de traitement de flux de Delph pour atteindre le chiffrement et la compression des données, et est utilisé dans le développement de logiciels réels.
1. Fonctions du système
1) Compression des données
Utilisez deux classes de flux fournies par Delphi (tCompessionStream et TdecompressionsStream) pour compléter la compression et la décompression des données.
2) Encryption et compression des données
Le chiffrement des données est réalisé par l'application de "Stream" dans la programmation de Delphi, en utilisant principalement TFileStream et TmemoryStream, deux classes dérivées de TSTREAM;
3) Double-cliquez sur le fichier compressé pour associer et décompresser automatiquement
En modifiant l'association de l'extension de registre avec les fichiers du programme, le trégistre est principalement utilisé;
4) peut générer des fichiers auto-extraits
Le fichier auto-décompressé réalise la décompression automatique de la compression des données 1) et la compression du cryptage des données 2); L'auto-décompression des données est obtenue.
2. Implémentation du système
2.1.
2.2.
(I) Zlib
1) Classe de base TCustomzlibstream: est la classe de base des classes TCompessionStream et TdecompressionStream.
Format: ProcédureOnProgress (expéditeur: tobject); dynamique;
2) Classe de compression TCompessionStream: En plus de hériter de la propriété OnProgress de la classe de base, un autre attribut est ajouté: Compressionrate, qui est défini comme suit:
PropertyCompressionRate: SingleReadGetCompressionRate;
Grâce à cette propriété, le taux de compression peut être obtenu.
Plusieurs méthodes importantes sont définies comme suit:
ConstructOrtCompessionsStream.Create (CompressionLevel: tCompressionLevel; dest: tStream);
Parmi eux: TCompressionLevel (type de compression), il est défini par ce qui suit:
1) Clnone: aucune compression de données n'est effectuée;
2) Clasfest: Effectue une compression rapide, sacrifiant l'efficacité de compression;
3) Cldefault: effectuer une compression normale;
4) Clmax: maximiser la compression et la vitesse du sacrifice;
DEST: Stream Stream, utilisé pour stocker des données compressées.
Functiontcompressionsstream.write (constbuffer; count: longint): longint;
Parmi eux: Buffer: données qui doivent être compressées;
Compte: le nombre d'octets de données à comprimer;
La fonction renvoie le nombre d'octets écrits au flux.
Remarque: Les données de la classe compressée TCompessionsStream ne peuvent être écrites. Les données qui doivent être compressées sont écrites dans le flux via la méthode d'écriture de méthode et sont compressées pendant le processus d'écriture, et est enregistrée dans le flux de mémoire (TMemoryStream) fournie par le constructeur, et l'événement On-Process est déclenché.
3) Classe de décompression TDECOMPRESSIONSTERAM: Contrairement à la classe compressée TCOMPRESSIONSTERAM, ses données ne peuvent être lues que si vous essayez d'écrire des données à l'intérieur, une exception "Erreur" se produira.
Ses plusieurs méthodes importantes sont définies comme suit:
ConstructorCreate (source: tStream);
Parmi eux: Source est un flux qui stocke les données compressées;
FunctionRead (varbuffer; count: longint): longInt;
Fonction de lecture de données, tampon: stocker le tampon de données;
La fonction renvoie le nombre d'octets de lecture. Pendant le processus de lecture, les données sont décompressées et l'événement ONPROCESS est déclenché.
(Ii)
Dans Delphi, la classe de base de tous les objets de flux est la classe TStream, qui définit les propriétés et les méthodes communes de tous les flux.
Les propriétés définies dans la classe TStream sont les suivantes:
1), Taille: Cette propriété renvoie la taille des données dans le flux en octets.
2) Position: Cette propriété contrôle la position d'accès aux pointeurs dans le flux.
Il existe quatre méthodes virtuelles définies dans TSTREAM:
1) Lire: Cette méthode implémente les données de lecture du flux, et la valeur de retour est le nombre réel d'octets lus, qui peuvent être inférieurs ou égaux à la valeur spécifiée.
2) Écrire: Cette méthode implémente la rédaction de données dans le flux, et la valeur de retour est le nombre d'octets réellement écrits dans le flux.
3) Cherchez: cette méthode réalise le mouvement du pointeur de lecture dans le flux, et la valeur de retour est la position du pointeur après le mouvement.
Le prototype de fonction est: functionseek (offset: longInt; origine: word): longint; virtual; abstrait;
Le décalage du paramètre est le nombre d'octets de décalage.
SOFROMBEGINGING: Offset est que les données de distance du pointeur commencent. À l'heure actuelle, le décalage doit être supérieur ou égal à zéro.
SofromCurrent: Offset est la position relative du pointeur et le pointeur actuel après le déplacement.
SOFROMEND: Le décalage est la position où les données de distance du pointeur se terminent après le déplacement. À l'heure actuelle, le décalage doit être inférieur ou égal à zéro.
4) SETSIZE: Cette méthode réalise la modification de la taille des données.
De plus, plusieurs méthodes statiques sont définies dans la classe Tstream:
1) ReadBuffer: La fonction de cette méthode est de lire les données de la position actuelle dans le flux, la même que la lecture ci-dessus.
Remarque: Lorsque le nombre d'octets de lecture est différent du nombre d'octets à lire, une exception EreaDerror sera générée.
2) WriteBuffer: La fonction de cette méthode est d'écrire des données sur le flux à l'emplacement actuel, le même que l'écriture ci-dessus.
Remarque: Lorsque le nombre d'octets écrits en données est différent du nombre d'octets à écrire, une exception EWriteError sera générée.
3) CopyFrom: la fonction de cette méthode est de copier des flux de données à partir d'autres flux.
Le prototype de fonction est: FunctionCopyFrom (Source: TStream; Count: Longint): longInt;
La source de paramètre est le flux qui fournit des données, et le nombre est le nombre d'octets de données copiés. Lorsque le nombre est supérieur à 0, les copies de copies de comptage des données des données de la position actuelle du paramètre source;
Classes de Ttream communément dérivées:
TFilestream (accès aux flux de fichiers)
TStringStream (traite les données de type de chaîne en mémoire)
TMEMORYSTREAM (pour le traitement des données de la mémoire de la mémoire)
TBlobStream (traitement des données des champs de type blob)
TwinsocketStream (traitement et traitement de l'écriture de socket)
Tolestream (traitement des données de l'interface COM)
Tresourcestream (traitement des flux de fichiers de ressources)
La classe la plus couramment utilisée est la classe TFilestream. Pour accéder aux fichiers à l'aide de la classe TFileStream, vous devez d'abord créer une instance. La déclaration est la suivante:
ConstructorCreate (ConstFileName: String; Mode: Word);
Le nom de fichier est le nom de fichier (y compris le chemin)
Le mode est le moyen d'ouvrir un fichier.
Mode ouvert:
fmcreate: créez un fichier avec le nom de fichier spécifié et ouvrez-le si le fichier existe déjà.
fmOpenRead: ouvrez le fichier spécifié en lecture seule
FMOpenWrite: Ouvrez le fichier spécifié de manière écrite uniquement
fmOpenReadWrite: Ouvrez le fichier spécifié en mode d'écriture
Mode de partage:
FMShareCompat: Le mode partagé est compatible avec FCBS
FMSHAREEExclusif: Aucun autre programme n'est autorisé à ouvrir le fichier de quelque manière que ce soit
fmsharedenywrite: aucun autre programme n'est autorisé à ouvrir le fichier par écrit
fmsharedenyread: aucun autre programme n'est autorisé à ouvrir le fichier en mode lecture
fmsharedenynone: d'autres programmes peuvent ouvrir le fichier de quelque manière que ce soit
(Iii) Fichier de ressources
1) Créer des fichiers de ressources
Créez d'abord un fichier texte brut de .rc.
Format: Nom du fichier de ressources de mot-clé identifiant de ressource
Identifiant de ressources: une étiquette spéciale lors de l'appel d'une ressource dans le programme;
Mots-clés: identifier le type de fichier de ressources;
WAVE: Le fichier de ressources est un fichier son;
Rcdata: fichier jpeg;
Avi: Avi Animation;
Icône: fichier d'icône;
Bitmap: fichier bitmap;
Curseur: fichier de curseur;
EXEFILE: fichier exe
Nom du fichier de ressources: le nom complet du fichier stocké sur le disque du fichier de ressources
Par exemple:
myzjyexefilezjy.exe
2) Compiler les fichiers de ressources
Sous / bin du répertoire d'installation de Delphi, utilisez BRCC32.exe pour compiler le fichier de ressources.rc. Bien sûr, vous pouvez également copier BRCC32 dans le répertoire de document du programme séparément pour une utilisation.
Par exemple:
BRCC32WNHOO_REG.RC
3) Référence du fichier de ressources
…
Mise en œuvre
{$ R * .dfm}
{$ Rwnhoo_reg.res}
…
4) Appelez les fichiers de ressources
(1) accéder au bitmap dans le fichier de ressources (bitmap)
Image.Picture.Bitmap.Handle: = LoadBitmap (Hinstance, «Resource Identifier»);
Remarque: Si le bitmap n'est pas chargé avec succès, le programme sera toujours exécuté, mais l'image ne sera plus affichée. Vous pouvez juger si la charge est réussie en fonction de la valeur de retour de la fonction LoadBitmap.
Une autre méthode pour accéder et afficher le bitmap est la suivante
Image.Picture.bitmap.LoadFroMresourceName (Hinstance, «Resource Identifier»);
(2) accéder au curseur dans le fichier de ressources
Screen.cursors [] est un tableau de curseur. Étant donné que la valeur d'index du curseur par défaut dans le tableau est de 0, il est préférable de définir la valeur d'index du curseur personnalisé sur 1, sauf si vous souhaitez remplacer le curseur par défaut.
Screen.Cursors [1]: = LoadCursor (Hinstance, «Resource Identifier»);
Image.cursor: = 1;
(3) Icônes d'accès dans les fichiers de ressources
La mise en place de l'icône dans le fichier de ressources vous permet de modifier dynamiquement l'icône de l'application.
application.icon.handle: = LoadIcon (Hinstance, «Resource Identifier»);
(4) accéder à l'AVI dans le fichier de ressources
Animate.resname: = 'myavi'; // numéro d'identifiant de ressource
Animate.active: = true;
(5) Accéder à JPEG dans le fichier de ressources
Ajoutez l'unité JPEG à l'unité d'utilisation.
var
FJPG: TJPEGIMAGE;
Fstream: tresourcestream;
Commencer
Fjpg: = tjpegimage.create;
// Utilisation de Tresourcestream
Fstream: = tresourcestream.create (hinstance, «Resource Identifier», type de ressource);
Fjpg.loadFromStream (fstream);
Image.picture.bitmap.assign (fjpg);
(6) l'onde d'accès dans le fichier de ressources
Ajouter MMSystem à l'unité USE
PlaySound (pChar ('mywav'), hinstance, snd_asyncorsnd_memoryorsnd_resource);
(Iv) opération de fichiers INI
(1) Structure du fichier INI:
; Ceci est la section des commentaires sur le fichier INI
[nœud]
Mot-clé = valeur
...
Le fichier INI permet plusieurs nœuds et chaque nœud permet plusieurs mots clés. Le fichier INI, la vraie valeur booléenne est représentée par 1 et la valeur fausse booléenne est représentée par 0). Les commentaires commencent par un point-virgule ";".
(2) le fonctionnement du fichier INI
1. Ajouter des inifiles à la section Utilisation de l'interface;
2. Ajoutez une ligne à la partie de définition de la variable VAR: Inifile: tinifile; alors, vous pouvez créer, ouvrir, lire, écrire et d'autres opérations sur le myinifile variable.
3. Ouvrez le fichier INI: Inifile: = tinifile.create ('tmp.ini');
4. Lisez la valeur du mot-clé:
a: = inifile.readString («node», «mot-clé», valeur par défaut);
b: = inifile.readInteger ('nœud', 'keyword', valeur par défaut); // type entier
c: = inifile.readbool («nœud», «mot-clé», valeur par défaut);
Où [par défaut] est la valeur par défaut renvoyée lorsque le mot clé n'existe pas dans le fichier INI.
5. Écrivez dans le fichier INI:
inifile.writeString ('node', 'clé clé', variable ou valeur de chaîne);
inifile.writeInteger ('node', 'keyword', variable ou entier de valeur);
inifile.writebool ('node', 'keyword', variable ou vrai ou false);
Lorsque le nœud de ce fichier INI n'existe pas, l'instruction ci-dessus créera également automatiquement le fichier INI.
6. Supprimer les mots clés:
inifile.deleteKey ('node', 'keyword'); // mot-clé supprime
inifile.érasessection ('nœud'); // Retrait du nœud
7. Fonctionnement du nœud:
inifile.readsection ('node', variable tStrings); // tous les noms de mots clés de la section spécifiée peuvent être lus dans une variable de liste de chaînes;
Inifile.readSections (variable TStrings); // Vous pouvez lire tous les noms de sous-section dans le fichier INI dans une variable de liste de chaînes.
Inifile.readSectionValues ('node', variable tStrings); // toutes les lignes (y compris les mots clés, =, valeurs) dans la section spécifiée dans le fichier INI peuvent être lues dans une variable de liste de chaînes.
8. Libération: Inifile.Distory; ou Inifile.Free;
(V) Relation de document
usages
Registre, Shlobj;
// réalise l'inscription connexe
procéduretmyzip.regzzz;
var
Reg: Tregistry;
Commencer
Reg: = Tregistry.Create;
reg.rootkey: = hkey_classes_root;
reg.openKey ('. Zzz', true);
reg.writeString ('', 'myzip');
reg.closekey;
reg.openkey ('myzip / shell / open / commande', true);
// Programme exécutable utilisé pour ouvrir des fichiers .zzz
reg.writeString ('', '' '+ application.exename +' ""% 1 "');
reg.closekey;
reg.openKey ('myzip / defaultIcon', true);
// s'il vous plaît l'icône du programme exécutable actuel comme l'icône du fichier .zzz
reg.writeString ('', '' + application.exename + ', 0');
reg.free;
// actualiser maintenant
Shchangenotify (shcne_assocchanged, shcnf_idlist, nil, nil);
fin;
2.3
1. Générer un fichier crypté temporaire INI
Format de fichier temporaire pour INI pour le cryptage:
[File1] // nœud, le chiffrement multi-fichiers peut être réalisé à l'aide de file1..n dans le logiciel
FileName = nom de fichier compressé
Mot de passe = mot de passe de décompression
FileSize = Taille du fichier
Filedate = Créer Date
Isjm = est-il nécessaire de décompresser?
Si vous implémentez le stockage d'informations de plusieurs fichiers et dossiers, vous pouvez stocker le mot-clé de mot de passe sous un nœud total. Cet article n'implémente que le chiffrement d'un seul fichier, donc tant que le format ci-dessus est suffisant.
2. Mergez le fichier de données avec le fichier INI utilisé pour le chiffrement, qui peut être implémenté sous la forme d'un flux de fichiers.
Diagramme de structure de fichiers chiffrés:
Figure (1)
Figure (2)
Les deux formes ci-dessus peuvent être utilisées en fonction des conditions réelles. Cet article adopte la structure de la figure (1).
3. Pour les données cryptées, la technologie ZLIB est utilisée pour réaliser un stockage compressé et générer de nouveaux fichiers compressés.
2.4.
2.5
1 et 1 Créez un fichier de programme exécutable spécifiquement à partir de décompression
2 Créer des fichiers de ressources dans 1
3 et 3 Mettez le fichier de ressources dans le programme de cet outil de compression dans cet article et compilez-le ensemble.
4 Générez un fichier auto-extrait en fusionnant le fichier de ressources avec le fichier compressé.
Diagramme de structure de fichiers auto-extrait:
5 Implémentation d'auto-décompression: en décomposant les données compressées cruptées dans son propre fichier, puis en décompressant les données compressées cryptées décomposées à nouveau et en décomposant le fichier de données réel.
2.6 Programmation système
Ceci est tout le code de la partie principale de cette implémentation de logiciel, et nous expliquerons ici tous les détails techniques de ce logiciel en détail.
//wnhoo_zzz.pas
unitwnhoo_zzz;
interface
usages
Windows, formulaires, sysutils, classes, zlib, registre, inifiles, dialogs, shlobj;
taper
pass = string [20];
taper
Tmyzip = classe
Privé
{privéClatationalShere}
protégé
{ProtectedDeclarationShere}
publique
ProcédureRegzzz;
procédures_file (infilename, outFileName: chaîne; mot de passe: pass; isjm: boolean; ysbz: entier);
functionjy_file (infilename: string; mot de passe: pass = ''): boolean;
procédurezjywj (varFileName: String);
ConstructorCreate;
destructordestroy; remplacer;
{publicDeclaationShere}
publié
{PubliagedDeclarationShere}
fin;
Mise en œuvre
ConstructOrTMyzip.Create;
Commencer
hérité de création; // initialiser la partie héritée
fin;
// ################################################## #################################################### ############################ ####
// cryptage de fichiers d'origine
procédurejm_file (vFile: string; vartarget: tmeMoryStream; mot de passe: pass; isjm: booléen);
{
VFILE: fichier crypté
cible: flux cible de sortie après chiffrement 》》》》》
Mot de passe: mot de passe
ISJM: Est-il crypté?
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ------ -----------------
Taille de fichier chiffré = taille du fichier d'origine + [INI Fichier d'informations compressées chiffrées] Taille + Taille Stockage du type de données de taille de [INI Crypted Compressé Fichier d'informations]
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ------ ----------------------
}
var
TMPSTREAM, INSTRUCTION: TFileStream;
Files Size: Integer;
Inifile: tinifile;
nom de fichier: String;
Commencer
// L'ouverture nécessite [fichier comprimé chiffré]
tmpStream: = tFilestream.create (vFile, fmOpenReadorfmShareExclusive);
essayer
// Écrivez [flux de fichiers d'origine] à la fin du flux de fichiers compressé chiffré temporaire]
Target.seek (0, sofromend);
Target.CopyFrom (tmpStream, 0);
// Obtenez le chemin du fichier et générez [Fichier d'informations compressé INI crypté]
FileName: = extractFilePath (paramstr (0)) + 'tmp.in_';
Inifile: = tinifile.create (nom de fichier);
inifile.writeString ('file1', 'filename', extractFileName (vFile));
inifile.writeString ('file1', 'mot de passe', mot de passe);
Inifile.writeInteger ('File1', 'FileSize', Target.Size);
Inifile.writeDateTime ('File1', 'Filedate', Now ());
inifile.writebool ('file1', 'isjm', isjm);
Inifile.recred;
// Lire dans [INI Crypted Comprestic Information File Stream]
instream: = tFileStream.create (nom de fichier, fmOpenReadorfmShareExclusive);
essayer
// Continue à ajouter [INI Crypted Compressé Fichier d'informations compressé] à la fin du [flux de fichiers compressé temporaire crypté]
instream.position: = 0;
Target.seek (0, sofromend);
Target.CopyFrom (inistream, 0);
// Calculez la taille du fichier d'informations compressé Current [INI Crypted]
FileSize: = inSistream.Size;
// Continuez à ajouter les informations de taille du fichier d'informations compressées crypté INI] à la fin du [fichier chiffré temporaire]
Target.WriteBuffer (FileSize, sizeof (Filesize));
Enfin
instream.free;
DeleteFile (nom de fichier);
fin;
Enfin
tmpStream.free;
fin;
fin;
// ************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** *************************** ***************
// compression de débit
procédures_stream (InsideRam, Outstream: tStream; ysbz: entier);
{
Instream: flux de fichiers crypté à comprimer
Flux de fichiers de sortie de compression en dehors
YSBZ: Norme de compression
}
var
YS: TCompressionsstream;
Commencer
// Le pointeur de flux pointe vers la tête
instream.position: = 0;
// Sélection des normes de compression
casbzof
1: ys: = tcompressionstream.create (clnone, outream); // non compressé
2: ys: = tcompressionstream.create (clôtual, en outre); // compression rapide
3: ys: = tcompressionstream.create (cldefault, outream); // compression standard
4: ys: = tcompressionstream.create (clmax, en outre); // compression maximale
autre
ys: = tCompressionsStream.Create (ClFastest, Outstream);
fin;
essayer
// flux de compression
Ys.CopyFrom (InsideRam, 0);
Enfin
ys.free;
fin;
fin;
// ************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** *************************** *********************
// Décompression du flux
ProcédureJy_stream (InsideRam, Outstream: tStream);
{
Insile: fichier de flux compressé d'origine
en dehors: dézip le fichier de streaming
}
var
Jyl: Tdecompressionsstream;
Buf: Array [1..512] ofByte;
Sjread: entier;
Commencer
instream.position: = 0;
jyl: = tdecompressionsstream.create (instream);
essayer
répéter
// Lire la taille réelle
sjread: = jyl.read (buf, sizeof (buf));
ifsjread> 0ment
Outstream.write (buf, sjread);
jusqu'à (sjread = 0);
Enfin
jyl.free;
fin;
fin;
// ************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** **************************************************** *************************** ***************
// réalise l'inscription connexe
procéduretmyzip.regzzz;
var
Reg: Tregistry;
Commencer
Reg: = Tregistry.Create;
reg.rootkey: = hkey_classes_root;
reg.openKey ('. Zzz', true);
reg.writeString ('', 'myzip');
reg.closekey;
reg.openkey ('myzip / shell / open / commande', true);
// Programme exécutable utilisé pour ouvrir des fichiers .zzz
reg.writeString ('', '' '+ application.exename +' ""% 1 "');
reg.closekey;
reg.openKey ('myzip / defaultIcon', true);
// s'il vous plaît l'icône du programme exécutable actuel comme l'icône du fichier .zzz
reg.writeString ('', '' + application.exename + ', 0');
reg.free;
// actualiser maintenant
Shchangenotify (shcne_assocchanged, shcnf_idlist, nil, nil);
fin;
// Compressant les fichiers
procéduretmyzip.ys_file (infilename, outFileName: chaîne; mot de passe: pass; isjm: boolean; ysbz: entier);
{
infiLename: // Les fichiers cryptés doivent être compressés
outFileName: // compresser le fichier généré après cryptage
mot de passe: // non compresser le mot de passe
YSBZ: // Norme de compression
}
var
Insile: TMemoryStream; // Stream temporaire après cryptage de fichiers
en dehors: TFilestream; // Stream de fichier de sortie de compression
Commencer
// Créer [Stream temporaire après cryptage de fichiers]
Instream: = tmeMoryStream.Create;
// cryptage de fichiers
JM_FILE (infilename, insistème, mot de passe, isjm);
// Créer un flux de fichiers de sortie compressé
Outstream: = tFileStream.Create (outFileName, fmcreate);
essayer
// [flux temporaire après cryptage de fichiers] compression
ys_stream (instream, Outstream, ysbz);
Enfin
Strestream.recref;
enterream.free;
fin;
fin;
// Décompressez le fichier
functiontmyzip.jy_file (infilename: string; mot de passe: pass = ''): boolean;
var
Instream, InsideRam, FileStream_OK: tFileStream;
{
Instream: // unzip nom de fichier
instream: // INI Temporary File Stream
filestream_ok: // dézippe le fichier ok
}
en dehors: tmemorystream; // flux de mémoire temporaire
Inifile: tinifile; // Fichier INI temporaire
Files Size: entier; // Taille du fichier de mot de passe
ResultValue: Boolean; // Valeur de retour
Commencer
essayer
instream: = tFilestream.create (infiLename, fmOpenRead);
essayer
Outstream: = TMemoryStream.Create;
essayer
JY_Stream (Instream, Outstream);
// générer un fichier INI temporaire
instream: = tFilestream.create (extractFilePath (paramstr (0)) + 'tmp.in _', fmcreate);
essayer
// pointer la position variable de type entier qui stocke les informations décodées
Outstream.seek (-sizeof (file size), sofromend);
// Lire dans des informations variables
Outstream.readbuffer (FileSize, sizeof (fileSize));
// indique l'emplacement des informations décodées
Outstream.seek (- (fileSize + sizeof (fileSize)), sofromend);
// Lire les informations décodées dans le flux INI
instream.copyFrom (OutStream, FileSize);
// Libérez le flux de fichiers INI
instream.free;
// Lire les informations du fichier INI
Inifile: = tinifile.create (extractFilePath (paramstr (0)) + 'tmp.in_');
resultValue: = Inifile.readbool ('file1', 'isjm', false);
ifresultvaluéthan
Commencer
ifinifile.readString ('file1', 'mot de passe', '') = trim (mot de passe) puis
ResultValue: = True
autre
resultValue: = false;
fin
autre
resultValue: = true;
ifresultvaluéthan
Commencer
filestream_ok: = tFilestream.create (extractFilePath (paramstr (1)) + inifile.readstring ('file1', 'filename', 'wnhoo.zzz'), fmcreate);
essayer
Outstream.Position: = 0;
filestream_ok.copyFrom (outremeam, inifile.readInteger ('file1', 'filesize', 0));
Enfin
filestream_ok.free;
fin;
fin;
Inifile.recred;
Enfin
// Supprimer le fichier INI temporaire
DeleteFile (ExtractFilePath (paramstr (0)) + 'tmp.in_');
fin;
//
Enfin
Strestream.recref;
fin;
Enfin
instream.free;
fin;
sauf
resultValue: = false;
fin;
Résultat: = resultValue;
fin;
// Création de soi
ProcédureEtMyzip.zjywj (varFileName: String);
var
myres: trsourcestream; // stocker temporairement le fichier exe auto-extrait
MyFile: TFilestream; // flux de fichiers d'origine
xfilename: chaîne; // nom de fichier temporaire
file_ok: tmemorystream; // le flux de mémoire du fichier généré
Files size: entier; // Taille du fichier d'origine
Commencer
IffileExists (nom de fichier) puis
Commencer
// Créer un flux de mémoire
file_ok: = tmemorystream.create;
// Libérez le fichier de ressources - auto-extraire le fichier exe
myres: = tresourcestream.create (hinstance, 'myzjy', phar ('exefile'));
// Lire le fichier d'origine en mémoire
MyFile: = tFileStream.Create (nom de fichier, fmOpenRead);
essayer
Myres.position: = 0;
file_ok.copyFrom (myres, 0);
file_ok.seek (0, sofromend);
MyFile.Position: = 0;
file_ok.copyFrom (myFile, 0);
file_ok.seek (0, sofromend);
FileSize: = myFile.size;
file_ok.writeBuffer (FileSize, sizeof (FileSize));
file_ok.position: = 0;
xFileName: = ChangeFileExt (FileName, '. EXE');
file_ok.savetofile (xFileName);
Enfin
MyFile.Free;
Myres.Free;
file_ok.free;
fin;
DeleteFile (nom de fichier);
FileName: = xFileName;
fin;
fin;
// ################################################## #################################################### ############################ ####
destructortmyzip.destroy;
Commencer
hérité destroy;
fin;
fin.
3. Conclusion
Le nouvel environnement de programmation visuelle de Delphi nous offre un outil de développement d'applications Windows pratique et rapide. Pour les développeurs de programmes, l'utilisation de Delphi pour développer des logiciels d'application améliorera sans aucun doute considérablement l'efficacité de la programmation. À Delphi, vous pouvez facilement utiliser des flux pour implémenter divers formulaires de données tels que le traitement de fichiers, le traitement de la mémoire dynamique, le traitement des données réseau, etc., et les programmes d'écriture amélioreront considérablement l'efficacité.
Références:
1. Aide du système Delphi
2. Feng Zhiqiang.
3. Chen Jingtao.