Oleh kerana perkembangan pesat teknologi pengaturcaraan, semakin ramai orang berhadapan dengan masalah meningkatkan keupayaan program mereka. Artikel ini dikhaskan dengan tepat kepada isu ini, iaitu, pengaturcaraan DLL di Borland Delphi. Di samping itu, memandangkan kami akan menyentuh isu yang berkaitan dengan penggunaan DLL, kami juga akan menyentuh mengimport fungsi daripada DLL asing (termasuk yang sistem, iaitu WinAPI).

Kawasan Aplikasi DLL

Jadi, mengapa DLL diperlukan dan di mana ia digunakan?.. Mari kita senaraikan beberapa kawasan aplikasinya:

• Perpustakaan individu mengandungi maklumat berguna untuk pengaturcara fungsi tambahan. Contohnya, fungsi untuk bekerja dengan rentetan, atau perpustakaan kompleks untuk menukar imej.
• Storan sumber. DLL boleh menyimpan bukan sahaja program dan fungsi, tetapi juga semua jenis sumber - ikon, gambar, tatasusunan rentetan, menu, dll.
• Perpustakaan Sokongan. Sebagai contoh, kita boleh memetik perpustakaan seperti itu pakej yang diketahui, Bagaimana: DirectX, ICQAPI(API untuk ICQ), OpenGL dan lain-lain.
• Sebahagian daripada program. Sebagai contoh, anda boleh menyimpan tetingkap program (borang), dsb. dalam DLL.
• Pemalam(Pemalam). - Di sinilah skop sebenar untuk pemikiran pengaturcara! Pemalam ialah tambahan kepada program yang mengembangkan keupayaannya. Sebagai contoh, dalam artikel ini kita akan melihat teori mencipta pemalam untuk program anda sendiri.
• Sumber yang dikongsi. DLL ( Pautan Dinamik Perpustakaan) boleh digunakan oleh beberapa program atau proses sekaligus (yang dipanggil. perkongsian- sumber dikongsi)

Penerangan ringkas tentang fungsi dan teknik untuk bekerja dengan DLL

Jadi, apakah teknik dan fungsi yang perlu anda gunakan untuk bekerja dengan DLL? Mari kita lihat dua kaedah untuk mengimport fungsi daripada perpustakaan:

1 cara. Mengikat DLL ke program. Ini adalah yang paling mudah dan kaedah mudah untuk menggunakan fungsi yang diimport daripada DLL. Walau bagaimanapun (dan ini harus diperhatikan) kaedah ini mempunyai kelemahan yang sangat ketara - jika perpustakaan yang digunakan oleh program tidak dijumpai, maka program itu tidak akan bermula, memberikan ralat dan melaporkan bahawa sumber DLL tidak dijumpai. Dan carian perpustakaan akan dijalankan: dalam direktori semasa, dalam direktori program, dalam direktori WINDOWS\SYSTEM, dsb.
Jadi, sebagai permulaan - bentuk umum teknik ini:

pelaksanaan
...
fungsi Nama Fungsi(Par1: Par1Type; Par2: Par2Type; ...): ReturnType; stdcall; luaran"DLLNAME.DLL" nama"Nama Fungsi" indeks FuncIndex;
// atau (jika bukan fungsi, tetapi prosedur):
prosedur ProcedureName(Par1: Par1Type; Par2: Par2Type; ...); stdcall; luaran"DLLNAME.DLL" nama"Nama Prosedur" indeks ProcIndex;

di sini: Nama Fungsi(atau Nama Prosedur) - nama fungsi (atau prosedur) yang akan digunakan dalam program anda;
Par1, Par2, ...- nama fungsi atau parameter prosedur;
Par1Type, Par2Type, ...- jenis fungsi atau parameter prosedur (contohnya, Integer);
ReturnType- jenis nilai pulangan (untuk fungsi sahaja);
stdcall- arahan yang mesti sepadan dengan arahan yang digunakan dalam DLL itu sendiri;
luaran "DLLNAME.DLL"- arahan yang menyatakan nama DLL luaran dari mana ia akan diimport fungsi ini atau prosedur (dalam dalam kes ini - DLLNAME.DLL);
nama "FunctionName" ("ProcedureName")- arahan yang menunjukkan nama sebenar fungsi dalam DLL itu sendiri. Ini ialah arahan pilihan yang membenarkan fungsi digunakan dalam atur cara yang mempunyai nama selain yang benar (yang ada dalam pustaka);
indeks FungsiIndex(ProcedureIndex)- petunjuk arahan nombor siri fungsi atau prosedur dalam DLL. Ini juga merupakan arahan pilihan.

Kaedah 2. Pemuatan dinamik DLL. Ini adalah kaedah yang lebih kompleks, tetapi juga lebih elegan. Ia tidak mempunyai kelemahan kaedah pertama. Satu-satunya perkara yang tidak menyenangkan ialah jumlah kod yang diperlukan untuk melaksanakan teknik ini, dan kesukarannya ialah fungsi yang diimport daripada DLL hanya boleh diakses apabila DLL ini dimuatkan dan dalam ingatan... Anda boleh lihat contoh di bawah, tetapi buat masa ini - Penerangan Ringkas Fungsi WinAPI yang digunakan oleh kaedah ini:

Muat Pustaka(LibFileNama: PChar) - memuatkan perpustakaan tertentu LibFileName ke dalam memori. Apabila berjaya disiapkan, fungsi mengembalikan pemegang ( Tandle) DLL dalam ingatan.
GetProcAddress(Modul: Tandle; Nama Proc: PChar) - membaca alamat fungsi perpustakaan yang dieksport. Apabila berjaya disiapkan, fungsi mengembalikan pemegang ( TFarProc) berfungsi dalam DLL yang dimuatkan.
Perpustakaan Percuma(LibModul: Tandle) - membatalkan LibModule dan membebaskan memori yang berkaitan dengannya. Perlu diingat bahawa selepas memanggil prosedur ini, fungsi perpustakaan ini tidak lagi tersedia.

Amalan dan contoh

Nah, kini tiba masanya untuk memberikan beberapa contoh menggunakan kaedah dan teknik di atas:

Sekarang perkara yang sama, tetapi dengan cara kedua - dengan pemuatan dinamik:

(...Berikut adalah pengepala fail dan takrif bentuk TForm1 dan contoh Borang1) var Borang1: TForm1; GetSimpleText: fungsi(LangRus: Boolean): PChar; LibHandle: THandle; prosedur Button1Click(Penghantar: TObject); bermula (“Membersihkan” alamat fungsi daripada “kotoran”) @GetSimpleText:= tiada; (Kami cuba memuatkan perpustakaan) LibHandle:= LoadLibrary("MYDLL.DLL"); (Jika semuanya OK) jika LibHandle >= 32 maka mulakan (...kemudian kami cuba mendapatkan alamat fungsi di perpustakaan) @GetSimpleText:= GetProcAddress(LibHandle,"GetSimpleText"); (Jika semuanya OK di sini juga) jika @GetSimpleText<>tiada kemudian (...kemudian panggil fungsi ini dan tunjukkan hasilnya) ShowMessage(StrPas(GetSimpleText(True))); akhir; (Dan jangan lupa untuk mengosongkan memori dan memunggah DLL) FreeLibrary(LibHandle); akhir;

CATATAN : Anda harus mengelak daripada menggunakan jenis rentetan dalam fungsi perpustakaan kerana Terdapat masalah dengan "perkongsian memori" semasa menggunakannya. Anda boleh membaca lebih lanjut mengenai ini (walaupun dalam bahasa Inggeris) dalam teks projek DLL kosong yang Delphi cipta (Fail -> Baharu -> DLL). Jadi lebih baik menggunakan PChar dan kemudian menukarnya kepada rentetan menggunakan fungsi StrPas jika perlu.

Nah, sekarang mari kita lihat DLL itu sendiri:

Meletakkan sumber dan borang dalam DLL

DLL boleh mengandungi bukan sahaja fungsi, tetapi juga kursor, gambar, ikon, menu dan rentetan teks. Kami tidak akan memikirkan perkara ini. Saya hanya akan ambil perhatian bahawa untuk memuatkan sumber anda perlu memuatkan DLL, dan kemudian, setelah menerima deskriptornya, muatkan sumber itu sendiri dengan fungsi yang sesuai (LoadIcon, LoadCursor, dll.). Dalam bahagian ini, kami hanya akan menyentuh secara ringkas tentang penempatan tetingkap aplikasi (iaitu borang dalam Delphi) dalam DLL.

Untuk melakukan ini, anda perlu mencipta DLL baharu dan menambahnya uniform baru(Fail -> Baharu -> DLL, dan kemudian Fail -> Borang Baharu). Seterusnya, jika borang ialah kotak dialog ( bentuk modal(bsDialog)), kemudian tambahkan fungsi berikut pada DLL (katakan borang itu dipanggil Form1, dan kelasnya ialah TForm1):

Jika anda perlu meletakkan borang bukan modal dalam DLL, maka anda perlu mencipta dua fungsi - membuka dan menutup borang. Dalam kes ini, anda perlu memaksa DLL untuk mengingati pemegang kepada borang ini.

Mencipta pemalam

Di sini kami tidak akan mempertimbangkan pemalam secara terperinci, kerana... Contoh-contoh yang telah diberikan di atas akan membantu anda dengan mudah memahami bahagian besar pengaturcaraan DLL. Izinkan saya hanya mengingatkan anda bahawa pemalam adalah tambahan kepada program yang mengembangkan keupayaannya. Pada masa yang sama, program itu sendiri mesti menyediakan kehadiran tambahan tersebut dan membolehkan mereka memenuhi tujuannya.

Iaitu, sebagai contoh, untuk mencipta pemalam untuk penyunting grafik yang akan melakukan penukaran imej, anda perlu menyediakan sekurang-kurangnya dua fungsi dalam pemalam (dan, dengan itu, panggil fungsi ini dalam program) - fungsi yang akan mengembalikan nama pemalam (dan/atau jenisnya) untuk tambah pemalam ini pada menu (atau dalam bar alat), tambah fungsi utama- penghantaran imej dan penerimaan. Itu. mula-mula program mencari pemalam, kemudian untuk setiap pemalam yang ditemui ia memanggil fungsi pengenalannya dengan nama yang ditetapkan dengan ketat (contohnya, GetPluginName) dan menambah item yang dikehendaki dalam menu, maka, jika pengguna telah memilih item ini, ia memanggil fungsi kedua, yang mana ia menghantar imej input (atau nama fail yang mengandungi imej ini), dan fungsi ini, seterusnya, memproses imej dan mengembalikannya dalam bentuk baharu (atau nama fail dengan imej baharu). Itulah intipati plugin... :-)

Epilog

Artikel ini menunjukkan asas menggunakan dan mencipta DLL dalam Borland Delphi. Jika anda mempunyai soalan, hantarkan kepada saya melalui e-mel: [e-mel dilindungi], dan lebih baik lagi - tulis dalam persidangan di tapak ini supaya pengguna lain dapat melihat soalan anda dan cuba menjawabnya!

Karikh Nikolay. Wilayah Moscow, Zhukovsky

Perpustakaan dinamik, atau DLL, ialah koleksi subrutin (program kecil) yang boleh dipanggil oleh aplikasi atau lain-lain DLL. Seperti modul, DLL mengandungi kod am atau sumber yang boleh digunakan oleh berbilang aplikasi secara serentak daripada satu contoh DLL. Sebenarnya Windows- ia hanya koleksi DLL.

Sememangnya, menggunakan Delphi, kita juga boleh menulis dan menggunakan kita sendiri DLL dan kita boleh memanggil fungsi masuk DLL, dibangunkan oleh pembangun lain dan pada sistem lain (seperti Visual Basic atau C/C++).

Mencipta perpustakaan dinamik

Beberapa baris seterusnya menunjukkan cara membuat yang mudah DLL menggunakan Delphi.

Untuk pemula Ikan lumba-lumba anda perlu memilih daripada menu Fail | Baharu...DLL. Ini akan mencipta templat baharu DLL dalam tetingkap editor. Pilih teks lalai dan gantikannya dengan kod berikut:

LibraryTestLibrary; menggunakan SysUtils, Kelas, Dialog; prosedur DllMessage; eksport; mulakan ShowMessage("Hello world from a Delphi DLL" ; akhir; mengeksport DllMessage; mula akhir.

Jika anda melihat fail projek mana-mana aplikasi Delphi Anda akan melihat bahawa ia bermula dengan perkataan terpelihara Program. DLL sebaliknya, bermula dengan perkataan terpelihara Perpustakaan. Ini kemudian diikuti dengan klausa kegunaan bagi apa apa modul yang diperlukan. Dalam contoh mudah ini, ini diikuti dengan prosedur yang dipanggil DllMessage, yang tidak melakukan apa-apa selain memaparkan mesej ringkas.

Di akhir teks ini terdapat arahan eksport. Di sini disertakan senarai rutin yang akan dieksport daripada DLL dan boleh dipanggil oleh aplikasi lain. Ini bermakna, sebagai contoh, dalam DLL Terdapat 5 prosedur dan hanya 2 daripadanya (disenaraikan dalam bahagian eksport) boleh dipanggil dari program luar(3 daripadanya adalah subrutin dalam DLL).

Untuk menggunakan mudah ini DLL, kita perlu menyusunnya dengan mengklik Ctrl+F9. Ini adalah untuk mencipta DLL dengan nama SimpleMessageDll.dll dalam folder projek.

Sekarang mari lihat cara memanggil prosedur DllMessage dari (dimuatkan secara statik) DLL.

Untuk mengimport prosedur yang terkandung dalam DLL, kami menggunakan kata kunci luaran dalam pengisytiharan prosedur. Contohnya, pengisytiharan prosedur DllMessage ditunjukkan sebelum ini akan kelihatan seperti ini:

Prosedur DllMessage; luaran "SimpleMessageDLL.dll"

Dan panggilan prosedur kelihatan seperti ini:

DllMessage;

Kod penuh untuk borang Borang1 Dengan TButton dengan nama Butang1(untuk memanggil fungsi DllMessage) kelihatan seperti itu:

Unit Unit1; antara muka menggunakan Windows, Mesej, SysUtils, Varian, Kelas, Grafik, Kawalan, Borang, Dialog, StdCtrls; taip TForm1 = class(TForm) Butang1: TButton; prosedur Button1Click(Penghantar: TObject); persendirian ( Perisytiharan persendirian ) awam ( Perisytiharan awam ) tamat; var Borang1: TForm1; prosedur DllMessage; pelaksanaan "SimpleMessageDLL.dll" luaran ($R *.dfm) prosedur TForm1.Button1Click(Pengirim: TObject) ; beginDllMessage; akhir; tamat.

Itu sahaja! Ia mudah, sama seperti segala-galanya di Delphi!

Rakan-rakan yang dihormati!

Dalam artikel ini saya akan cuba menjawab soalan: Apa itu DLL? Untuk apa itu? Dan bagaimana untuk mencipta dan menggunakan DLL dengan bantuan Delphi.

Apa itu DLL?

Pustaka Pautan Dinamik atau ringkasnya DLL ialah perpustakaan yang mengandungi set data atau fungsi untuk digunakan dalam atur cara lain.

Bidang penggunaan:

• Penyimpanan sumber: ikon, bunyi, kursor, dsb. Jimat saiz fail boleh laku menggabungkan sumber menjadi satu perpustakaan.
• Penempatan modul program individu dan borang antara muka. Kami mendapat peluang untuk mengemas kini sebahagian aplikasi, dan dengan sambungan dinamik, adalah mungkin untuk mengemas kini modul tanpa memulakan semula program utama.
• Gunakan sebagai pemalam (PlugIn). Kami memberi peluang untuk mengembangkan fungsi aplikasi tanpa menulis semula kod program utama.
• Perpustakaan boleh digunakan pada perbezaan bahasa pengaturcaraan, tanpa mengira bahasa di mana ia ditulis.

Ciptaan perpustakaan sendiri DLL.

Untuk membuat perpustakaan, pergi ke menu Fail -> Lain-lain dan pilih Projek Delphi -> Perpustakaan pautan dinamik.
Teks kod dengan templat untuk mencipta perpustakaan akan dibuka:

Projek Perpustakaan1; menggunakan System.SysUtils, System.Classes; ($R *.res) bermula akhir.

Penempatan sumber

Mari tambahkan ikon pada perpustakaan, yang akan kita gunakan kemudian dalam program utama.
Cara menambah sumber pada projek diterangkan secara terperinci dalam artikel.

Mari tambahkan borang "Perihal program".
klik Fail -> Baru -> Borang VCL. Mari tambah teks dan butang "OK":

Mari tambah fungsi yang akan memaparkan standard MessageBox dengan soalan, butang "Ya", "Tidak" dan dengan keputusan dalam borang betul atau Salah.

Fungsi YesNoDlg(const Question: PChar): boolean; stdcall; mulakan Keputusan:= (MessageBox(0, Soalan, "Pengesahan", MB_YESNO + MB_ICONQUESTION) = ID_YES); akhir;

Beri perhatian kepada kata kunci stdcall. Ia menentukan dengan tepat bagaimana parameter dan hasil akan diluluskan apabila memanggil fungsi. Anda boleh membaca lebih lanjut di halaman wiki Perjanjian Panggilan.

Kami juga akan menambah prosedur yang akan digunakan sebagai pemalam untuk program utama. Yang akan menambah butang "Perihal program" ke menu program utama untuk membuka tetingkap yang kami buat.
Kod prosedur:

Pemalam Prosedur(Borang: TForm); stdcall; var i: integer; mi: TMenuItem; mulakan untuk i:= 0 hingga Form.ComponentCount - 1 bermula jika (Form.Components[i].ClassName = "TMenuItem") dan (Form.Components[i].Name = "miHelp") kemudian mulakan mi:= TMenuItem .Buat(Borang.Komponen[i]); mi.Caption:= "Mengenai program"; mi.OnClick:= fmAbout.onAboutButtonClick; TMenuItem(Borang.Komponen[i]).Tambah(mi); Keluar; akhir; akhir; akhir;

Bentuk program diserahkan kepada prosedur sebagai parameter. Kami menyemak sama ada terdapat item menu bernama “ miHelp"dan jika menu itu dijumpai, kemudian tambahkan butang kami kepadanya.

Sekarang kami akan menunjukkan fungsi dan prosedur yang boleh digunakan dari perpustakaan kami.
Mari tambah baris:

Eksport PlugIn, YesNoDlg;

Mari kita susun fungsi Projek -> bina atau menggunakan hotkey Shift+F9.
Jika tiada ralat dalam kod, maka fail dengan sambungan akan muncul dalam folder projek DLL.

Sekarang mari kita beralih kepada mencipta aplikasi yang akan menggunakan perpustakaan kita.

Mari buat borang dalam aplikasi Utama di mana kami akan menambah komponen dengan butang berikut: Program -> Keluar dan Bantuan. Untuk yang terakhir, mari kita tetapkan nama - miHelp:

Mari kita beralih kepada kod borang.

Fungsi dari perpustakaan DLL boleh disambungkan dalam dua cara:
Statik— perpustakaan disambungkan apabila program bermula. Jika pustaka atau nama fungsi tidak ditemui, atur cara akan menghasilkan ralat dan tidak akan dijalankan.
Dinamik— perpustakaan disambungkan sama ada sejurus sebelum panggilan fungsi atau pada acara tertentu.

Mari kita pertimbangkan kaedah sambungan statik:

Taip TfmMain = class(TForm) MainMenu: TMainMenu; miProgram: TMenuItem; miKeluar: TMenuItem; miHelp: TMenuItem; prosedur FormCreate(Penghantar: TObject); prosedur miExitClick(Penghantar: TObject); hujung awam swasta; procedure PlugIn(Borang: TForm); stdcall; luaran "SampleDLL.dll"; var...

Kata kunci luaran menunjukkan bahawa fungsi ini disambungkan daripada perpustakaan luaran.

Untuk majlis tersebut onCreate borang, tambah panggilan prosedur Pasangkan:

Prosedur TfmMain.FormCreate(Penghantar: TObject); mulakan PlugIn(Self); akhir;

Sebagai parameter Borang kami menghantar borang semasa kepada prosedur (kata kunci Diri sendiri).

Apabila memulakan program, kita harus mempunyai item "Perihal program" dalam bahagian "Bantuan" pada menu utama.

Mari kita beralih kepada kaedah sambungan dinamik.

Kami memerlukan tiga fungsi WinApi:

Muat Pustaka
Memuatkan perpustakaan ke dalam memori komputer. Akibatnya, ia mengembalikan penunjuk ke perpustakaan dalam ingatan. Sekiranya ralat, ia akan mengembalikan 0.

LoadLibrary(lpLibFileName: LPCWSTR): HMODULE;

lpLibFileName— Nama fail perpustakaan.

GetProcAddress
Cari fungsi dalam perpustakaan mengikut nama. Hasilnya akan menjadi penunjuk fungsi. Jika fungsi tidak dijumpai, ia akan kembali tiada.

GetProcAddress(hModule: HMODULE; lpProcName: LPCSTR): FARPROC;

hModul
lpProcName- Nama fungsi.

Perpustakaan Percuma
Memunggah perpustakaan daripada memori komputer. Hasilnya adalah Benar sekiranya berjaya dan Salah sekiranya berlaku kesilapan.

FreeLibrary(hLibModule: HMODULE): BOOL;

hLibModul— Penunjuk ke perpustakaan yang dimuatkan.

Sekarang, menggunakan kaedah dinamik, kami akan mendapat sumber, ikon kami dan menambah panggilan fungsi pada butang "Keluar". YaTidakDlg untuk mengesahkan program ditutup.
Tambahkan kod pada acara onCreate yang sama:

Prosedur TfmMain.FormCreate(Penghantar: TObject); var DLLHandle: THandle; mulakan PlugIn(Self); DLLHandle:= LoadLibrary("SampleDLL.dll"); jika DLLHandle = 0 kemudian naikkan Exception.Create("Tidak boleh memasukkan perpustakaan 'SampleDLL'!"); cuba Self.Icon.LoadFromResourceName(DLLHandle, "my_icon"); akhirnya FreeLibrary(DLLHandle); akhir; akhir;

Dan untuk acara itu onClick item menu "Keluar":

Prosedur TfmMain.miExitClick(Penghantar: TObject); var DLLHandle: THandle; Dlg: function(const Soalan: PChar): boolean; stdcall; mulakan DLLHandle:= LoadLibrary("SampleDLL.dll"); jika DLLHandle = 0 kemudian naikkan Exception.Create("Tidak boleh memasukkan perpustakaan 'SampleDLL'!"); cuba @Dlg:= GetProcAddress(DLLHandle, "YesNoDlg"); jika tidak Ditugaskan(@Dlg) kemudian naikkan Exception.Create("Fungsi bernama "YesNoDlg" tidak ditemui dalam perpustakaan "SampleDLL"!"); jika Dlg("Keluar dari program?") kemudian Tutup; akhirnya FreeLibrary(DLLHandle); akhir; akhir;

Jika anda menulis semuanya dengan betul, maka selepas memulakan program, ikon borang harus berubah, butang "Mengenai program" harus ditambah, apabila diklik padanya borang akan dipaparkan Tentang dan apabila anda menekan butang keluar, program akan meminta pengesahan: "Keluar dari program?"

Saya harap anda mendapati contoh kecil menggunakan ciri ini berguna. DLL perpustakaan.
Sumber projek boleh dimuat turun.

DLL- Pustaka Pautan Dinamik, atau perpustakaan pautan dinamik, yang membolehkan anda menggunakan semula fungsi yang sama dalam program yang berbeza. Malah, ia adalah alat yang agak mudah, terutamanya kerana perpustakaan, setelah ditulis, boleh digunakan dalam banyak program. Dalam pelajaran hari ini kita akan belajar bagaimana untuk bekerja dengan dll dan sudah tentu menciptanya!
Baiklah, mari kita mulakan!

Mula-mula, mari buat Pustaka Pautan Dinamik pertama kami! Mari pergi ke Delphi dan segera pergi ke menu File -> New -> Other.
Tetingkap berikut muncul di hadapan kami:

Pilih Pustaka Pautan Dinamik daripada senarai (dalam versi lebih awal daripada 2009 Delphi Item itu dipanggil DLL Wizard).

Akibatnya, kami hanya mempunyai tetingkap dengan kod; ambil perhatian bahawa kami tidak mempunyai sebarang bentuk di sini!
Sekarang keseronokan bermula. Mari kita tulis prosedur pertama kita di perpustakaan.

perpustakaanProjek2;
//Anda mungkin sudah perasan bahawa bukannya program
//apabila mencipta dll, perkataan perpustakaan digunakan.
//Maksud perpustakaan.
kegunaan
SysUtils, dialog,
Kelas; // Perhatian! Jangan lupa untuk menentukan modul ini,
// jika tidak, kod tidak akan berfungsi
($R *.res)
(KOD DLL DILETAKKAN DI BAHAGIAN INI)

Prosedur Panggilan Pertama; stdcall; eksport;
//Stdcall - Dengan operator ini, parameter ditolak ke tindanan
//dari kanan ke kiri, dan dijajarkan ke nilai piawai
//Eksport boleh, pada dasarnya, ditinggalkan, digunakan untuk penjelasan
//eksport prosedur atau fungsi.
Mulakan
ShowMessage(" Prosedur pertama saya dalam dll");

Tamat;

Prosedur DoubleCall; stdcall; eksport;
Mulakan
ShowMessage(" Prosedur kedua saya");
//Panggil mesej pada skrin
Tamat;

Mengeksport FirstCall, DoubleCall;
//Eksport mengandungi senarai elemen yang dieksport.
//Yang kemudiannya akan diimport oleh beberapa program.
bermula
tamat.

Kami akan berhenti di sini buat masa ini kerana... Untuk contoh mudah ini akan cukup. Sekarang kami menyimpan projek kami, saya secara peribadi menyimpannya di bawah nama Project2.dll dan tekan kombinasi kekunci CTRL+F9 untuk menyusun perpustakaan. Dalam folder yang anda simpan fail dpr fail dengan dll sambungan, ini ialah perpustakaan kami yang baru dibuat. Saya mempunyai ia dipanggil Project2.dll

Sekarang mari kita mulakan prosedur panggilan daripada perpustakaan ini. Kami mencipta aplikasi baharu mengikut skema standard. Di hadapan kita tidak ada yang luar biasa, hanya bentuk. Simpan aplikasi baharu ke beberapa folder. Dan salin yang baru dibuat ke dalam folder yang sama dll perpustakaan . Itu. V dalam contoh ini Project2.dll

Kini anda perlu memilih cara memanggil fungsi daripada perpustakaan. Terdapat dua kaedah panggilan secara keseluruhan.

Kaedah No 1
Mungkin ini adalah kaedah paling mudah untuk prosedur panggilan yang terdapat di perpustakaan.
Sesuai untuk bekerja dengan hanya satu perpustakaan.

Di sini kita pergi...
Selepas kata kunci pelaksanaan kami menulis kod berikut:

Prosedur Panggilan Pertama; stdcall; luaran "Project2.dll" ;
// Daripada Project2.dll boleh ada sebarang nama perpustakaan
Prosedur DoubleCall; stdcall; luaran "Project2.dll" ;

Di sini, seperti yang anda mungkin sudah meneka, kami memberitahu program nama-nama prosedur kami dan mengatakan bahawa mereka sudah masuk dll perpustakaan, dalam kes saya bernama Project2.dll

Sekarang, untuk memanggil prosedur ini, kami hanya perlu memasukkan nama mereka di mana-mana dalam kod, yang akan kami lakukan sekarang. Lepaskan komponen Butang 2 daripada tab Standard ke dalam borang dan buat pengendali acara OnClick pada setiap satu

Klik pada butang pertama:

Mulakan
Panggilan Pertama;
Tamat;

Klik pada butang kedua:

Mulakan
DoubleCall; // Nama prosedur yang ada dalam dll
Tamat;

Itu sahaja!

Kaedah nombor 2:
Lebih kompleks daripada yang pertama, tetapi ia mempunyai kelebihannya, dan yang paling penting, ia sesuai untuk pemalam.
Untuk kegunaan kaedah ini, pertama sekali kami mengisytiharkan beberapa pembolehubah global:

Var
LibHandle: HModul; //Pautan ke modul perpustakaan
Panggilan Pertama:prosedur; stdcall;
//Nama prosedur kami terletak di perpustakaan.
DoubleCall: prosedur; stdcall;

Kemudian, selepas kata kunci pelaksanaan, kami akan menulis prosedur yang akan memuatkan perpustakaan kami:

Prosedur LoadMyLibrary(FileName: String);
Mulakan
LibHandle:= LoadLibrary(PWideChar(Nama Fail));
//Memuatkan perpustakaan!
// Perhatian! PChar untuk versi di bawah Delphi 2009
Jika LibHandle = 0 maka mulakan
MessageBox(0,"",0,0);
Keluar;
Tamat;
FirstCall:= GetProcAddress(LibHandle,"FirstCall ");
//Dapatkan penunjuk ke objek
//Pautan parameter pertama ke modul perpustakaan
//Nama objek parameter kedua dalam dll
DoubleCall:= GetProcAddress(LibHandle,"DoubleCall");
Jika @FirstCall = tiada maka mulakan

MessageBox(0," Tidak dapat memuatkan pustaka",0,0);
Keluar;
Tamat;
Jika @DoubleCall = tiada maka mulakan
//Semak kehadiran fungsi ini dalam perpustakaan.
MessageBox(0," Tidak dapat memuatkan pustaka",0,0);
Keluar;
Tamat; Tamat;

Kemudian kami membuat pengendali pada borang Acara OnCreate, di mana, menggunakan prosedur yang baru kami buat, kami akan memuatkan kami perpustakaan

Prosedur TForm1.FormCreate(Pengirim: TObject);
Mulakan
LoadMyLibrary("Project2.dll ");
Tamat;

Sekarang, sekali lagi, untuk memanggil prosedur yang diperlukan dari perpustakaan kami, kami hanya perlu memasukkan nama mereka di mana-mana dalam kod. Untuk melakukan ini, lepaskan komponen 2 Butang daripada tab Standard ke dalam borang dan buat pengendali acara OnClick pada setiap

Klik pada butang pertama:

Prosedur TForm1.Button1Click(Penghantar: TObject);
Mulakan
Panggilan Pertama; // Nama prosedur yang ada dalam dll
Tamat;

Klik pada butang kedua:

Prosedur TForm1.Button2Click(Penghantar: TObject);
Mulakan
DoubleCall; // Nama prosedur yang ada dalam dll
Tamat;

Dan akhirnya, kami mencipta pengendali acara OnDestroy pada borang, di mana kami memunggah dll perpustakaan dari ingatan

Prosedur TForm1.FormDestroy(Sender: TObject);
Mulakan
FreeLibrary(LibHandle);
// Nyahmuat perpustakaan daripada ingatan.
Tamat;

Itu sahaja! Kaedah kedua ternyata agak menyusahkan, tetapi kelebihannya adalah untuk menjelaskan objek yang disimpan di perpustakaan.

P.S. Adakah anda ingin menerima pelajaran Video terkini, podcast Audio, artikel tentang Delphi mendahului semua pelawat tapak lain?
Sertai pertandingan dan secara beransur-ansur menyertai pasukan kami?!
Kemudian sekarang langgan surat berita multimedia percuma tapak
Kami sudah lebih daripada 3500 orang!