Ev / Multimedya/ Dinamik kitaplıklar dll delphi örnekleri. DLL oluşturma

Dinamik kitaplıklar dll delphi örnekleri. DLL oluşturma

DLL- Dinamik Bağlantı Kitaplığı, aksi takdirde, aynı işlevleri yeniden kullanmanıza izin veren bir dinamik bağlantı kitaplığıdır. farklı programlar. Aslında oldukça kullanışlı bir araçtır, özellikle bir kez bir kütüphane yazıldığından birçok programda kullanılabilir. Bugünün dersinde nasıl çalışılacağını öğreneceğiz dll Ve elbette onları yaratın!
Pekala, başlayalım!

İlk Dinamik Bağlantı Kitaplığımızı oluşturarak başlayalım! Hadi gidelim Delfi ve hemen Dosya -> Yeni -> Diğer menüsüne gidin.
Karşımıza aşağıdaki pencere çıkıyor:

Listeden Dinamik Bağlantı Kitaplığı'nı seçin (2009'dan önceki sürümlerde Delfiöğe DLL Sihirbazı olarak adlandırılır).

Sonuç olarak, sadece kodu içeren bir penceremiz var, dikkat edin, burada herhangi bir formumuz yok!
Şimdi eğlence başlıyor. İlk prosedürlerimizi kütüphanede yazalım.

kütüphane Projesi2;
//Muhtemelen bunu program yerine fark etmişsinizdir
//dll oluşturulurken word library kullanılır.
// İşaretleyici kitaplığı.
kullanır
Sysutil'ler, diyaloglar,
sınıflar; // Dikkat! Bu modülleri dahil etmeyi unutmayın,
// aksi takdirde kod çalışmaz
($R*.res)
(BU BÖLÜM DLL KODUNU YERLEŞTİRECEKTİR)

İlk Prosedür Çağrısı; çağrı; ihracat;
//Stdcall - Bu ifade, parametreleri yığına iter
//sağdan sola ve hizalanmış standart değer
//Dışa aktarma, ilke olarak atlanabilir, açıklama için kullanılabilir
//dışa aktarma prosedürü veya işlevi.
Başlamak
Mesajı Göster(" Dll'deki ilk prosedürüm");

son;

DoubleProcedureCall; çağrı; ihracat;
Başlamak
Mesajı Göster(" ikinci prosedürüm");
// Mesajı ekrana çağır
son;

FirstCall, DoubleCall'ı dışa aktarır;
//Exports, dışa aktarılan öğelerin bir listesini içerir.
//Daha sonra bir program tarafından içe aktarılacak.
başlamak
son.

Şimdilik burada duracağız. İçin basit bir örnek bu yeterli olacaktır. Şimdi projemizi kaydediyoruz, şahsen Project2.dll adı altında kaydettim ve kütüphaneyi derlemek için CTRL + F9 tuş kombinasyonuna basıyorum. dpr dosyasını kaydettiğiniz klasörde dll uzantılı bir dosya görünmelidir, bu bizim yeni oluşturduğumuz kütüphanedir. Project2.dll olarak adlandırdım

Şimdi bu kütüphaneden çağırma prosedürlerini ele alalım. Standart şemaya göre yeni bir uygulama oluşturuyoruz. Önümüzde sıra dışı bir şey yok, sadece bir form. Yeni uygulamayı bir klasöre kaydediyoruz. Ve aynı klasörde yeni oluşturulanları kopyalıyoruz dll kitaplığı. Onlar. bu örnekte Project2.dll

Şimdi fonksiyonları kütüphaneden nasıl çağıracağınızı seçmelisiniz. Toplamda iki çağrı yöntemi vardır.

Yöntem numarası 1
Belki de bu, kitaplıktaki yordamları çağırmanın en basit yöntemidir.
Yalnızca bir kitaplık ile çalışmak için idealdir.

İşte başlıyoruz...
Uygulama anahtar sözcüğünden sonra aşağıdaki kodu yazın:

İlk Prosedür Çağrısı; çağrı; harici "Project2.dll" ;
// Project2.dll bunun yerine herhangi bir kitaplık adı olabilir
DoubleProcedureCall; çağrı; harici "Project2.dll" ;

Burada tahmin etmiş olabileceğiniz gibi prosedürlerimizin isimlerini programa söylüyoruz ve içinde olduklarını söylüyoruz. dll kitaplığı, benim durumumda Project2.dll adlı

Şimdi, bu prosedürleri çağırmak için, şimdi yapacağımız kodun herhangi bir yerine isimlerini girmemiz yeterli. Standard sekmesinden forma 2 adet Button componenti atıyoruz ve her birinde OnClick event handler oluşturuyoruz.

İlk düğmenin OnClick'i:

Başlamak
ilk arama;
son;

İkinci düğmenin Tıklanması:

Başlamak
çift arama; // Dll'deki prosedürün adı
son;

Bu kadar!

Yöntem numarası 2:
İlkinden daha karmaşık ama avantajları var ve en önemlisi eklentiler için ideal.
Uygulama için Bu method, her şeyden önce birkaç global değişken bildiririz:

Var
LibHandle: HModule; //Kütüphane modülüne bağlantı
FirstCall: prosedür; çağrı;
//Kütüphanedeki prosedürlerimizin isimleri.
DoubleCall: prosedür; çağrı;

Daha sonra implementasyon anahtar kelimesinden sonra kütüphanemizi yükleyecek bir prosedür yazıyoruz:

Yordamı YükleMyLibrary(DosyaAdı: Dize);
Başlamak
LibHandle:= LoadLibrary(PWideChar(DosyaAdı));
//Kütüphaneyi yükleyin!
// Dikkat! 2009 Delphi'nin altındaki sürümler için PChar
LibHandle = 0 ise başlayın
Mesaj Kutusu(0,"",0,0);
çıkış;
son;
FirstCall:= GetProcAddress(LibHandle,"FirstCall ");
//Bir nesneye işaretçi getir
//Kütüphane modülüne 1. parametre bağlantısı
//dll'deki 2. parametre nesne adı
DoubleCall:= GetProcAddress(LibHandle,"DoubleCall");
@FirstCall = nil ise başlayın

İleti Kutusu(0," Kitaplık yüklenemiyor",0,0);
çıkış;
son;
@DoubleCall = nil ise başlayın
//Kütüphanede bu işlevin varlığını kontrol edin.
İleti Kutusu(0," Kitaplık yüklenemiyor",0,0);
çıkış;
son; son;

Bundan sonra, formda, yeni oluşturulan prosedürü kullanarak formumuzu yükleyeceğimiz bir OnCreate olay işleyicisi oluşturuyoruz. kütüphane

Prosedür TForm1.FormCreate(Sender: TObject);
Başlamak
LoadMyLibrary("Project2.dll");
son;

Şimdi yine kütüphanemizden gerekli işlemleri çağırmak için sadece isimlerini kodun herhangi bir yerine yazmamız yeterli. Bunun için Standard sekmesinden forma 2 Button componenti atıyoruz ve her birinde OnClick event handler oluşturuyoruz.

İlk düğmenin OnClick'i:

Prosedür TForm1.Button1Click(Sender: TObject);
Başlamak
ilk arama; // Dll'deki prosedürün adı
son;

İkinci düğmenin Tıklanması:

Prosedür TForm1.Button2Click(Sender: TObject);
Başlamak
çift arama; // Dll'deki prosedürün adı
son;

Son olarak, boşalttığımız form üzerinde bir OnDestroy olay işleyicisi oluşturuyoruz. dll kitaplığı hafızadan

Prosedür TForm1.FormDestroy(Sender: TObject);
Başlamak
FreeLibrary(LibHandle);
//Kütüphaneyi bellekten kaldırın.
son;

Bu kadar! İkinci yöntemin oldukça hantal olduğu ortaya çıktı, ancak avantajı, kitaplıkta depolanan nesneyi iyileştirmektir.

Not: Delphi ile ilgili en son Video eğitimlerini, Sesli podcast'leri ve makaleleri diğer tüm site ziyaretçilerinden önce almak istiyor musunuz?
Yarışmalara katılın ve yavaş yavaş ekibimize katılın?!
O zaman hemen şimdi sitenin ücretsiz multimedya bültenine abone olun
Zaten 3500'den fazla kişiyiz!

Bir DLL, yeniden kullanılabilir kodu tek bir bütün halinde birleştirmenizi sağlar. Uygulama derleme aşamasında statik olarak bağlanan Delphi paketlerindeki işlevlerin aksine, DLL'lerden gelen işlevler çalışma zamanında dinamik olarak bağlanabilir.

Bir DLL kütüphanesi oluşturmak için öncelikle Dosya|Yeni|Diğer menü komutunu çalıştırmanız ve Yeni Öğe iletişim kutusunun Yeni sayfasındaki DLL Sihirbazı öğesini seçmeniz gerekir.

DLL Sihirbazı otomatik olarak oluşturacak boş şablon DLL için. Unit anahtar sözcüğüyle başlayan normal bir modülün aksine, bir DLL modülü library anahtar sözcüğüyle başlar. Bir DLL modülünün kullanımlar bölümü yalnızca iki paketin dahil edilmesini gerektirir: SysUtils ve Classes.

Bir DLL işlevi oluşturmak birkaç adımdan oluşur:

1. İlk olarak, modülün uygulama bölümünde işlev imzasını girin ve işlevin yürüttüğü kodu programlayın.

3. Son olarak, sadece modül içinde değil, diğer uygulamalardan da çağrılan bir fonksiyon, export bölümünde exportable olarak bildirilmelidir.

Bir DLL'den gelen işlevler, hem Delphi'de geliştirilen uygulamalardan hem de C++ gibi diğer programlama dillerinde yazılmış uygulamalardan çağrılabilir.

Parametreler için bellek ayırma ve serbest bırakma sırası, farklı programlama dilleri için farklıdır. Bir çalışma zamanı hatasından kaçınmak için, bir DLL'deki bir işlevin bildirimi ve bir uygulamadaki bildirimi, aynı parametre geçirme mekanizmasını kullanmalıdır. Bir prosedür veya fonksiyon bildirilirken, aşağıdaki parametre geçirme mekanizmalarından biri belirtilebilir:

Parametre geçirme yöntemi, işlev açıklamasından sonra noktalı virgülle belirtilir. Örneğin:

F1(X, Y, Z: Gerçek) işlevi: Gerçek; stdcall;.

Çeşitli yollar parametre geçişleri, parametrelerin geçirilme sırasını (soldan sağa veya sağdan sola) belirler ve ayrıca yığın belleğini kimin serbest bırakacağını (çağrılan prosedür veya çağıran prosedür) belirtir. DLL'leri diğer programlama dillerindeki uygulamalardan çağrılan bileşenler olarak kullanırken, uygun çağrı değiştiriciyi kullanın. C++ uygulamaları için stdcall çağrı değiştiricisi kullanılır.

DLL'de açıklanan bir işlevin başka bir uygulamadan çağrılabilmesi için işlevin dışa aktarılması gerekir. Dışa aktarılan tüm işlevlerin listesi, dışa aktarma bölümünde virgülle ayrılmış olarak gösterilir.

ve noktalı virgülle biter. İşlevler üç şekilde dışa aktarılabilir:

DLL'de kullanılan işlev adına göre;

Dışa aktarma adı olarak verilen işlev adına göre;

İşleve atanan dizine göre.

Bir işleve bazı dizin atamak için, işlev adından sonra dışa aktarma bölümünde belirtilmesi gerekir. anahtar kelime dizin.

Dışa aktarılan işlevin DLL'de kullanılan addan farklı bir adla çağrılabilmesi için, dışa aktarma bölümünde işlev adından sonra bu işlev için name anahtar sözcüğünü ve yeni dışa aktarma adını belirtmeniz gerekir.

DLL - kitaplık çalıştırılabilir bir modül değil. Kodunu almak için projeyi derlemek yeterlidir.

kütüphane projesi;

SysUtils, Sınıflar;

fonksiyon F1(X, Y: Tamsayı): Tamsayı; çağrı;

Bir DLL'yi Statik Bağlama

Bir DLL, statik veya dinamik olarak bağlanabilir. Bir DLL eklendiğinde, uygulamanın belleğine yüklenir.

Statik bir bağlantıyla, uygulama başladığında DLL bir kez yüklenir. Uygulamanın yürütülmesi boyunca, statik olarak bağlı bir DLL'den içe aktarılan bir işlevin adı, aynı DLL'deki aynı işlevi (DLL giriş noktası) işaret eder. Başlangıçta uygulamada kullanılacak DLL'deki tüm işlevlerin harici olarak bildirilmesi gerekir. Bu durumda, gerekirse bir çağrı değiştirici belirtmelisiniz. Bir fonksiyon indeks tarafından çağrılırsa, uygulamada kullanılan isim ve DLL'deki fonksiyonun indeksi verilmelidir.

Harici fonksiyon bildirimleri, bu fonksiyonlar kullanılmadan önce uygulama bölümünde yapılır.

Harici duyuru fonksiyonlar harici anahtar kelime ile statik bağlantının kullanılacağını belirtir.

TForm = sınıf(TForm)

Düzenleme: TEdit; [İlk değeri girme alanı)

Düzenleme2: TDüzenle; (İkinci değeri girme alanı)

Düzenleme3: TDüzenle; (Sonucu görüntülemek için alan

DLL'den bir işlevi yürütme)

Düğme: TButton; (Ada göre kullanılan bir işlevi çağırma)

Düğme2: T Düğmesi; [Dizin tarafından kullanılan bir işlevi çağırma)

prosedür ButtonlClickfSender: TObject);

prosedür Button2Click(Sender: TObject);

(Özel beyanlar)

(Kamu beyanları)

(Dışa aktarılan işlevlerin bildirimi)

fonksiyon Fl (i: Tamsayı; j: Tamsayı): Tamsayı; çağrı;

harici "projectl.dll";

fonksiyon F2 (i: Tamsayı; j: Tamsayı): Tamsayı; çağrı;

harici "Projectl.dll dizin 2;

prosedür TForml.ButtonlClick(Sender: TObject);

(Dışa aktarılan bir işlevi çağırma)

Edit3.Text:=IntToStr(Fl(StrToInt(Editl.Text),StrToInt(Edit2.Text) ));

prosedür TForml.Button2Click(Sender: TObject);

Edit3.Text:=JntToStr(F2(StrToInt(Editl.Text),StrToInt(Edit2.Text)));

Bir DLL'nin dinamik bağlantısı

Bir uygulama yüklendiğinde ortaya çıkan bir DLL için statik bağlantıdan farklı olarak, bir DLL için dinamik bağlantı, programın yürütülmesi sırasında herhangi bir noktada yapılabilir. Bir işlev DLL'den çağrıldıktan sonra devre dışı bırakılabilir. Birkaç DLL kitaplığının eşzamanlı kullanımıyla bu, bellekte önemli bir tasarruf sağlar. Bir DLL dosyasını dinamik olarak bağlamak için Windows API işlevlerini kullanın. Windows API'si - bu bir dizi standart özellikler A, işletim sistemiyle etkileşimi gerçekleştirmek için kullanılır.

Bir dinamik bağlantı DLL'sinden işlev çağırırken, statik bağlantı durumunda işlev adını harici olarak tanımlamak yerine, çağrılan işlevin türüyle eşleşen yeni bir tür tanımlamalı ve bu türde bir değişken oluşturmalısınız.

Dinamik bağlantı DLL'sinden bir işlevi çağırmak için aşağıdakileri yapın:

1. Yeni bir tür oluşturun. çağrılan fonksiyonun tipine karşılık gelir (tip kısmından sonra yeni tipin adı girilebilir).

Örneğin:

TMyFl=işlev(i,j:Tamsayı):Tamsayı; çağrı;

2. Modülün arabirim bölümünün var bölümünde, oluşturulan işlev türünden bir değişken oluşturun. Örneğin: MyFl: TMyFl;

3. DLL'yi yüklemeden önce, içerilen kitaplığın tanımlayıcısını içerecek bir Tamsayı değişkeni bildirin.

4. DLL'yi yükleyen LoadLibrary yöntemini çağırın. Örneğin; h:=LoadLibrary("Projectl.dll");

5. Kütüphane bağlantısının başarılı olup olmadığını kontrol edin. DLL adı yanlışsa veya DLL bulunamazsa, LoadLibrary işlevi 0 döndürür.

6. DLL kitaplığının başarılı bir şekilde bağlanması durumunda, işlevin adresini almalısınız. Bunun için kullanılır Windows işlevi DLL kitaplığı tanımlayıcısını ve eklenti işlevinin adını parametre olarak belirten API GetProcAddress. Örneğin: @MyFl: =GetProcAddress(h, " Fl ");

7. Fonksiyonun adresi elde edilirse, adresin değeri (bizim örneğimizde @MyFl) sıfıra eşit olmamalıdır.

8. Bu noktada, dinamik olarak bağlı DLL'den işlevi çağırabilirsiniz.

9. DLL'yi serbest bırakmak ve kaldırmak için, DLL'nin bağlantısını kaldıran FreeLibrary yöntemini çağırın.

Windows, Mesajlar, SysUtils, Değişkenler, Sınıflar, Grafikler,

Kontroller, Formlar, Diyaloglar, StdCtrl'ler;

TForm = sınıf(TForm)

Düğme3: T Düğmesi;

prosedür Button3Click

prosedür TForml.Button3Click(Sender: TObject);

h:=LoadLibrary("Projectl.dll");

eğer h<>0 o zaman

@MyFl:=GetProcAddress(h,"Fl");

eğer @MyFl<>sıfır o zaman

Edit3.Text:=IntToStr(MyFl(StrToInt(Editl.Text),

StrToInt(Düzenle2.Metin));

Ortak modal iletişim kutularını çağırmak için bir DLL kullanma.

Bir DLL kitaplığından bir yordam yürütmenin sonucu, bazı kalıcı iletişim pencerelerinin görüntülenmesi olabilir. Bunu yapmak için, dışa aktarılan yöntemde bir form nesnesi oluşturun, bunu kalıcı bir iletişim kutusu olarak görüntüleyin ve ardından form nesnesini silin. Bu durumda formun kendisi, diyaloğu sonlandırmak için Close yöntemine bir çağrı sağlamalıdır.

Bir form oluşturmak için, çağıran uygulamanın formu olan ana forma bir işaretçiyi parametre olarak ileten Create yöntemi kullanılır. Bu parametre, çağrılan DLL işlevine iletilir.

kütüphane projesi;

"Unitl_DLL.pas" (Forml) içindeki Unitl_DLL;

prosedür MyModalForm (var Z:Integer ;F:TForm1); çağrı;

Form1:=TForml.Create(F);

(Yordam çağrıldığında F parametresi iletilir ve bir işaretçi içerir.

ana forma - çağıran uygulamanın formu)

Programlama teknolojilerinin hızlı gelişimi nedeniyle, giderek daha fazla insan programlarının yeteneklerini artırma sorunuyla karşı karşıya kalmaktadır. Bu makale, bu soruna, yani Borland Delphi'de DLL programlamaya ayrılmıştır. Ek olarak, DLL kullanma konularına değineceğimiz için, diğer kişilerin DLL'lerinden (sistem olanlar, yani WinAPI dahil) içe aktarma işlevlerine de değineceğiz.

DLL Uygulamaları

Peki, DLL'lere neden ihtiyaç duyulur ve nerede kullanılırlar?.. İşte uygulama alanlarından sadece birkaçı:

Ayrı Kitaplıklar programcılar için faydalı içerikler Ek fonksyonlar. Örneğin, dizelerle çalışmak için işlevler veya görüntüleri dönüştürmek için karmaşık kitaplıklar.
Kaynak depoları. Bir DLL'de yalnızca programları ve işlevleri değil, aynı zamanda her türlü kaynağı - simgeler, resimler, dize dizileri, menüler vb.
Destek Kitaplıkları. Bir örnek, aşağıdakiler gibi iyi bilinen paketlerin kitaplıklarıdır: DirectX, ICQAPI(ICQ için API), OpenGL vesaire.
programın bölümleri. Örneğin, bir DLL program pencerelerini (formları) vb. depolayabilir.
Eklentiler(Eklentiler). - Programcının düşüncelerinin gerçek kapsamı burasıdır! Eklentiler, programın yeteneklerini artıran eklentilerdir. Örneğin, bu yazıda kendi programınız için bir eklenti oluşturma teorisine bakacağız.
Paylaşılan kaynak. DLL( Dinamik Bağlantı Kitaplığı) aynı anda birkaç program veya işlem tarafından kullanılabilir (sözde. paylaşım- paylaşılan kaynak)

DLL ile çalışmak için işlevlerin ve püf noktalarının kısa açıklaması

Peki, bir DLL ile çalışmak için hangi püf noktalarını ve işlevleri kullanmanız gerekiyor? Kitaplıktan işlevleri içe aktarmak için iki yöntemi inceleyelim:

1 yol. Bir DLL'yi bir programa bağlama. Bu, bir DLL'den içe aktarılan işlevleri kullanmanın en basit ve en kolay yöntemidir. Ancak (ve buna dikkat etmelisiniz) bu yöntemin çok önemli bir dezavantajı vardır - programın kullandığı kitaplık bulunamazsa, program bir hata vererek ve DLL kaynağının bulunamadığını bildirerek başlamaz. Ve kitaplık aranacaktır: geçerli dizinde, program dizininde, WINDOWS\SYSTEM dizininde vb.
Yeni başlayanlar için - bu tekniğin genel şekli:

uygulama
...
işlev FunctionName(Par1: Par1Type; Par2: Par2Type; ...): ReturnType; stdcall; harici"DLLNAME.DLL" isim"Fonksiyon adı" dizin FuncIndex;
// veya (işlev değil, prosedür ise):
prosedür ProsedürAdı(Par1: Par1Type; Par2: Par2Type; ...); stdcall; harici"DLLNAME.DLL" isim"prosedür adı" dizin ProcIndex;

Burada: Fonksiyon adı(veya ProsedürAdı) - programınızda kullanılacak işlevin (veya prosedürün) adı;
Par1, Par2, ...- işlev veya prosedür parametrelerinin adları;
Par1Type, Par2Type, ...- bir işlev veya prosedürün parametre türleri (örneğin, tamsayı);
dönüş tipi- dönüş değeri türü (yalnızca bir işlev için);
stdcall- DLL'nin kendisinde kullanılanla tam olarak eşleşmesi gereken bir yönerge;
harici "DLLNAME.DLL"- içe aktarılacağı harici DLL'nin adını belirten yönerge verilen işlev veya prosedür (bu durumda - DLLNAME.DLL);
adı "İşlevAdı" ("YordamAdı")- DLL'nin kendisinde bir işlevin tam adını belirten bir yönerge. Bu, programda gerçek adından (kütüphanede bulunan) farklı bir işleve sahip bir işlevi kullanmanıza izin veren isteğe bağlı bir yönergedir;
dizin FunctionIndex(ProcedureIndex)- bir DLL'deki bir işlev veya yordamın sıra numarasını belirten bir yönerge. Bu aynı zamanda isteğe bağlı bir direktiftir.

2 yol. Dinamik DLL yükleme. Bu çok daha karmaşık ama aynı zamanda daha zarif bir yöntemdir. İlk yöntemin dezavantajı yoktur. Hoş olmayan tek şey, bu tekniği uygulamak için gereken kod miktarıdır ve zorluk, DLL'den içe aktarılan işlevin yalnızca bu DLL yüklendiğinde ve bellekte olduğunda kullanılabilir olmasıdır ... Aşağıda bir örnek bulunabilir, ama şimdilik - Kısa Açıklama Bu yöntemle kullanılan WinAPI işlevleri:

Yük Kitaplığı(libfilename: PChar) - belirtilen LibFileName kitaplığının belleğe yüklenmesi. Başarılı olduğunda, işlev bir tanıtıcı ( TTutucu) DLL bellekte.
GetProcAddress(Modül: TTutucu; İşlem Adı: PChar) - dışa aktarılan kitaplık işlevinin adresini okur. Başarılı olduğunda, işlev bir tanıtıcı ( TFarProc) yüklü DLL'de çalışır.
ücretsiz kitaplık(LibModül: TTutucu) - LibModule'ü geçersiz kılar ve onunla ilişkili belleği boşaltır. Bu yordam çağrıldıktan sonra, bu kitaplığın işlevlerinin artık kullanılamayacağına dikkat edilmelidir.

Uygulama ve örnekler

Pekala, şimdi yukarıdaki yöntem ve tekniklerin kullanımına ilişkin birkaç örnek vermenin zamanı geldi:

Şimdi aynı şey, ancak ikinci şekilde - dinamik yükleme ile:

(... İşte dosya başlığı ve TForm1 formunun ve onun Form1 örneğinin tanımı geliyor)

var
Form1: TForm1;
GetSimpleText: işlev(LangRusça: Boolean): PChar;
LibHandle: Thandle;

prosedür Button1Click(Sender: TObject);
başlamak
("İşlevin adresini" kirden temizliyoruz ")
@GetSimpleText:= sıfır;
(Kitaplığı yüklemeye çalışıyorum)
LibHandle:= LoadLibrary("MYDLL.DLL");
(Her şey yolundaysa)
LibHandle >= 32 ise başlayın
(... o zaman kütüphanedeki fonksiyonun adresini almaya çalışıyoruz)
@GetSimpleText:= GetProcAddress(LibHandle,"GetSimpleText");
(Burada her şey yolundaysa)
if @GetSimpleText<>sıfır o zaman
(... sonra bu fonksiyonu çağırırız ve sonucu gösteririz)
ShowMessage(StrPas(GetSimpleText(True)));
son;
(Ve belleği boşaltmayı ve DLL'yi kaldırmayı unutmayın)
FreeLibrary(LibHandle);
son;

NOT : Kütüphane fonksiyonlarında string tipini kullanmaktan kaçınmalısınız, çünkü kullanırken "bellek paylaşımı" ile ilgili sorunlar var. Bununla ilgili daha fazla bilgiyi (ancak İngilizce olarak) Delphi'nin oluşturduğu boş DLL projesinin metninde (Dosya -> Yeni -> DLL) okuyabilirsiniz. Bu yüzden PChar'ı kullanmak ve ardından gerekirse onu StrPas ile bir dizgeye dönüştürmek daha iyidir.

Şimdi doğrudan DLL'nin kendisini inceleyelim:

DLL kaynaklarına ve formlarına yerleştirme

Bir DLL'de yalnızca işlevleri değil, imleçleri, resimleri, simgeleri, menüleri, metin satırlarını da yerleştirebilirsiniz. Bununla kalmayacağız. Yalnızca kaynağı yüklemek için DLL'yi yüklemeniz gerektiğini ve ardından tanımlayıcısını aldıktan sonra kaynağın kendisini uygun işlevle (LoadIcon, LoadCursor, vb.) Yüklemeniz gerektiğini not edeceğim. Bu bölümde uygulama pencerelerinin (yani Delphi'deki formların) DLL'ler içindeki yerleşimine kısaca değineceğiz.

Bunu yapmak için yeni bir DLL oluşturmanız ve ona eklemeniz gerekir. yeni form(Dosya -> Yeni -> DLL ve ardından Dosya -> Yeni Form). Ayrıca, form bir iletişim kutusu ise ( modal biçim(bsDialog)), ardından DLL'ye aşağıdaki işlevi ekliyoruz (diyelim ki formun adı Form1 ve sınıfı TForm1):

DLL'ye kalıcı olmayan bir form yerleştirmeniz gerekiyorsa, formu açma ve kapatma olmak üzere iki işlev yapmanız gerekir. Bu durumda, DLL'yi bu formun tanıtıcısını hatırlamaya zorlamanız gerekir.

eklenti oluşturma

Burada eklentileri ayrıntılı olarak ele almayacağız çünkü. Yukarıda zaten verilen örnekler, DLL programlamanın aslan payını kolayca anlamanıza yardımcı olacaktır. Eklentinin, programın yeteneklerini genişleten bir ek olduğunu size hatırlatmama izin verin. Aynı zamanda, programın kendisi mutlaka bu tür eklemelerin varlığını sağlamalı ve amaçlarını yerine getirmelerine izin vermelidir.

Bu, örneğin, bir eklenti oluşturmak için grafik editörü, görüntü dönüşümü gerçekleştirecek, eklentide en az iki işlev sağlamanız gerekir (ve buna göre, bu işlevleri programda çağırın) - eklemek için eklentinin adını (ve / veya türünü) döndürecek bir işlev Bu eklentiyi menüye (veya araç çubuğunda) artı ana işlev, bir görüntü iletmek ve almaktır. Onlar. program önce eklentileri arar, ardından bulunan her biri için tanımlayıcı işlevini kesin olarak tanımlanmış bir adla (örneğin GetPluginName) çağırır ve istenen öğeyi menüye ekler, ardından kullanıcı bu öğeyi seçtiyse çağırır girdi görüntüsünü (veya bu görüntüyü içeren dosya adını) ileten ikinci işlev ve bu işlev de görüntüyü işler ve onu yeni bir biçimde (veya yeni bir görüntü içeren bir dosya adıyla) döndürür. Eklentinin tüm amacı bu ... :-)

sonsöz

Bu makale, Borland Delphi'de DLL kullanmanın ve oluşturmanın ana yönlerini gösterir. Herhangi bir sorunuz varsa - bana e-posta ile gönderin: [e-posta korumalı] ve daha da iyisi - diğer kullanıcıların sorunuzu görebilmesi ve yanıtlamaya çalışabilmesi için bu sitenin konferansına yazın!

Karik Nikolai. Moskova bölgesi, Zhukovski

Kısaltma DLL"dinamik olarak bağlı kitaplık" anlamına gelir. Delphi'de dll Yürütme aşamasında programın bağlı olduğu bir bilgisayar programının çalışması için gerekli olan prosedürleri ve fonksiyonları içeren dosyadır.

Görünüşe göre gerekli tüm alt programlar programın gövdesinde açıklanabilir, neden ek bir program oluşturmanız gerekiyor? dll dosyası ve çalışma zamanında buna bağlanılsın mı? Bu daha fazla esneklik için yapılır. oluşturulan program. Nitekim zaman içinde bazı veri işleme algoritmaları değişebilir. İşleme prosedürleri programın gövdesinde yer alacaksa, yeniden derlenmesi ve oldukça büyük bir dosya ile müşterilere yeniden aktarılması gerekecektir. Yalnızca birkaç prosedür içeren küçük bir dll dosyasını aktarmak çok daha kolaydır ve hatta otomatik olarak gerçekleşir.

Ayrıca iş dll'ler oluşturulacağı programlama dilinden tamamen bağımsızdır. Bu nedenle, programımız için bir dll oluşturulmasını, konuştukları programlama dillerini düşünmeden üçüncü taraf geliştiricilere emanet edebiliriz. Tüm bunlar, elbette, bitmiş projenin oluşturulmasını ve müşterilere aktarılmasını büyük ölçüde hızlandırır.

DLL oluşturma

Delphi'de bir dll oluşturma oluşturmak artık zor değil ek modül. Dosya -> Yeni -> -> Diğer... komutunu yürütün Görüntülenen iletişim kutusunda DLL Wisard simgesini seçin. Sonuç olarak, Delphi bir saplama DLL projesi yaratacaktır:

kütüphane 1. Proje;

(DLL bellek yönetimi hakkında önemli not: ShareMem,
kitaplığınızdaki ilk birim USES yan tümcesi VE projeniz (seçin
Project-View Source) USES yan tümcesi, DLL'niz herhangi bir prosedürü dışa aktarırsa veya
dizeleri parametre veya işlev sonuçları olarak ileten işlevler. Bu
DLL'nize ve DLL'nizden iletilen tüm dizeler için geçerlidir --
kayıtlar ve sınıflar içinde iç içedir. ShareMem, arayüz birimidir.
birlikte dağıtılması gereken BORLNDMM.DLL paylaşılan bellek yöneticisi
DLL'niz ile. BORLNDMM.DLL kullanmaktan kaçınmak için dize bilgilerini iletin
PChar veya ShortString parametrelerini kullanarak. )

kullanır
sistem,
sınıflar;

($R*.res)

başlamak
son.

Yeni dll için bir ad seçin ve komutu çalıştırarak ayrı bir klasöre kaydedin. dosya -> Farklı kaydet... Klasörde, aralarında gerçek bir dll dosyası olmayacak 4 dosya görünecektir. Doğal olarak, sadece metin dosyaları, projenin açıklamasını içerir. Son dll dosyasını oluşturmak için projeyi derlemeniz gerekir. komutu yürüt proje -> Derleme Projesi. Sonuç olarak, klasörümüz aslında şunları içerecektir: dll dosyası, ana programın bağlanacağı.

Şimdiye kadar, bu boş bir kütüphane.

...metin şu anda düzenleniyor...

giriiş

DLL Uygulamaları

Peki, DLL'lere neden ihtiyaç duyulur ve nerede kullanılırlar?.. İşte uygulama alanlarından sadece birkaçı:

Ayrı Kitaplıklar Programcılar için faydalı ek işlevler içerir. Örneğin, dizelerle çalışmak için işlevler veya görüntüleri dönüştürmek için karmaşık kitaplıklar. Kaynak Depoları Bir DLL yalnızca programları ve işlevleri değil, aynı zamanda simgeler, resimler, dize dizileri, menüler vb. gibi her türden kaynağı da depolayabilir. Destek Kitaplıkları Örnekler, DirectX, ICQAPI (ICQ için API), OpenGL, vb. gibi iyi bilinen paketlerin kitaplıklarını içerir. Bir programın bölümleri Örneğin, bir DLL, program pencerelerini (formları) vb. depolayabilir. Eklentiler (Eklentiler) Programcının düşünceleri için gerçek alan burasıdır! Eklentiler, programın yeteneklerini artıran eklentilerdir. Örneğin, bu yazıda kendi programınız için bir eklenti oluşturma teorisine bakacağız. Paylaşılan bir kaynak DLL (Dinamik Bağlantı Kitaplığı), aynı anda birkaç program veya işlem tarafından kullanılabilir (paylaşım, paylaşılan bir kaynaktır).

DLL ile çalışmak için işlevlerin ve püf noktalarının kısa açıklaması

Peki, bir DLL ile çalışmak için hangi püf noktalarını ve işlevleri kullanmanız gerekiyor? Kitaplıktan işlevleri içe aktarmak için iki yöntemi inceleyelim:

1 yol. Bir DLL'yi bir programa bağlama.

Bu, bir DLL'den içe aktarılan işlevleri kullanmanın en basit ve en kolay yöntemidir. Ancak (ve buna dikkat etmelisiniz) bu yöntemin çok önemli bir dezavantajı vardır - programın kullandığı kitaplık bulunamazsa, program bir hata vererek ve DLL kaynağının bulunamadığını bildirerek başlamaz. Ve kitaplık aranacaktır: geçerli dizinde, program dizininde, WINDOWS\SYSTEM dizininde vb. Yeni başlayanlar için - bu tekniğin genel şekli:

FonksiyonAdı (veya ProsedürAdı) programınızda kullanılacak fonksiyonun (veya prosedürün) adı; Par1, Par2, ... işlev veya prosedür parametrelerinin adları; Par1Type, Par2Type, ... işlev türleri veya prosedür parametreleri (örneğin, Tamsayı); ReturnType dönüş tipi (yalnızca işlev); DLL'nin kendisinde kullanılanla tam olarak eşleşmesi gereken stdcall yönergesi; verilen işlev veya yordamın içe aktarılacağı harici DLL'nin adını belirten harici "DLLNAME.DLL" yönergesi (bu durumda, DLLNAME.DLL); name DLL'nin kendisinde bir işlevin tam adını belirten "FunctionName" ("ProcedureName") yönergesi. Bu, programda gerçek adından (kütüphanede bulunan) farklı bir işleve sahip bir işlevi kullanmanıza izin veren isteğe bağlı bir yönergedir; index FunctionIndex (ProcedureIndex) Bir DLL'deki bir işlev veya yordamın sıra numarasını belirten bir yönerge. Bu aynı zamanda isteğe bağlı bir direktiftir.

Bu çok daha karmaşık ama aynı zamanda daha zarif bir yöntemdir. İlk yöntemin dezavantajı yoktur. Tatsız olan tek şey, bu tekniği uygulamak için gereken kod miktarıdır ve zorluk, DLL'den içe aktarılan işlevin yalnızca bu DLL yüklendiğinde ve bellekte olduğunda kullanılabilir olmasıdır ... Aşağıdaki örneği okuyabilirsiniz, ancak şimdilik - bu yöntemle kullanılan WinAPI işlevlerinin kısa bir açıklaması:

LoadLibrary(LibFileName: PChar) Belirtilen LibFileName kitaplığını belleğe yükler. Başarı durumunda işlev, bellekteki DLL'ye bir tanıtıcı (THandle) döndürür. GetProcAddress(Module: THandle; ProcName: PChar), dışa aktarılan bir kitaplık işlevinin adresini alır. Başarılı olduğunda işlev, yüklenen DLL'deki işleve bir tanıtıcı (TFarProc) döndürür. FreeLibrary(LibModule: Thandle), LibModule'ü geçersiz kılar ve onunla ilişkili belleği boşaltır. Bu yordam çağrıldıktan sonra, bu kitaplığın işlevlerinin artık kullanılamayacağına dikkat edilmelidir.

Uygulama ve örnekler

Pekala, şimdi yukarıdaki yöntem ve tekniklerin kullanımına ilişkin birkaç örnek vermenin zamanı geldi:

Örnek 1: Bir DLL'yi Bir Programa Bağlamak

Şimdi aynı şey, ancak ikinci şekilde - dinamik yükleme ile:

Not:

Kütüphane fonksiyonlarında string tipini kullanmaktan kaçınmalısınız, çünkü kullanırken "bellek paylaşımı" ile ilgili sorunlar var. Bununla ilgili daha fazla bilgiyi (ancak İngilizce olarak) Delphi'nin oluşturduğu boş DLL projesinin metninde (Dosya -> Yeni -> DLL) okuyabilirsiniz. Bu yüzden PChar'ı kullanmak ve ardından gerekirse onu StrPas ile bir dizgeye dönüştürmek daha iyidir.

Şimdi doğrudan DLL'nin kendisini inceleyelim:

Örnek 3. Proje kaynağı MYDLL.DPR

DLL kaynaklarına ve formlarına yerleştirme

Bunu yapmak için yeni bir DLL oluşturmanız ve ona yeni bir form eklemeniz gerekir (Dosya -> Yeni -> DLL ve ardından Dosya -> Yeni Form). Ayrıca, form bir iletişim kutusuysa (modal form (bsDialog)), DLL'ye aşağıdaki işlevi ekleyin (örneğin, formun adı Form1 ve sınıfı TForm1'dir):

Örnek 4 Bir DLL'ye Form Yerleştirme

eklenti oluşturma

Yani, örneğin, görüntü dönüştürme gerçekleştirecek bir grafik düzenleyici için bir eklenti oluşturmak için, eklentide en az iki işlev sağlamanız gerekir (ve buna göre, bu işlevleri programda çağırın) - bir işlev bu eklentiyi menüye (veya araç çubuğuna) eklemek için eklentinin adını (ve/veya türünü) döndürür, artı ana işlev bir görüntü göndermek ve almaktır. Onlar. program önce eklentileri arar, ardından bulunan her biri için tanımlayıcı işlevini kesin olarak tanımlanmış bir adla (örneğin GetPluginName) çağırır ve istenen öğeyi menüye ekler, ardından kullanıcı bu öğeyi seçtiyse çağırır girdi görüntüsünü (veya bu görüntüyü içeren dosya adını) ileten ikinci işlev ve bu işlev de görüntüyü işler ve onu yeni bir biçimde (veya yeni bir görüntü içeren bir dosya adıyla) döndürür. Eklentinin tüm amacı bu ... :-)

sonsöz

Bu makale, Borland Delphi'de DLL kullanmanın ve oluşturmanın ana yönlerini gösterir. Herhangi bir sorunuz varsa - bana e-posta ile gönderin: