Gunakan Delphi untuk mengimplementasikan enkripsi dan kompresi file
Penulis: E Mengyuan (Wnhoo)
Mail: [email protected]
Cinta dan cinta
Klik untuk mengunduh file deskripsi terperinci ini
Ringkasan:
Dalam dokumen ini, kita akan berbicara tentang implementasi enkripsi data, kompresi data dan dekompresi diri dari satu file. Demikian pula, kompresi beberapa file atau folder dapat dicapai dengan sedikit modifikasi.
Kata kunci: kompresi terenkripsi, zlib, stream, file sumber daya
perkenalan:
Dalam kehidupan sehari -hari, kita harus menggunakan perangkat lunak kompresi terkenal seperti Winzip dan Winrar, yang berarti bahwa kita pasti akan menghadapi masalah seperti enkripsi data dan kompresi data selama proses pengembangan perangkat lunak! Artikel ini membahas masalah teknis ini, dan juga berkat semua netizen atas keterampilan mereka. Artikel ini terutama menggunakan keterampilan pemrosesan aliran Delph yang kuat untuk mencapai enkripsi dan kompresi data, dan digunakan dalam pengembangan program perangkat lunak yang sebenarnya.
1. Fungsi Sistem
1) Kompresi data
Gunakan dua kelas aliran yang disediakan oleh Delphi (TCompressionstream dan TDecompressionstream) untuk menyelesaikan kompresi dan dekompresi data.
2) Enkripsi dan kompresi data
Enkripsi data direalisasikan melalui penerapan "stream" dalam pemrograman Delphi, terutama menggunakan tfileStream dan tMemorystream, dua kelas tstream yang diturunkan;
3) Klik dua kali file terkompresi untuk secara otomatis mengaitkan dan mendekompresi
Dengan mengubah asosiasi ekstensi registri dengan file program, Tregistry terutama digunakan;
4) dapat menghasilkan file pengekspresikan diri
File yang tidak terkejut diri mewujudkan dekompresi otomatis kompresi data 1) dan kompresi enkripsi data 2); Dekompresi sendiri data tercapai.
2. Implementasi sistem
2.1
2.2.
(I) Zlib
1) TCUSTOMZLIBSTREAM: adalah kelas dasar dari kelas tompresi dan tdecompressionstream.
Format: ProcedureOnprogress (pengirim: Tobject); dinamis;
2) Kelas Kompresi TCompressionstream: Selain mewarisi properti onprogress dari kelas dasar, atribut lain ditambahkan: kompresiasi, yang didefinisikan sebagai berikut:
PropertyCompressionRate: SinglereadgetCompressionRate;
Melalui properti ini, rasio kompresi dapat diperoleh.
Beberapa metode penting didefinisikan sebagai berikut:
ConstructOrcompressionstream.create (CompressionLevel: TCompressionLevel; Dest: TStream);
Di antara mereka: TompressionLevel (tipe kompresi), itu ditentukan oleh yang berikut:
1) Clnone: tidak ada kompresi data yang dilakukan;
2) clfastest: melakukan kompresi cepat, mengorbankan efisiensi kompresi;
3) ClDefault: Lakukan kompresi normal;
4) CLMAX: Maksimalkan kompresi dan kecepatan pengorbanan;
DEST: Aliran tujuan, digunakan untuk menyimpan data terkompresi.
Functiontcompressionstream.write (constbuffer; count: longint): longint;
Di antara mereka: buffer: data yang perlu dikompresi;
Hitungan: Jumlah byte data yang akan dikompresi;
Fungsi mengembalikan jumlah byte yang ditulis ke aliran.
Catatan: Data dari Tompresi Kelas Terkompresi hanya dapat ditulis. Data yang perlu dikompresi ditulis ke aliran melalui metode penulisan metode, dan dikompresi selama proses penulisan, dan disimpan dalam aliran memori (TMemoryStream) yang disediakan oleh konstruktor, dan acara OnProses dipicu.
3) Kelas Dekompresi TDecompressionstream: Berbeda dengan Tompresi Kelas Terkompresi, data hanya dapat dibacakan.
Beberapa metode penting didefinisikan sebagai berikut:
ConstructorCreate (Sumber: TStream);
Di antara mereka: Sumber adalah aliran yang menyimpan data terkompresi;
FunctionRead (varbuffer; count: longint): longint;
Fungsi pembacaan data, buffer: menyimpan buffer data;
Fungsi mengembalikan jumlah byte baca. Selama proses membaca, data didekompresi dan acara OnProses dipicu.
(Ii)
Di Delphi, kelas dasar dari semua objek aliran adalah kelas TStream, yang mendefinisikan sifat dan metode umum dari semua aliran.
Properti yang ditentukan dalam kelas TStream adalah sebagai berikut:
1), Ukuran: Properti ini mengembalikan ukuran data dalam aliran dalam byte.
2) Posisi: Properti ini mengontrol posisi mengakses pointer dalam aliran.
Ada empat metode virtual yang didefinisikan dalam tstream:
1) Baca: Metode ini mengimplementasikan data membaca dari aliran, dan nilai pengembalian adalah jumlah aktual byte yang dibaca, yang dapat kurang dari atau sama dengan nilai yang ditentukan.
2) Tulis: Metode ini mengimplementasikan data penulisan ke dalam aliran, dan nilai pengembalian adalah jumlah byte yang sebenarnya ditulis ke aliran.
3) Mencari: Metode ini menyadari pergerakan penunjuk baca di aliran, dan nilai pengembalian adalah posisi pointer setelah gerakan.
Fungsi prototipe adalah: functionseek (offset: longint; origint: word): longint; virtual; abstrak;
Parameter offset adalah jumlah byte offset.
Sofrombeginning: Offset adalah data jarak pointer dimulai. Pada saat ini, offset harus lebih besar dari atau sama dengan nol.
SofromCurrent: Offset adalah posisi relatif dari pointer dan penunjuk saat ini setelah bergerak.
Sofromend: Offset adalah posisi di mana data jarak pointer berakhir setelah bergerak. Pada saat ini, offset harus kurang dari atau sama dengan nol.
4) Setsize: Metode ini menyadari mengubah ukuran data.
Selain itu, beberapa metode statis didefinisikan dalam kelas TStream:
1) ReadBuffer: Fungsi metode ini adalah membaca data dari posisi saat ini dalam aliran, sama seperti yang dibaca di atas.
Catatan: Ketika jumlah byte yang dibaca berbeda dari jumlah byte yang akan dibaca, pengecualian ereaderror akan dihasilkan.
2) WriteBuffer: Fungsi metode ini adalah menulis data ke aliran di lokasi saat ini, sama seperti penulisan di atas.
Catatan: Ketika jumlah byte yang ditulis dalam data berbeda dari jumlah byte yang akan ditulis, pengecualian eWriteError akan dihasilkan.
3) CopyFrom: Fungsi metode ini adalah menyalin aliran data dari aliran lain.
Fungsi prototipe adalah: functionCopyFrom (sumber: tstream; count: longint): longint;
Sumber parameter adalah aliran yang menyediakan data, dan hitungan adalah jumlah byte data yang disalin. Ketika jumlah lebih besar dari 0, salin dari salinan jumlah byte data dari posisi saat ini dari parameter sumber; ketika jumlah sama dengan 0, CopyFrom menetapkan properti posisi parameter sumber ke 0, dan kemudian menyalin semua data dari sumber;
Kelas tstream yang umum diturunkan:
Tfilestream (akses ke aliran file)
Tstringstream (memproses data tipe string dalam memori)
TMemoryStream (untuk pemrosesan data area memori kerja)
Tblobstream (pemrosesan data bidang tipe gumpalan)
TwinsocketStream (Baca dan Tulis Pemrosesan Soket)
Tolestream (pemrosesan data antarmuka COM)
Tresourcestream (pemrosesan aliran file sumber daya)
Yang paling umum digunakan adalah kelas tfilestream. Untuk mengakses file menggunakan kelas TFileStream, Anda harus terlebih dahulu membuat instance. Pernyataannya adalah sebagai berikut:
constructorCreate (constfileName: string; mode: word);
Nama file adalah nama file (termasuk path)
Mode adalah cara untuk membuka file.
Mode Buka:
FMCreate: Buat file dengan nama file yang ditentukan, dan buka jika file sudah ada.
FMopenRead: Buka file yang ditentukan di Read-only
FMopenWrite: Buka file yang ditentukan dengan cara yang hanya menulis
FMopenReadWrite: Buka file yang ditentukan dalam mode penulisan
Mode Berbagi:
FMShareCompat: Mode bersama kompatibel dengan FCBS
FMShareExclusive: Tidak ada program lain yang diizinkan untuk membuka file dengan cara apa pun
fmsharedenywrite: Tidak ada program lain yang diizinkan untuk membuka file secara tertulis
FMSharedYyread: Tidak ada program lain yang diizinkan untuk membuka file dalam mode baca
fmsharedenynone: Program lain dapat membuka file dengan cara apa pun
(Iii) file sumber daya
1) Buat file sumber daya
Pertama -tama buat file teks biasa dari .rc.
Format: Nama Kata Kunci Sumber Daya Nama File Sumber Daya
Pengidentifikasi Sumber Daya: Label Khusus saat memanggil sumber daya dalam program;
Kata kunci: Identifikasi jenis file sumber daya;
WAVE: File Sumber Daya adalah file suara;
Rcdata: file jpeg;
Avi: Avi Animation;
Ikon: file ikon;
Bitmap: file bitmap;
Kursor: file kursor;
Exfile: file exe
Nama File Sumber Daya: Nama lengkap file yang disimpan di disk file sumber daya
Misalnya:
myzjyexefilezjy.exe
2) menyusun file sumber daya
Di bawah /bin direktori instalasi Delphi, gunakan BRCC32.EXE untuk mengkompilasi file sumber daya.rc. Tentu saja, Anda juga dapat menyalin BRCC32 ke direktori dokumen program secara terpisah untuk digunakan.
Misalnya:
BRCC32WNHOO_REG.RC
3) Referensi File Sumber Daya
...
Pelaksanaan
{$ R*.dfm}
{$ Rwnhoo_reg.res}
...
4) Panggilan file sumber daya
(1) Akses bitmap di file sumber daya (bitmap)
Image.picture.bitmap.handle: = loadBitmap (hinstance, 'sumber daya pengidentifikasi');
Catatan: Jika bitmap tidak berhasil dimuat, program masih akan dieksekusi, tetapi gambar tidak akan lagi ditampilkan. Anda dapat menilai apakah beban berhasil berdasarkan nilai pengembalian fungsi LoadBitmap.
Metode lain untuk mengakses dan menampilkan bitmap adalah sebagai berikut
Image.picture.bitmap.LoadFromResourCename (Hinstance, 'Resource Identifier');
(2) mengakses kursor di file sumber daya
Screen.Cursors [] adalah array kursor. Karena nilai indeks kursor default dalam array adalah 0, yang terbaik adalah mengatur nilai indeks kursor yang disesuaikan menjadi 1 kecuali Anda ingin mengganti kursor default.
Screen.Cursors [1]: = LoadCursor (Hinstance, 'Resource Identifier');
Image.Cursor: = 1;
(3) Akses ikon dalam file sumber daya
Menempatkan ikon di file sumber daya memungkinkan Anda untuk mengubah ikon aplikasi secara dinamis.
application.icon.handle: = loadicon (Hinstance, 'Resource Identifier');
(4) Akses AVI di file sumber daya
Animate.resname: = 'myavi'; // nomor pengidentifikasi sumber daya
Animate.active: = true;
(5) Akses JPEG dalam file sumber daya
Tambahkan unit JPEG ke unit penggunaan.
var
Fjpg: tjpegimage;
Fstream: tresourcestream;
Mulai
Fjpg: = tjpegimage.create;
// Penggunaan Tresourcestream
Fstream: = tresourcestream.create (hinstance, 'sumber daya pengidentifikasi', jenis sumber daya);
Fjpg.loadFromStream (fStream);
Image.picture.bitmap.assign (fjpg);
(6) Gelombang akses dalam file sumber daya
Tambahkan Mmsystem ke Unit Penggunaan
Playsound (pchar ('mywav'), hinstance, snd_asyncorsnd_memoryorsnd_resource);
(Iv) Operasi file INI
(1) Struktur file INI:
; Ini adalah bagian komentar tentang file INI
[Node]
Kata kunci = nilai
...
File INI memungkinkan beberapa node, dan setiap node memungkinkan beberapa kata kunci. File INI, nilai boolean yang sebenarnya diwakili oleh 1, dan nilai boolean palsu diwakili oleh 0). Komentar dimulai dengan titik koma ";".
(2) Operasi file INI
1. Tambahkan inifiles ke bagian Penggunaan antarmuka;
2. Tambahkan baris ke bagian Definisi Variabel Var: difinfil: Tinifile;
3. Buka file INI: difinil: = tinifile.create ('tmp.ini');
4. Baca nilai kata kunci:
A: = inifile.readstring ('node', 'kata kunci', nilai default);
b: = inifile.readInteger ('node', 'kata kunci', nilai default); // tipe integer
c: = inifile.readbool ('node', 'kata kunci', nilai default);
Di mana [default] adalah nilai default yang dikembalikan ketika kata kunci tidak ada dalam file INI.
5. Menulis ke file INI:
inifile.writeString ('node', 'kata kunci', variabel atau nilai string);
inifile.writeInteger ('node', 'kata kunci', nilai variabel atau integer);
inifile.writebool ('node', 'kata kunci', variabel atau benar atau salah);
Ketika simpul file INI ini tidak ada, pernyataan di atas juga akan secara otomatis membuat file INI.
6. Hapus kata kunci:
inifile.deletey ('node', 'kata kunci'); // kata kunci hapus
inifile.erasesection ('node'); // penghapusan simpul
7. Operasi Node:
inifile.readsection ('node', variabel tstrings); // Semua nama kata kunci di bagian yang ditentukan dapat dibaca ke dalam variabel daftar string;
inifile.readsections (variabel tstrings); // Anda dapat membaca semua nama ayat dalam file INI ke variabel daftar string.
inifile.readsectionValues ('node', variabel tstrings); // semua baris (termasuk kata kunci, =, nilai) di bagian yang ditentukan dalam file INI dapat dibaca ke dalam variabel daftar string.
8. rilis: difile.distory;
(V) Hubungan dokumen
penggunaan
Registry, Shlobj;
// sadari pendaftaran terkait
ProcedureTmyzip.Regzzz;
var
Reg: Tregistry;
Mulai
Reg: = Tregistry.Create;
Reg.rootkey: = hkey_classses_root;
Reg.openkey ('. zzz', true);
Reg.WriteString ('', 'Myzip');
Reg.Closey;
Reg.openkey ('myzip/shell/open/command', true);
// program yang dapat dieksekusi digunakan untuk membuka file .zzz
Reg.WriteString ('', '"'+Application.exename+'" "%1"');
Reg.Closey;
Reg.openkey ('myzip/defaulticon', true);
// Harap ikon program yang dapat dieksekusi saat ini sebagai ikon file .zzz
Reg.WriteString ('', ''+Application.exename+', 0');
Reg.Free;
// Segarkan sekarang
Shchangenotify (shcne_assocchanged, shcnf_idlist, nil, nil);
akhir;
2.3.
1. Hasilkan file terenkripsi sementara INI
Format file sementara untuk INI untuk enkripsi:
[File1] // node, enkripsi multi-file dapat dicapai dengan menggunakan file1..n dalam perangkat lunak
FileName = Nama file terkompresi
Kata sandi = Kata sandi dekompresi
FileSize = Ukuran File
FileDate = Buat Tanggal
Isjm = apakah perlu untuk mendekompresi?
Jika Anda menerapkan penyimpanan informasi dari beberapa file dan folder, Anda dapat menyimpan kata kunci kata sandi di bawah total node. Artikel ini hanya mengimplementasikan enkripsi satu file, jadi selama format di atas sudah cukup.
2. Gabungkan file data dengan file INI yang digunakan untuk enkripsi, yang dapat diimplementasikan dalam bentuk aliran file.
Diagram Struktur File Terenkripsi:
Gambar (1)
Gambar (2)
Dua bentuk di atas dapat digunakan sesuai dengan kondisi aktual. Artikel ini mengadopsi struktur gambar (1).
3. Untuk data terenkripsi, teknologi ZLIB digunakan untuk mewujudkan penyimpanan terkompresi dan menghasilkan file terkompresi baru.
2.4. Lihat 2.2 (v) Untuk implementasi asosiasi file
2.5
1. Buat file program yang dapat dieksekusi secara khusus dari dekompresi
2. Buat file sumber daya di 1
3. Masukkan file sumber daya ke dalam program alat kompresi ini di artikel ini dan kompilasi bersama.
4. Hasilkan file pengekspresikan diri dengan menggabungkan file sumber daya dengan file terkompresi.
Diagram struktur file yang mengekstrak sendiri:
5. Implementasi Dekompresi Mandiri: Dengan menguraikan data terkompresi yang dienkripsi dalam file sendiri, kemudian mendekompresi data terkompresi terenkripsi yang terenkripsi lagi dan menguraikan file data nyata.
2.6 Pemrograman Sistem
Ini adalah semua kode bagian inti dari implementasi perangkat lunak ini, dan di sini kami akan menjelaskan semua detail teknis dari perangkat lunak ini secara rinci.
//wnhoo_zzz.pas
unitwnhoo_zzz;
antarmuka
penggunaan
Windows, Formulir, Sysutils, Kelas, Zlib, Registry, dialogiles, Dialog, Shlobj;
jenis
pass = string [20];
jenis
Tmyzip = kelas
Pribadi
{PrivatedEclarationShere}
terlindung
{ProtectedDeclarationShere}
publik
Prosedureregzzz;
Procedures_file (infilename, outfileName: string; kata sandi: pass; isjm: boolean; ysbz: integer);
functionjy_file (infilename: string; kata sandi: pass = ''): boolean;
Prosedurzjywj (varfilename: string);
ConstructorCreate;
Destructordestroy; override;
{PublicDeclarationShere}
diterbitkan
{PublishedDeclarationShere}
akhir;
Pelaksanaan
constructortmyzip.create;
Mulai
diwariskan create; // inisialisasi bagian yang diwariskan
akhir;
// ################################################## ################################################### #################################
// enkripsi file asli
ProsedurJM_File (vfile: string; vartarget: tMemoryStream; Kata sandi: pass; isjm: boolean);
{
VFILE: File terenkripsi
Target: aliran target output setelah enkripsi 》》》》》
Kata sandi: Kata sandi
ISJM: Apakah dienkripsi?
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ------ -----------------
Ukuran File Terenkripsi = Ukuran File Asli + [INI Interkripsi File Informasi Terkompresi] Ukuran + Ukuran Menyimpan Jenis Data Ukuran [File Informasi Terenkripsi Terenkripsi INI]
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ------ ----------------------
}
var
tmpstream, instream: tfilestream;
Fileze: Integer;
difinfile: tinifile;
nama file: string;
Mulai
// Pembukaan memerlukan [file terkompresi terenkripsi]
tmpstream: = tfileStream.create (vfile, fmopenreadorfmshareexclusive);
mencoba
// Tulis [aliran file asli] ke akhir [stream file terkompresi sementara yang dienkripsi]
Target.seek (0, sofromend);
Target.CopyFrom (TMPStream, 0);
// Dapatkan path file dan buat [INI dienkripsi file informasi terkompresi]
nama file: = extractFilePath (paramstr (0))+'tmp.in_';
difinfile: = tinifile.create (nama file);
inifile.writeString ('file1', 'fileName', extractFileName (vfile));
inifile.writeString ('file1', 'kata sandi', kata sandi);
inifile.writeInteger ('file1', 'fileSize', target.size);
inifile.writedateTime ('file1', 'fileedate', now ());
inifile.writebool ('file1', 'isjm', isjm);
diinifile. bebas;
// Baca di [INI Terenkripsi Stream File Informasi Terkompresi]
instream: = tfilestream.create (nama file, fMopenreadorfmshareExclusive);
mencoba
// Terus tambahkan [file informasi terkompresi terenkripsi INI] di akhir [stream file terkompresi sementara yang dienkripsi]
instream.position: = 0;
Target.seek (0, sofromend);
Target.copyfrom (inistream, 0);
// Hitung ukuran file informasi terkompresi saat ini [INI dienkripsi]
FileSize: = inistream.size;
// Terus menambahkan informasi ukuran [file informasi terkompresi terenkripsi INI] di akhir [file terenkripsi sementara]
Target.writeBuffer (fileseze, sizeof (filessize));
Akhirnya
instream.free;
DeleteFile (nama file);
akhir;
Akhirnya
tmpstream.free;
akhir;
akhir;
// ******************************************** ********************************************** ********************************************** ********************************************** ********************************************** ********************************************** ********************************************** ***************************************
// Kompresi aliran
Procedures_stream (instream, outstream: tstream; ysbz: integer);
{
Instream: Stream file terenkripsi untuk dikompresi
Aliran file output kompresi outstream
YSBZ: Standar Kompresi
}
var
YS: TCompressionstream;
Mulai
// Pointer aliran menunjuk ke kepala
instream.position: = 0;
// Memilih standar kompresi
casebzof
1: ys: = tompressionstream.create (clnone, outstream); // tidak dikompresi
2: ys: = tompressionstream.create (clfastest, outstream); // kompresi cepat
3: ys: = tcompressionstream.create (cldefault, outstream); // kompresi standar
4: ys: = tompressionstream.create (clmax, outstream); // kompresi maksimum
kalau tidak
ys: = tompressionstream.create (clfastest, outstream);
akhir;
mencoba
// aliran kompresi
ys.copyfrom (instream, 0);
Akhirnya
ys. bebas;
akhir;
akhir;
// ******************************************** ********************************************** ********************************************** ********************************************** ********************************************** ********************************************** ********************************************** *************************** *********************
// aliran dekompresi
ProsedurJy_stream (instream, outstream: tstream);
{
Instream: File Aliran Terkompresi Asli
Outstream: unzip file streaming
}
var
jyl: tdecompressionstream;
buf: array [1..512] ofbyte;
Sjread: Integer;
Mulai
instream.position: = 0;
jyl: = tdecompressionstream.create (instream);
mencoba
mengulang
// Baca ukuran sebenarnya
sjread: = jyl.read (buf, sizeof (buf));
ifsjread> 0then
Outstream.write (buf, sjread);
sampai (sjread = 0);
Akhirnya
Jyl.Free;
akhir;
akhir;
// ******************************************** ********************************************** ********************************************** ********************************************** ********************************************** ********************************************** ********************************************** ***************************************
// sadari pendaftaran terkait
ProcedureTmyzip.Regzzz;
var
Reg: Tregistry;
Mulai
Reg: = Tregistry.Create;
Reg.rootkey: = hkey_classses_root;
Reg.openkey ('. zzz', true);
Reg.WriteString ('', 'Myzip');
Reg.Closey;
Reg.openkey ('myzip/shell/open/command', true);
// program yang dapat dieksekusi digunakan untuk membuka file .zzz
Reg.WriteString ('', '"'+Application.exename+'" "%1"');
Reg.Closey;
Reg.openkey ('myzip/defaulticon', true);
// Harap ikon program yang dapat dieksekusi saat ini sebagai ikon file .zzz
Reg.WriteString ('', ''+Application.exename+', 0');
Reg.Free;
// Segarkan sekarang
Shchangenotify (shcne_assocchanged, shcnf_idlist, nil, nil);
akhir;
// Kompres file
ProcedureTmyzip.ys_file (infilename, outfileName: string; kata sandi: pass; isjm: boolean; ysbz: integer);
{
infilename: // file terenkripsi perlu dikompresi
OutfileName: // Kompres file yang dihasilkan setelah enkripsi
Kata sandi: // Kata sandi yang tidak kompreh
YSBZ: // Standar Kompresi
}
var
Instream: TMemoryStream; // Stream sementara setelah enkripsi file
Outstream: tfileStream; // Compress Output File Stream
Mulai
// Buat [stream sementara setelah enkripsi file]
Instream: = tMemoryStream.create;
// File enkripsi
jm_file (infilename, instream, password, isjm);
// Buat aliran file output terkompresi
outstream: = tfileStream.create (outfileName, fMcreate);
mencoba
// [stream sementara setelah enkripsi file] Kompresi
ys_stream (instream, outstream, ysbz);
Akhirnya
Outstream.free;
enterstream.free;
akhir;
akhir;
// mendekompres file
functiontmyzip.jy_file (infilename: string; kata sandi: pass = ''): boolean;
var
instream, instream, filestream_ok: tfilestream;
{
Instream: // unzip nama file
Instream: // stream file sementara INI
filestream_ok: // unzip file ok
}
Outstream: TMemoryStream; // Stream memori sementara
difinfile: tinifile; // file ini sementara
Fileze: integer; // ukuran file kata sandi
HasilValue: Boolean; // nilai pengembalian
Mulai
mencoba
instream: = tfilestream.create (infilename, fMopenread);
mencoba
Outstream: = tMemoryStream.create;
mencoba
jy_stream (instream, outstream);
// Hasilkan file INI sementara
instream: = tfileStream.create (extractFilePath (paramstr (0))+'tmp.in _', fMcreate);
mencoba
// Arahkan ke posisi variabel tipe integer yang menyimpan informasi yang diterjemahkan
Outstream.seek (-sizeOf (fileze), sofromend);
// Baca dalam Informasi Variabel
Outstream.readbuffer (fileseze, sizeOf (fileSize));
// Arahkan ke lokasi informasi yang diterjemahkan
Outstream.seek (-(FileSize+sizeOf (FileSize)), Sofromend);
// Baca informasi yang diterjemahkan ke dalam aliran INI
instream.copyfrom (outstream, filsize);
// Lepaskan aliran file INI
instream.free;
// Baca informasi file INI
tidak penting: = tinifile.create (extractFilePath (paramstr (0))+'tmp.in_');
resultValue: = inifile.readbool ('file1', 'isjm', false);
ifresultValuethen
Mulai
ifinifile.readstring ('file1', 'password', '') = trim (kata sandi) lalu
HasilValue: = Benar
kalau tidak
HasilValue: = false;
akhir
kalau tidak
HasilValue: = true;
ifresultValuethen
Mulai
filestream_ok: = tfilestream.create (extractFilePath (paramstr (1))+inifile.readstring ('file1', 'fileName', 'wnhoo.zzz'), fmcreate);
mencoba
Outstream.position: = 0;
filestream_ok.copyfrom (outstream, inifile.readInteger ('file1', 'fileSize', 0));
Akhirnya
filestream_ok.free;
akhir;
akhir;
diinifile. bebas;
Akhirnya
// Hapus file INI sementara
deleteFile (extractFilePath (paramstr (0))+'tmp.in_');
akhir;
//
Akhirnya
Outstream.free;
akhir;
Akhirnya
instream.free;
akhir;
kecuali
HasilValue: = false;
akhir;
Hasil: = hasil result;
akhir;
// Penciptaan diri sendiri
ProcedureetMyzip.zjywj (varfileName: string);
var
Myres: trsourcestream; // Simpan untuk sementara file exe pengeksprak mandiri
myfile: tfilestream; // stream file asli
xfilename: string; // Nama file sementara
file_ok: tMemoryStream; // aliran memori dari file yang dihasilkan
FileSize: Integer; // Ukuran File Asli
Mulai
IffileExists (nama file) lalu
Mulai
// Buat aliran memori
file_ok: = tMemoryStream.Create;
// Lepaskan File Sumber Daya-SELF-EKTRAK file EXE
myres: = tresourcestream.create (hinstance, 'myzjy', pchar ('exefile'));
// Baca file asli ke dalam memori
myfile: = tfilestream.create (nama file, fMopenread);
mencoba
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);
file: = myfile.size;
file_ok.writeBuffer (filezeze, sizeof (filesize));
file_ok.position: = 0;
xfilename: = changeFileExt (nama file, '. exe');
file_ok.savetofile (xfileName);
Akhirnya
myfile.free;
Myres.Free;
file_ok.free;
akhir;
DeleteFile (nama file);
Nama file: = xFileName;
akhir;
akhir;
// ################################################## ################################################### #################################
destructortmyzip.destroy;
Mulai
diwariteddestroy;
akhir;
akhir.
3. Kesimpulan
Lingkungan pemrograman visual baru Delphi memberi kami alat pengembangan aplikasi Windows yang nyaman dan cepat. Untuk pengembang program, menggunakan Delphi untuk mengembangkan perangkat lunak aplikasi tidak diragukan lagi akan sangat meningkatkan efisiensi pemrograman. Di Delphi, Anda dapat dengan mudah menggunakan aliran untuk mengimplementasikan berbagai formulir data seperti pemrosesan file, pemrosesan memori dinamis, pemrosesan data jaringan, dll., Dan program penulisan akan sangat meningkatkan efisiensi.
Referensi:
1. Bantuan Sistem Delphi
2. Feng Zhiqiang.
3. Chen Jingtao.