Verwenden Sie Delphi, um die Dateiverschlüsselung und Komprimierung zu implementieren

Autor：Eve Cole Aktualisierungszeit：2025-02-25 07:00:02

Autor: E Mengyuan (Wnhoo)

Liebe und Liebe

Klicken Sie hier, um diese detaillierte Beschreibungsdatei herunterzuladen

Überblick:

In diesem Dokument werden wir über die Implementierung von Datenverschlüsselung, Datenkomprimierung und Selbstwechselkompression einer einzelnen Datei sprechen. In ähnlicher Weise kann die Komprimierung mehrerer Dateien oder Ordner mit einer leichten Änderung erreicht werden.

Schlüsselwörter: verschlüsselte Komprimierung, ZLIB, Stream, Ressourcendateien

Einführung:

Im täglichen Leben müssen wir berühmte Komprimierungssoftware wie Winzip und Winrar verwendet haben, was bedeutet, dass wir unweigerlich auf Probleme wie Datenverschlüsselung und Datenkomprimierung während des Softwareentwicklungsprozesses stoßen werden! In diesem Artikel wird dieses technische Problem erörtert und dank aller Internetnutzer für ihre Fähigkeiten. Dieser Artikel verwendet hauptsächlich Delphs leistungsstarke Stromverarbeitungsfähigkeiten, um die Datenverschlüsselung und -komprimierung zu erreichen, und wird in der tatsächlichen Softwareprogrammentwicklung verwendet.

1. Systemfunktionen

1) Datenkomprimierung

Verwenden Sie zwei von Delphi (tCompressionSions und TDeCompressionStream) bereitgestellte Stream -Klassen, um die Komprimierung und Dekompression von Daten zu vervollständigen.

2) Datenverschlüsselung und Komprimierung

Die Datenverschlüsselung wird durch die Anwendung von "Stream" in der Delphi -Programmierung realisiert, hauptsächlich unter Verwendung von TFileStream und Tmemorystream, zwei abgeleiteten Klassen von TStream.

3) Doppelklicken Sie auf die komprimierte Datei, um automatisch zu assoziieren und zu dekomprimieren

Durch Ändern der Assoziation der Registrierungserweiterung mit Programmdateien wird hauptsächlich die Tregistry verwendet.

4) können selbsterrextrahierende Dateien generieren

Die selbst dekomprimierte Datei realisiert die automatische Dekompression der Datenkomprimierung 1) und die Datenverschlüsselungskomprimierung 2) und durch die Verwendung von Ressourcendateien wird die Selbstdekompression von Daten realisiert, um die ausführbare Selbstvertiefungsdatei und die Datendatei und die Datendatei zu erreichen, und Datendatei und Datendatei und Datendatei, und Datendateien, die Datendatei und Datendatei erhalten. Die Selbstwechselkompression von Daten wird erreicht.

2. Systemimplementierung

2.1

2.2.

(I) Zlib

1) Basisklasse Tcustomzlibstream: Ist die Basisklasse der T -Compressions -Stream- und TDecompressions -Klassen hauptsächlich eine Eigenschaft.

Format: procedureonProgress (Absender: tobject); dynamisch;

2) Komprimierungsklasse -T -Compressionsstream: Zusätzlich zur Erbscheibe der On -Progress -Eigenschaft der Basisklasse wird ein weiteres Attribut hinzugefügt: Komprimierung, das wie folgt definiert ist:

PropertyCompressionRate: SingleleAdgetCompressionRate;

Durch diese Eigenschaft kann das Kompressionsverhältnis erhalten werden.

Mehrere wichtige Methoden werden wie folgt definiert:

ConstructortCompressionsTream.create (komprimierende: tCompressionLevel; dest: tstream);

Unter ihnen: tCompressionLevel (Komprimierungstyp), wird es durch Folgendes definiert:

1) Clnone: Es wird keine Datenkomprimierung durchgeführt;

2) Clastest: führt eine schnelle Komprimierung durch und opfert die Komprimierungseffizienz;

3) CLDEFAULT: Normale Komprimierung durchführen;

4) Clmax: Maximieren Sie die Druck- und Opfergeschwindigkeit;

Dest: Zielstrom, das zum Speichern von komprimierten Daten verwendet wird.

FunctionTCompressionsstream.write (constbuffer; count: longint): longint;

Unter ihnen: Puffer: Daten, die komprimiert werden müssen;

Zählung: Die Anzahl der zu komprimierten Datenbytes;

Die Funktion gibt die Anzahl der in den Stream geschriebenen Bytes zurück.

HINWEIS: Die Daten der komprimierten Klasse -T -Compressionsstream können nur geschrieben werden. Die Daten, die komprimiert werden müssen, werden über die Methode -Schreibmethode in den Stream geschrieben und während des Schreibprozesses komprimiert und im Speicherstrom (tmemoryStream) gespeichert, der vom Konstruktor bereitgestellt wird, und das On -Process -Ereignis wird ausgelöst.

3) Dekompressionsklasse TDecompressionsstream: Im Gegensatz zu komprimierten Klasse -T -Komplikten können die Daten nur ausgelesen werden.

Die verschiedenen wichtigen Methoden sind wie folgt definiert:

ConstructorCreate (Quelle: TStream);

Unter ihnen: Quelle ist ein Stream, der komprimierte Daten speichert.

FunktionRead (Varbuffer; Graf: Longint): Longint;

Datenauslesefunktion, Puffer: Datenpuffer speichern;

Die Funktion gibt die Anzahl der Lesebytes zurück. Während des Leseprozesses werden die Daten dekomprimiert und das Onprocess -Ereignis ausgelöst.

(Ii)

In Delphi ist die Basisklasse aller Stream -Objekte die TStream -Klasse, die gemeinsame Eigenschaften und Methoden aller Streams definiert.

Die in der TStream -Klasse definierten Eigenschaften sind wie folgt:

1), Größe: Diese Eigenschaft gibt die Datengröße im Stream in Bytes zurück.

2) Position: Diese Eigenschaft steuert die Position des Zugriffs auf Zeiger im Fluss.

In Tstream sind vier virtuelle Methoden definiert:

1) Lesen Sie: Diese Methode implementiert das Lesen von Daten aus dem Stream, und der Rückgabewert ist die tatsächliche Anzahl der gelesenen Bytes, die geringer oder gleich dem angegebenen Wert sein können.

2) Schreiben: Diese Methode implementiert das Schreiben von Daten in den Stream, und der Rückgabewert ist die Anzahl der tatsächlich in den Stream geschriebenen Bytes.

3) Suchen: Diese Methode erkennt die Bewegung des Lesezeigers im Stream, und der Rückgabewert ist die Position des Zeigers nach der Bewegung.

Der Funktionsprototyp ist: FunctionSeek (Offset: Longint; Origint: Wort): Longint; virtuell; Abstract;

Der Parameter -Offset ist die Anzahl der Offset -Bytes.

SOFROMBEGINNING: Offset sind die Zeigerabstandsdaten starten. Zu diesem Zeitpunkt muss der Versatz größer oder gleich Null sein.

AFROMCurrent: Der Offset ist die relative Position des Zeigers und des aktuellen Zeigers nach dem Umzug.

AFROMEND: Der Offset ist die Position, in der die Zeigerabstandsdaten nach dem Umzug endet. Zu diesem Zeitpunkt muss der Offset kleiner oder gleich Null sein.

4) setSize: Diese Methode realisiert die Änderung der Größe der Daten.

Darüber hinaus sind in der TStream -Klasse mehrere statische Methoden definiert:

1) ReadBuffer: Die Funktion dieser Methode besteht darin, Daten aus der aktuellen Position im Stream zu lesen, die wie die oben gelesenen Lesen.

HINWEIS: Wenn sich die Anzahl der gelesenen Bytes von der Anzahl der zu gelesenen Bytes unterscheidet, wird eine EREADError -Ausnahme generiert.

2) WriteBuffer: Die Funktion dieser Methode besteht darin, Daten am aktuellen Standort in den Stream zu schreiben, das gleiche wie die obigen Schreiben.

Hinweis: Wenn sich die Anzahl der in Daten geschriebenen Bytes von der Anzahl der zu schriftlichen Bytes unterscheidet, wird eine EwriteError -Ausnahme generiert.

3) CopyFrom: Die Funktion dieser Methode besteht darin, Datenströme aus anderen Streams zu kopieren.

Der Funktionsprototyp ist: functionCopyFrom (Quelle: TStream; Count: Longint): Longint;

Die Parameterquelle ist der Stream, der Daten bereitstellt, und die Anzahl der kopierten Datenbytes. Wenn die Anzahl größer als 0 ist, kopieren Sie die Kopien von Daten Bytes von Daten aus der aktuellen Position des Quellparameters.

Häufig abgeleitete Klassen von Tstream:

TFileStream (Zugriff auf Dateiströme)

Tstringstream (verarbeitet String -Typdaten im Speicher)

TmemoryStream (für Datenverarbeitung für Arbeitsspeicherbereiche)

Tblobstream (Datenverarbeitung von Feldern vom Typ Blob)

TwinSocketstream (Lesen und Schreiben von Socket)

Tolestream (Datenverarbeitung der COM -Schnittstelle)

Tresourcestream (Verarbeitung von Ressourcendateiströmen)

Das am häufigsten verwendete ist die TFilESTREAM -Klasse. Um über die TFilESTREAM -Klasse auf Dateien zugreifen zu können, müssen Sie zunächst eine Instanz erstellen. Die Aussage lautet wie folgt:

ConstructorCreate (constFileName: String; Modus: Wort);

Dateiname ist der Dateiname (einschließlich Pfad)

Der Modus ist der Weg, um eine Datei zu öffnen.

Offener Modus:

FMCreate: Erstellen Sie eine Datei mit dem angegebenen Dateinamen und öffnen Sie sie, wenn die Datei bereits vorhanden ist.

FMOPENREAD: Öffnen Sie die angegebene Datei in der schreibgeschützten Schreibweise

FMOPENWRITE: Öffnen Sie die angegebene Datei auf eine Weise nur Schreib-

fMopenReadwrite: Öffnen Sie die angegebene Datei im Schreibmodus

Sharing -Modus:

FMSharecompat: Der gemeinsame Modus ist mit FCBS kompatibel

fmShareExClusive: Keine anderen Programme dürfen die Datei in irgendeiner Weise öffnen

FMSHARDENYWRITE: Keine anderen Programme dürfen die Datei schriftlich öffnen

FMSHARDENYREAD: Keine anderen Programme dürfen die Datei im Lesemodus öffnen

FMSHARDENYNONE: Andere Programme können die Datei in irgendeiner Weise öffnen

(Iii) Ressourcendatei

1) Ressourcendateien erstellen

Erstellen Sie zuerst eine einfache Textdatei von .rc.

Format: Ressourcenkennerschlüsselwort Ressourcendateiname

Ressourcenkennung: Ein spezielles Etikett beim Aufrufen einer Ressource im Programm;

Schlüsselwörter: Identifizieren Sie den Ressourcen -Dateityp;

WAVE: Die Ressourcendatei ist eine Tondatei.

RCDATA: JPEG -Datei;

AVI: AVI -Animation;

Symbol: Symboldatei;

Bitmap: Bitmap -Datei;

Cursor: Cursordatei;

EXEFILE: EXE -Datei

Ressourcenfile Name: Der vollständige Name der auf der Festplatte der Ressourcendatei gespeicherten Datei

Zum Beispiel:

myzjyexefilezjy.exe

2) Ressourcendateien kompilieren

Unter /bin des Delphi -Installationsverzeichnisses verwenden Sie BRCC32.exe, um die Ressourcendatei zu kompilieren. Natürlich können Sie auch BRCC32 für die Verwendung separat in das Programmdokumentverzeichnis kopieren.

Zum Beispiel:

BRCC32WNHOO_reg.rc

3) Ressourcendateireferenz

…

Durchführung

{$ R*.dfm}

{$ Rwnhoo_reg.res}

…

4) Rufen Sie Ressourcendateien auf

(1) Greifen Sie in der Ressourcendatei (BitMap) auf die Bitmap zu.

Image.Picture.BitMap.Handle: = loadbitmap (Hinstance, 'Ressourcenkennung');

Hinweis: Wenn die Bitmap nicht erfolgreich geladen wird, wird das Programm weiterhin ausgeführt, das Bild wird jedoch nicht mehr angezeigt. Sie können beurteilen, ob die Last auf der Grundlage des Rückgabewerts der Loadbitmap-Funktion erfolgreich ist.

Eine andere Methode zum Zugriff auf und zum Anzeigen von Bitmap ist wie folgt

Image.Picture.bitmap.loadfromResourcename (Hinstance, 'Ressourcenkennung');

(2) Zugriff auf den Cursor in der Ressourcendatei

Screen.Cursors [] ist ein Cursorarray. Da der Standard -Cursor -Indexwert im Array 0 beträgt, ist es am besten, den benutzerdefinierten Cursor -Indexwert auf 1 einzustellen, es sei denn, Sie möchten den Standard -Cursor ersetzen.

Screen.cursors [1]: = loadCursor (Hinstance, 'Ressourcenkennung');

Bild.Cursor: = 1;

(3) Zugriffsymbole in Ressourcendateien zugreifen

Wenn Sie das Symbol in die Ressourcendatei einfügen, können Sie das Anwendungssymbol dynamisch ändern.

application.icon.Handle: = loadicon (Hinstance, 'Ressourcenkennung');

(4) Zugriff auf die AVI in der Ressourcendatei

Animate.resname: = 'myavi'; // Ressourcenkennung Nummer

Animate.active: = true;

(5) Zugriff auf JPEG in der Ressourcendatei

Fügen Sie die JPEG -Einheit in die Verwendungseinheit hinzu.

var

FJPG: Tjpegimage;

Fstream: Tresourcestream;

Beginnen

Fjpg: = tjpegimage.create;

// Tresourcestream -Verwendung

Fstream: = tresourcestream.create (Hinstance, 'Ressourcenidentifier', Ressourcentyp);

Fjpg.loadfromstream (fstream);

Image.Picture.bitmap.assign (FJPG);

(6) Zugriffswelle in der Ressourcendatei zugreifen

Fügen Sie MMSystem in die Verwendungseinheit hinzu

PlaySound (pchar ('mywav'), hinstance, snd_asyncorsnd_memoryorsnd_resource);

(Iv) INI -Dateioperation

(1) Struktur der INI -Datei:

Dies ist der Kommentarbereich zur INI -Datei

[Knoten]

Keyword = Wert

...

Die INI -Datei ermöglicht mehrere Knoten, und jeder Knoten erlaubt mehrere Schlüsselwörter. Die INI -Datei, der wahre boolesche Wert wird durch 1 dargestellt, und der falsche boolesche Wert wird durch 0 dargestellt). Kommentare beginnen mit einem Semikolon ";".

(2) Betrieb der INI -Datei

1. Fügen Sie dem Verwendungsabschnitt der Schnittstelle Inifiles hinzu;

2. Fügen Sie dem VAR -Variablen -Definitionsteil eine Zeile hinzu: Inifile: Tinifile;

3. Öffnen Sie die INI -Datei: Inifile: = Tinifile.create ('tmp.ini');

4. Lesen Sie den Wert des Schlüsselworts:

A: = Inifile.readString ('Knoten', 'Keyword', Standardwert);

b: = inifile.readinteger ('node', 'keyword', Standardwert); // Ganzzahltyp

C: = Inifile.Readbool ('Knoten', 'Keyword', Standardwert);

Wobei [Standard] der Standardwert ist, der zurückgegeben wird, wenn das Schlüsselwort in der INI -Datei nicht vorhanden ist.

5. Schreiben Sie an die Ini -Datei:

Inifile.Writestring ('Knoten', 'Keyword', Variable oder String Value);

Inifile.writeIntier ('Knoten', 'Keyword', Variable oder Ganzzahlwert);

Inifile.WriteBool ('Knoten', 'Keyword', Variable oder True oder False);

Wenn der Knoten dieser INI -Datei nicht vorhanden ist, erstellt die obige Anweisung auch automatisch die INI -Datei.

6. Schlüsselwörter löschen:

Inifile.DeleteKey ('Knoten', 'Keyword'); // Schlüsselwort löschen

Inifile.erasesection ('Knoten'); // Knotenentfernung

7. Knotenbetrieb:

Inifile.readSection ('Knoten', TStrings Variable); // Alle Schlüsselwortnamen im angegebenen Abschnitt können in eine String -List -Variable gelesen werden.

Inifile.ReadSections (TStrings -Variable); // Sie können alle Unterabschnittsnamen in der INI -Datei in eine String -List -Variable lesen.

Inifile.ReadSectionValues ('Knoten', TStrings Variable); // Alle Zeilen (einschließlich Schlüsselwörter, =, Werte) im angegebenen Abschnitt in der INI -Datei können in eine String -List -Variable gelesen werden.

8. Release: Inifile.Distory;

(V) Dokumentbeziehung

Verwendung

Registrierung, Shlobj;

// Verwandte Registrierung erkennen

proceduretmyzip.regzzz;

var

Reg: Tregistry;

Beginnen

reg: = tregistry.create;

Reg.Rootkey: = hkey_classes_root;

Reg.openkey ('. Zzz', wahr);

Reg.Writestring ('', 'Myzip');

Reg.Closekey;

reg.openkey ('myzip/Shell/open/command', true);

// ausführbares Programm zum Öffnen von .zzz -Dateien

Reg.Writestring ('', '' '+Application.Exename+' "%1" ');

Reg.Closekey;

reg.openkey ('myzip/defaulticon', true);

// Bitte das Symbol des aktuellen ausführbaren Programms als Symbol der .zzz -Datei

Reg.Writestring ('', ''+Application.Exename+', 0');

Reg.Free;

// Jetzt aktualisieren

ShchangeNotify (shcne_assocchanged, shcnf_idlist, nil, nil);

Ende;

2.3.

1. Generieren Sie ini Temporärer verschlüsselter Datei

Temporäres Dateiformat für INI zur Verschlüsselung:

[Datei1] // Knoten, multi-file-Verschlüsselung kann unter Verwendung von Datei1..N in der Software erreicht werden

Dateiname = komprimierter Dateiname

Passwort = Dekompression Passwort

FileSize = Dateigröße

Fileedate = Datum erstellen

Isjm = ist es notwendig, zu dekomprimieren?

Wenn Sie Informationen mehrerer Dateien und Ordner implementieren, können Sie das Kennwortschlüsselwort unter einem Gesamtknoten speichern. Dieser Artikel implementiert nur die Verschlüsselung einer einzelnen Datei, solange das obige Format ausreicht.

2. Zusammenführen der Datendatei mit der für die Verschlüsselung verwendeten INI -Datei, die in Form eines Dateistroms implementiert werden kann.

Verschlüsselter Dateistrukturdiagramm:

Abbildung (1)

Abbildung (2)

Die beiden oben genannten Formen können gemäß den tatsächlichen Bedingungen verwendet werden. Dieser Artikel übernimmt die Struktur von Abbildung (1).

3. Für verschlüsselte Daten wird die ZLIB -Technologie verwendet, um komprimiertes Speicher zu realisieren und neue komprimierte Dateien zu generieren.

2.4. Siehe 2.2 (v) für die Implementierung von Dateiverbänden

2.5

1. Erstellen Sie eine ausführbare Programmdatei speziell aus der Dekompression

2. Erstellen Sie Ressourcendateien in 1

3. Fügen Sie die Ressourcendatei in das Programm dieses Komprimierungstools in diesem Artikel ein und kompilieren Sie sie zusammen.

4. Generieren Sie eine Self-Extrahing-Datei, indem Sie die Ressourcendatei mit der komprimierten Datei zusammenführen.

Self-Extrahing-Dateistrukturdiagramm:

5. Implementierung der Selbstabwehr: Durch die Zerlegung der verschlüsselten komprimierten Daten in seiner eigenen Datei, die Dekomprimierung der zerlegten verschlüsselten komprimierten Daten erneut und zerlegt die reale Datendatei.

2.6 Systemprogrammierung

Dies ist der gesamte Code des Kernteils dieser Software -Implementierung. Hier werden wir alle technischen Details dieser Software im Detail erläutern.

//wnhoo_zzz.pas

UNITWNHOO_ZZZ;

Schnittstelle

Verwendung

Fenster, Formulare, Systeme, Klassen, Zlib, Registrierung, Inifiles, Dialoge, Shlobj;

Typ

Pass = String [20];

Typ

Tmyzip = Klasse

Privat

{privatatedEclarationsshere}

geschützt

{ProtectedDeclarationsshere}

öffentlich

procedureregzzz;

Prozedures_file (Infilename, Outfilename: String; Passwort: Pass; ISJM: boolean; Ysbz: Integer);

FunktionJy_file (Infilename: String; Passwort: pass = ''): boolean;

procedurezjywj (VARFILENAME: STRING);

Konstruktorcreate;

destructorderestroy; überschreiben;

{publicDeclarationsshere}

veröffentlicht

{PublishedDeclarationshere}

Ende;

Durchführung

constructortmyzip.create;

Beginnen

erbte den ererbten Teil inheritedCreate; // initialisieren Sie den ererbten Teil

Ende;

// ################################################################################################################### zu erhalten ####################################################################################################################### zu erhalten ############################ ##########

// Originaldateiverschlüsselung

procedurejm_file (vfile: String; vartarget: tmemoryStream; Passwort: Pass; isjm: boolean);

{

VFILE: Verschlüsselte Datei

Ziel: Ausgangszielstrom nach der Verschlüsselung 》》》》》

Passwort: Passwort

ISJM: Ist es verschlüsselt?

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------ -----------------

Verschlüsselte Dateigröße = Originaldateigröße + [INI verschlüsselte komprimierte Informationsdatei] Größe + Größe Speichern Sie den Größendatentyp von [INI verschlüsselten komprimierten Informationsdatei]

}

var

tmpstream, instrenm: tFileStream;

Dateigröße: Ganzzahl;

Inifile: Tinifile;

Dateiname: String;

Beginnen

// Öffnen erfordert [verschlüsselte komprimierte Datei]

tmpstream: = tFileStream.create (vfile, fMopenReadorfmShareExClusive);

versuchen

// Schreiben Sie [Original -Dateistream] bis zum Ende von [temporär verschlüsselnden komprimierten Dateistrom]]

Target.Seek (0, Sofromend);

Target.copyFrom (tmpstream, 0);

// Erhalten Sie den Dateipfad und generieren Sie [INI verschlüsselte komprimierte Informationsdatei].

Dateiname: = extractFilepath (paramstr (0))+'tmp.in_';

Inifile: = Tinifile.create (Dateiname);

Inifile.Writestring ('Datei1', 'Dateiname', ExtractFileName (VFILE));

Inifile.Writestring ('Datei1', 'Passwort', Passwort);

Inifile.WriteIntier ('Datei1', 'FileSize', target.Size);

inifile.writedAtetime ('file1', 'mailedate', now ());

Inifile.WriteBool ('Datei1', 'isjm', isjm);

Inifile.Free;

// Lesen Sie in [INI verschlüsselt komprimierte Informationsdatei -Stream]

Instreme: = tFilESTREAM.Create (Dateiname, fMopenReadorfmShareExClusive);

versuchen

// Fügen Sie am Ende des [temporären verschlüsselten komprimierten komprimierten Dateistroms] weiter hinzu [INI verschlüsselte komprimierte Informationsdatei]]

instrenm.position: = 0;

Target.Seek (0, Sofromend);

Target.CopyFrom (Inistream, 0);

// Berechnen Sie die Größe des aktuellen [INI verschlüsselten komprimierten Informationsdatei]

FileSize: = Inistream.Size;

// Fügen Sie am Ende der [temporären verschlüsselten Datei

Target.writeBuffer (FileSize, sizeof (fileSize));

Endlich

intream.free;

DeleteFile (Dateiname);

Ende;

Endlich

tmpstream.free;

Ende;

//************************************************************ ******************************************************** ******************************************************** ******************************************************** ******************************************************** ******************************************************** ******************************************************** **********************************************

// Durchflusskomprimierung

Prozedures_Stream (instrenm, überstream: tstream; ysbz: Integer);

{

Anlagebericht: verschlüsselter Dateistrom, der komprimiert werden soll

Überstream -Komprimierungsausgabedatei Stream überstream

YSBZ: Kompressionsstandard

}

var

YS: t Compressionsstream;

Beginnen

// Der Flusszeiger zeigt auf den Kopf

instrenm.position: = 0;

// Auswählen von Komprimierungsstandards

CasesBzof

1: ys: = tCompressionsTream.create (Clnone, überstream); // nicht komprimiert

2: ys: = tCompressionsTream.create (Clastest, außerhalb); // schnelle Komprimierung

3: ys: = tCompressionsstream.create (cldefault, überstream); // Standardkomprimierung

4: ys: = tCompressionsTream.create (Clmax, überstream); // Maximale Komprimierung

anders

ys: = tCompressionsstream.create (Clastest, außerhalb);

Ende;

versuchen

// Komprimierungsstrom

ys.copyFrom (instrenm, 0);

Endlich

Ys.Free;

Ende;

// Fluss -Dekompression

procedurejy_stream (instrenm, außen: tstream);

{

Anlagen: Original komprimierte Stream -Datei

Outstream: Entpacken Sie die Streaming -Datei

}

var

Jyl: tDeCompressionsstream;

BUF: Array [1..512] von Byte;

Sjread: Ganzzahl;

Beginnen

instrenm.position: = 0;

Jyl: = tDeCompressionStream.create (Instreme);

versuchen

wiederholen

// Lesen Sie die tatsächliche Größe

sjread: = jyl.read (buf, sizeof (buf));

ifsjread> 0Then

Outstream.write (buf, sjread);

bis (sjread = 0);

Endlich

jyl.free;

Ende;

// Verwandte Registrierung erkennen

proceduretmyzip.regzzz;

var

Reg: Tregistry;

Beginnen

reg: = tregistry.create;

Reg.Rootkey: = hkey_classes_root;

Reg.openkey ('. Zzz', wahr);

Reg.Writestring ('', 'Myzip');

Reg.Closekey;

reg.openkey ('myzip/Shell/open/command', true);

// ausführbares Programm zum Öffnen von .zzz -Dateien

Reg.Writestring ('', '' '+Application.Exename+' "%1" ');

Reg.Closekey;

reg.openkey ('myzip/defaulticon', true);

// Bitte das Symbol des aktuellen ausführbaren Programms als Symbol der .zzz -Datei

Reg.Writestring ('', ''+Application.Exename+', 0');

Reg.Free;

// Jetzt aktualisieren

ShchangeNotify (shcne_assocchanged, shcnf_idlist, nil, nil);

Ende;

// Dateien komprimieren

proceduretMyzip.ys_file (Infilename, OutfileName: String; Passwort: Pass; isjm: boolean; ysbz: Integer);

{

Infilename: // verschlüsselte Dateien müssen komprimiert werden

OutFileName: // Komprimieren Sie die nach der Verschlüsselung generierte Datei

Passwort: // unkombiges Passwort

YSBZ: // Komprimierungsstandard

}

var

Instreme: tmemoryStream; // Temporärer Strom nach der Dateiverschlüsselung

Outstream: tFilestream; // Ausgangsdateistream komprimieren

Beginnen

// erstellen [temporärer Stream nach der Dateiverschlüsselung]

Anstrom: = tmemoryStream.create;

// Dateiverschlüsselung

JM_FILE (Infilename, Antrieb, Passwort, ISJM);

// Erstellen Sie einen komprimierten Ausgabedatei -Stream

überstream: = tFileStream.create (OutFileName, fmcreate);

versuchen

// [Temporärer Strom nach der Dateiverschlüsselung] Komprimierung

ys_stream (instrenm, außen, ysbz);

Endlich

Überstream.free;

Enterstream.free;

Ende;

// die Datei dekomprimieren

functionTmyzip.jy_file (Infilename: String; Passwort: pass = ''): boolean;

var

Instreme, Antrieb, fileStream_ok: tFileStream;

{

Anlagestab: // Dateiname Unzip

Anlagebericht: // Ini Temporärer Dateistrom

fileStream_ok: // die OK -Datei entpacken

}

Outstream: tmemoryStream; // Temporärer Speicherstrom

Inifile: Tinifile; // Temporäre Ini -Datei

Dateigröße: Ganzzahl; // Größe der Kennwortdatei

resultValue: boolean; // Rückgabewert

Beginnen

versuchen

Instreme: = tFileStream.create (Infilename, fMopenRead);

versuchen

überstream: = tmemoryStream.create;

versuchen

jy_stream (instrenm, außen);

// Temporäre INI -Datei generieren

Instreme: = tFilEstream.create (extractFilepath (Paramstr (0))+'tmp.in _', fmcreate);

versuchen

// Zeigen Sie auf die variable Position des Ganzzahl Typs, die die dekodierten Informationen speichert

Outstream.seek (-Sizeof (fileside), sofromend);

// in variable Informationen lesen

Outstream.readBuffer (FileSize, Sizeof (FileSize));

// Zeigen Sie auf den dekodierten Informationsort

Outstream.seek (-(FileSize+sizeof (fileSize)), sofromend);

// Lesen Sie die dekodierten Informationen in den INI -Stream ein

instream.copyFrom (überstream, filesize);

// INI -Dateistrom veröffentlichen

intream.free;

// Lesen Sie die Ini -Dateiinformationen

Inifile: = Tinifile.create (extractFilepath (paramstr (0))+'tmp.in_');

resultValue: = inifile.readbool ('file1', 'isjm', false);

ifresultvaluethen

Beginnen

ifIniFile.readstring ('Datei1', 'Passwort', '') = trimm (Passwort) dann

resultValue: = true

anders

resultValue: = false;

Ende

anders

resultValue: = true;

ifresultvaluethen

Beginnen

fileStream_ok: = tfileStream.create (extractFilepath (paramstr (1))+inifile.readstring ('file1', 'fileName', 'wnhoo.zzz'), fmcreate);

versuchen

Überstream.position: = 0;

fileStream_ok.copyfrom (überstream, inifile.readinteger ('file1', 'filesize', 0));

Endlich

filestream_ok.free;

Ende;

Inifile.Free;

Endlich

// Temporäre INI -Datei löschen

DeleteFile (ExtractFilePath (Paramstr (0))+'tmp.in_');

Ende;

Endlich

Überstream.free;

Ende;

Endlich

intream.free;

Ende;

außer

resultValue: = false;

Ende;

Ergebnis: = resultValue;

Ende;

// Self-Extract-Schöpfung

procedureEtmyzip.zjywj (varFileName: String);

var

Myres: trSourcestream; // Vorübergehend selbsterrextrahierende EXE-Datei speichern

MyFile: TFilESTREAM; // Original -Dateistream

XFileName: String; // Temporärer Dateiname

Datei_OK: tmemoryStream; // Der Speicherstrom der generierten Datei

Dateigröße: Ganzzahl; // Originaldateigröße

Beginnen

IFFILEExists (Dateiname) dann

Beginnen

// Speicherstrom erstellen

Datei_OK: = tmemoryStream.create;

// die Ressourcendatei freigeben-Selbstverträge der EXE-Datei

Myres: = Tresourcestream.create (Hinstance, 'Myzjy', pchar ('exefile');

// Lesen Sie die Originaldatei in den Speicher

MyFile: = tFilESTREAM.Create (Dateiname, fMopenRead);

versuchen

Myres.Position: = 0;

Datei_ok.copyfrom (Myres, 0);

Datei_OK.seek (0, Sofromend);

myFile.position: = 0;

Datei_ok.copyfrom (MyFile, 0);

Datei_OK.seek (0, Sofromend);

Dateigröße: = myFile.Size;

Datei_ok.writeBuffer (FileSize, SizeOf (FileSize));

Datei_ok.position: = 0;

xFileName: = ChangeFileext (Dateiname, '. exe');

Datei_ok.savetofile (xFileName);

Endlich

MyFile.Free;

Myres.Free;

Datei_ok.free;

Ende;

DeleteFile (Dateiname);

Dateiname: = xFileName;

Ende;

destructortmyzip.destroy;

Beginnen

erbterdestroy;

Ende;

Ende.

3. Schlussfolgerung

Die neue visuelle Programmierumgebung von Delphi bietet uns ein bequemes und schnelles Windows -Anwendungs -Entwicklungstool. Für Programmentwickler wird die Verwendung von Delphi zur Entwicklung von Anwendungssoftware zweifellos die Programmierungseffizienz erheblich verbessern. In Delphi können Sie Streams problemlos verwenden, um verschiedene Datenformulare wie Dateiverarbeitung, dynamische Speicherverarbeitung, Netzwerkdatenverarbeitung usw. zu implementieren, und das Schreiben von Programmen wird die Effizienz erheblich verbessern.

Referenzen:

1. Delphi System Hilfe

2. Feng Zhiqiang.

3. Chen Jingtao.