Delphi-ში ახალი DLL-ის შესაქმნელად აირჩიეთ მენიუს ბრძანება ფაილი > ახალი > სხვა. პანელზე ნივთების კატეგორიებივიკნა Ახალი ნივთებიაირჩიეთ უნივერსიტეტი დელფის პროექტები, შემდეგ დააწკაპუნეთ ელემენტზე დინამიური ბმული ბიბლიოთეკამარჯვენა პანელზე არის ფანჯარა.

მაისტერი DLL ოსტატიქმნის DLL ბიბლიოთეკის გამომავალი კოდის სათაურ ფაილს, რომელიც ზუსტად ჰგავს პირველადი პროგრამისთვის გამომავალ კოდს. იგივე პასუხისმგებლობა ეკისრება იმას. რომ ეს ფაილი იწყება დაცული სიტყვით ბიბლიოთეკა, მაგრამ არა პროგრამა.

ბიბლიოთეკის პროექტი1; ( მნიშვნელოვანი შენიშვნა DLL მეხსიერების მენეჯმენტის შესახებ: ShareMem უნდა იყოს თქვენი ბიბლიოთეკის USES პუნქტის პირველი ერთეული და თქვენი პროექტის (აირჩიეთ Project-View Source) გამოიყენოს პუნქტი, თუ თქვენი DLL ექსპორტირდება ნებისმიერი პროცედურის ან ფუნქციის, რომელიც გადასცემს სტრიქონებს პარამეტრებად ან გამოიყენება. ყველა სტრიქონს, რომელიც გადაცემულია თქვენს DLL-ზე და თქვენს DLL-ზე - მათაც კი, რომლებიც ჩასმულია ჩანაწერებსა და კლასებში. BORLNDMM.DLL-ის გამოყენებით, გადასცეთ სტრიქონების ინფორმაცია PChar ან ShortString პარამეტრების გამოყენებით. (პროექტი -> გამომავალი კოდის ჩვენება)), რომელსაც თქვენი DLL ექსპორტს ახორციელებს, იქნება ეს პროცედურები. ან ფუნქციები, რომლებიც გადასცემენ რიგებს, როგორც პარამეტრებს ან თანმიმდევრული ფუნქციების შედეგებს. ეს მოიცავს ყველა მწკრივს, რომელიც გადატანილია ან ინახება თქვენი DLL-დან, და ბმულები რიგებთან, რომლებიც შედის ამ კლასის ჩანაწერებში. ShareMem მოდული არის საზიარო მეხსიერების BORLNDMM.DLL ადმინისტრატორის ინტერფეისის მოდული, რომელიც ერთდროულად უნდა შეიქმნას DLL ბიბლიოთეკიდან. BORLNDMM.DLL კომპრომისის თავიდან ასაცილებლად, დაამატეთ მწკრივის ინფორმაცია PChar ან ShortString პარამეტრებს. ) იყენებს SysUtils, Classes; ($R *.res) იწყება დასასრული.

ყველაფერი, რაც ერთდროულად გჭირდებათ, არის ბლოკის წინ ქვეპროგრამის დამატება დასაწყისი-დასრულება, მე ყველაფრისგან. შემდეგ ირჩევთ შიდა ქვეპროგრამას, რომელიც შეგიძლიათ ნახოთ DLL-ში, მაგრამ არა გარე პროგრამებში. თუ გსურთ პროგრამის დაკავშირება სხვა პროგრამებიდან ან სხვა DLL-ებიდან, საჭიროა მისი ექსპორტი. ქვეპროგრამის მათში ექსპორტისთვის, დაამატეთ ისინი სიაში ექსპორტი. სია ექსპორტიაქვს იგივე სინტაქსი, რაც სიას იყენებს, ისევე როგორც სიაში ექსპორტიარის თუ არა რომელიმე ელემენტი ქვეპროგრამა თუ არა მოდული.

სია ექსპორტიგთხოვთ მოათავსოთ ბლოკის წინ დასაწყისი-დასრულება. შეხედეთ ჩამონათვალს 1, რომელიც აჩვენებს გამომავალი კოდს მარტივი ბიბლიოთეკისთვის. FirstLib.dll, რომელიც ახორციელებს ერთი ფუნქციის ექსპორტს.

ჩამონათვალი 1. მარტივი DLL

ბიბლიოთეკა FirstLib; ფუნქცია Max3(Num1, Num2, Num3: Integer): მთელი რიცხვი; stdcall; დასაწყისი შედეგი:= Num1; თუ Num2 > Result მაშინ Result:= Num2; თუ Num3 > Result მაშინ Result:= Num3; დასასრული; (ექსპორტის ფუნქცია Max3) ექსპორტი Max3; დასაწყისი დასასრული.

თუ სიას დაამატებთ ქვეპროგრამას ექსპორტიშემდეგ თქვენ გადაიტანთ პროგრამას მათ სახელზე. თქვენ ასევე შეგიძლიათ ქვეპროგრამის ექსპორტი სხვა სახელებით დამატებითი დირექტივების გამოყენებით სახელიან რიგითი მნიშვნელობის დამატებითი დახმარებისთვის ვიკორისტის დირექტივა ინდექსი. თუმცა დააყენე დირექტივა ინდექსიარარეკომენდირებული.

ქვემოთ მოცემულია ექსპორტის დირექტივის მაგალითი დამატებითი რიგითი მნიშვნელობის გამოყენებით ან სხვა სახელწოდებით:

ექსპორტირდება Max3-ის სახელი "MyMax3Function", SaySomething index 1;

სტატიკური იმპორტი არის DLL-ის იმპორტის ორი შესაძლო ხერხიდან უმარტივესი. სტატიკურ მიზიდულობას ასევე უწოდებენ დინამიურ კავშირებს მიზიდულობის საათში ( დატვირთვის დროის დინამიური კავშირი), რადგან არჩეული DLL ავტომატურად დაინსტალირდება პროგრამების გაშვებისას.

DLL-ზე სტატიკურად წვდომისთვის, თქვენ უნდა დააკოპიროთ იმ ქვეპროგრამებისა და დანამატების განცხადებები, რომლებიც იძახიან და მივანიჭოთ ისინი დამატებით დირექტივებს. გარე, რომელიც აცნობებს შემდგენელს, რომ ქვეპროგრამა მდებარეობს ობიექტის ფაილში ან DLL-ში.

თუ თქვენ იმპორტირებთ რუტინებს DLL-დან, თქვენ უნდა დაასახელოთ ისინი დირექტივებით გარე, მის უკან მიუთითებს DLL ბიბლიოთეკის სახელზე, რომელიც შეიცავს ქვეპროგრამების განხორციელებას. ქვემოთ მოცემულია იმპორტის ფუნქციის მაგალითი MaxZბიბლიოთეკიდან FirstLib.dll:

ფუნქცია Max3(Num1, Num2, Num3: Integer): მთელი რიცხვი; stdcall; გარე "FirstLib.dll";

ამის შემდეგ შეგიძლიათ ქვეპროგრამის გადარქმევა იმპორტამდე. რისთვისაც აუცილებელია ქვეპროგრამის სხვა სახელებით კენჭისყრა და ბოლოს დამატებითი დირექტივების საწყისი სახელების კენჭისყრა სახელი:

ფუნქცია Max(Num1, Num2, Num3: Integer): მთელი რიცხვი; stdcall; გარე "FirstLib.dll" სახელი "Max3";

ასევე შეგიძლიათ ფუნქციების იმპორტი DLL-დან. რატომ გჭირდებათ იმპორტის მოდულის შექმნა და სექციისთვის სტანდარტული ქვეპროგრამის სათაურის დაწერა? ინტერფეისი, ხოლო მისი გარე განხორციელება - განყოფილებაში განხორციელებაამ მოდული. 2 წაკითხვის ჩამონათვალს აქვს ახალი კოდი ბიბლიოთეკის იმპორტის მოდულისთვის FirstLib.dll.

ჩამონათვალი 2. FirstLib.dll ბიბლიოთეკის იმპორტის მოდული.

განყოფილება FirstLibInf; ინტერფეისის ფუნქცია Max3(Num1, Num2, Num3: Integer): მთელი რიცხვი; stdcall; განხორციელება const FirstLib = "FirstLib.dll"; (შემდგენელს ეცნობება, რომ Max3 ფუნქციის განხორციელება არის ბიბლიოთეკა FirstLib.dll) ფუნქცია Max3; გარე FirstLib; დასასრული.

მას შემდეგ რაც შექმნით DLL და იმპორტის მოდულს, გადააბრუნეთ DLL მოცულობაზე. რომ ქვეპროგრამა ნორმალურად მუშაობს. შეუძლებელია თავად DLL-ის გაშვება; თქვენ უნდა შექმნათ სატესტო პროგრამა, რომელიც მიიღებს წვდომას DLL-ზე. ფულის გამომუშავების საუკეთესო გზაა საპროექტო ჯგუფის შექმნა სრულმასშტაბიან პროექტში ახალი პროექტის დამატებით. ამისათვის თქვენ უნდა დააწკაპუნოთ ელემენტზე მარჯვენა ღილაკით ProjectGroup1ფანჯარასთან Პროექტის მენეჯერი(პროექტის მენეჯერი) და აირჩიეთ ბრძანება კონტექსტურ მენიუში დაამატეთ ახალი პროექტი,Yak ნაჩვენებია ნახ. 1.

ჩამონათვალი 3. Max3 ქვეპროგრამების შემოწმება, რომლებიც იმპორტირებულია FirstLib.dll ბიბლიოთეკიდან.

ერთეული ერთეული 1; ინტერფეისი იყენებს Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, FirstLibInf, StdCtrls; ტიპი TMainForm = class(TForm) Edit1: TEdit; Edit2: TEdit; რედაქტირება3: TEdit; Label1: TLabel; Label2: TLabel; Label3: TLabel; Max3Button: TButton; პროცედურა Max3ButtonClick(გამომგზავნი: TObject); კერძო (Private declarations) public (Public declarations) end; var MainForm: TMainForm; განხორციელების ($R *.dfm) პროცედურა TMainForm.Max3ButtonClick(Sender: TObject); var LargestNumber: მთელი რიცხვი; დასაწყისი LargestNumber:= Max3(StrToInt(Edit1.Text), StrToInt(Edit2.Text), StrToInt(Edit3.Text)); MessageDlg(Format("Highest: %d.", ), mtInformation, , 0); დასასრული; დასასრული.

ლიტერატურა წყარო: Inner World Borland Delphi 2006. ივან ხლადნი.

არაერთხელ მქონდა შესაძლებლობა ამომეღო ფურცლები დელფში შექმნის და vikoristan DLL-ის პრობლემისგან. ამ სტატიაში ჩვენ დაგეხმარებით ყველაფრის გაგებაში და საკუთარი ბიბლიოთეკის შექმნაში. დინამიურად დაკავშირებული ბიბლიოთეკები (Dynamic Link Library) იძლევა სხვადასხვა დანამატების შესაძლებლობას, როდესაც მუშაობთ ფარული რესურსების ამოღებაზე. მნიშვნელოვანია, რომ პროცედურები და ფუნქციები, რომლებიც განთავსებულია DLL-ში, დასრულდეს იმ პროცესის შუაში, რომელიც გამოიყენება მათ შესაქმნელად. DLL ითვალისწინებს ყველა დანამატს რესურსის ერთ ასლს, რომელიც მჭიდროდ არის გაანალიზებული ყველა მოთხოვნილი დანამატის მიერ, რათა იყოს ადმინისტრირებული, როგორც ქვეპროგრამები, რომლებიც გაშვებულია თითოეული პროგრამისთვის, რომელმაც მათ დაურეკა, საკუთარი ასლი. თქვენ ასევე შეგიძლიათ ჩართოთ ქვეპროგრამები, სადაც DLL-ებს შეუძლიათ მხოლოდ პროცედურების და ფუნქციების ექსპორტი, მაგრამ არა ტიპები, მუდმივები და ა.შ.

მე მსურს გაკვეთილი ავიღო "გაკვეთილები დელფიდან" მეხსიერების DLL სტრუქტურის შესახებ:

DLL არის ბიბლიოთეკა, რომელიც იმართება პროგრამების მიერ და არ საჭიროებს რაიმე დასტას ან ინფორმაციას. DLL-ებში განთავსებული ფუნქციები შეფუთულია პროგრამის კონტექსტში, რომელმაც გამოიძახა სტეკი. ყველა ეს ფუნქცია გამოიყენება მონაცემთა სეგმენტის შესაქმნელად, რომელიც ეკუთვნის ბიბლიოთეკას და არა პროგრამის ასლს. DLL-ების ამ ორგანიზაციის გამო, მეხსიერების დაზოგვა გამოწვეულია იმით, რომ ყველა გაშვებული პროგრამა იყენებს ერთ DLL მოდულს, მათი მოდულების შენახვაში სხვა სტანდარტული ფუნქციების გარეშე. ხშირად, DLL-ები იქმნება ფუნქციების ნაკრების გარშემო, რომლებიც გაერთიანებულია ამ და სხვა ლოგიკური ნიშნებით, ისევე როგორც მოდულების (ერთეულის გაგებით) კონცეპტუალურად დაგეგმილი პასკალში. განსხვავება მდგომარეობს იმაში, რომ პასკალის მოდულების ფუნქციები დაკავშირებულია სტატიკურად, დაკავშირების ეტაპზე, ხოლო DLL-ების ფუნქციები დაკავშირებულია დინამიურად, გაშვების დროს.

შექმნა DLL

DLL სტრუქტურა ოდნავ განსხვავდება Object Pascal მოდულის ძირითადი სტრუქტურისგან. DLL იწყება სიტყვებით Library, რასაც მოჰყვება ბიბლიოთეკის სახელი. ფუნქციები და პროცედურები, როგორიცაა DLL-ები, რომლებიც მინიჭებულია სხვა კლიენტებზე (ექსპორტი), აღდგება ექსპორტის დირექტივის შემდეგ.

კანის პროცედურის ან ფუნქციისთვის, შეგიძლიათ მიუთითოთ რიცხვი ინდექსის დირექტივის მიხედვით. თუ რიცხვი ყოველდღიურია, შემდგენელი განახორციელებს ავტომატურ ინდექსირებას. პროცედურის ნომრის ნაცვლად, შეგიძლიათ გამოიყენოთ უნიკალური სახელები, როგორც მითითებულია სახელის დირექტივაში. თუ არ არის მითითებული ფუნქციის სახელი ან ნომერი, მაშინ Delphi მიიღებს ექსპორტს იმ სახელებზე, რომლებიც შეესაბამება ფუნქციის სახელს.

ბიბლიოთეკას ასევე შეუძლია განათავსოს ინიციალიზაციის კოდი, რომელიც შეიტანება მისი იმპორტის დროს. იგი მდებარეობს დასაწყისსა და დასასრულს შორის. ღერძის სტრუქტურა DLL:

ბიბლიოთეკა First_Dll; იყენებს<используемые модули>; <объявления и описания функций>ექსპორტი<экспортируемые функции> <описание процедур и функций>დაიწყება<инициализационная часть>დასასრული.

ექსპორტის განყოფილებაში წარმოგიდგენთ ექსპორტის ფუნქციების აღწერას:

ექსპორტის ფუნქცია1 ინდექსი 2; ფუნქციის2 სახელი "My_sqr"; ფუნქცია3;

როგორც უკვე მიხვდით, ეს ფუნქციები შეიძლება არ იყოს გამოყენებული ექსპორტისთვის!

Wikoristannya DLL

მოდული, რომელიც მოითხოვს პროცედურებისა და ფუნქციების შეცვლას DLL-ებიდან, დამნაშავეა გარე დირექტივის გაძლიერებაში. DLL-ის შექმნის ორი გზა არსებობს (დინამიური და სტატიკური). პირველ შემთხვევაში, პროგრამამ, რომელიც იძახებს ფუნქციას DLL-დან, იცის ბიბლიოთეკის სახელი და მასში შესვლის წერტილი, სადაც ის გადადის, რათა ბიბლიოთეკა არ შეიცვალოს. სხვა ფანჯარაში არჩეული DLL-ის წინ არის კვალი, რომ საჭირო ბიბლიოთეკა ცარიელი იყოს და არის საჭირო ქვეპროგრამა.

შეგიძლიათ პროგრამის იმპორტი მისი სახელისა და ნომრის გამოყენებით. ნომრის ქვეპროგრამების ძიება უფრო სწრაფად გამოჩნდება, მაგრამ არა ხელით.

ქვემოთ მოცემულია ჩვენი First_DLL ფუნქციის იმპორტის მაგალითი, როგორც ეს აპლიკაციაში ჩანს:

(იმპორტი კონკრეტული სახელებით) ფუნქცია ImportByName; გარე "First_DLL" სახელი "My_sqr"; (იმპორტი ინდექსით) ფუნქცია ImportByOrdinal; გარე "First_DLL" ინდექსი 2; (იმპორტი ორიგინალური სახელით) ფუნქცია Function3; გარე "First_DLL";

ჩვენ გადავხედეთ DLL-ის შექმნის სტატიკური მეთოდს. თუმცა, ზოგიერთ სიტუაციაში წინასწარ არ არის ნათელი, თუ როგორ იქნება საჭირო ბიბლიოთეკა, ასე რომ ეს შეიძლება გაკეთდეს სწრაფად დინამიური მეთოდის გამოყენებით:

იყენებს WinTypes, WinProcs, ...; ტიპი TMyProc = პროცედურა; var Handle: THandle; MyImportProc: TMyProc; start Handle:=LoadLibrary("FirstDLL"); თუ სახელური>=32 მაშინ (<=32 - ошибка! } begin @MyImportProc:=GetProcAddress(Handle,"My_sqr"); if MyImportProc<>nil შემდეგ ...... (აქ ფუნქცია ამოღებულია ვიკორის გზით) დასასრული; FreeLibrary(Handle); დასასრული;

მაგრამ ყველაფერი რაც აქ წერია საერთოდ არ არის გასაგები და მინდა რეალური, სრული აპლიკაციები. დავიწყე დაბნეულობა, რადგან სტატიებში რამდენიმე აპლიკაცია იყო და მხოლოდ თეორია, ამიტომ თქვენს პატივისცემას გირჩევთ vikoristan DLL-ის მარტივ მაგალითს.

დააჭირეთ მენიუს File -> New და აირჩიეთ DLL. შეინახეთ მზა შაბლონი, რომელიც შეიქმნება სახელწოდებით Project1.dpr.

ქვემოთ მოცემულია საბოლოო კოდი:

ბიბლიოთეკის პროექტი1; იყენებს SysUtils,Classes; ფუნქცია Function1(x,y:integer):integer; ექსპორტი; bgin შედეგი:=x+y; დასასრული; ფუნქცია Function2(x,y:real):real; ექსპორტი; var t:რეალური; დასაწყისი t:=exp(y*ln(x)); შედეგი:=t; დასასრული; ექსპორტი Function1 ინდექსი 1, Function2 სახელი "My_sqr"; დასაწყისი დასასრული.

აქ არის ორი ფუნქცია, ერთი ითვლის ორი რიცხვის ჯამს და ექსპორტირებულია რიცხვით, ხოლო მეორე ითვლის x საფეხურზე y და ექსპორტირებულია სახელით.

ახლა შევქმნათ ახალი პროექტი და შევინახოთ სხვა პროექტებიდან, მაგალითად, DemoDLL. ფორმაზე ორი ღილაკია, პირველზე დაჭერით პირველ პროცედურაზე დაწკაპუნებთ, მეორეზე კი მეორეზე. ამ დემო პროექტის ახალი კოდის ღერძი:

ერთეულის დემო; ინტერფეისი იყენებს Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; ტიპი TForm1 = class(TForm) ღილაკი1: TButton; ღილაკი 2: TButton; პროცედურა Button1Click(გამომგზავნი: TObject); პროცედურა Button2Click(გამომგზავნი: TObject); კერძო (Private declarations) public (Public declarations) end; var Form1: TForm1; განხორციელების ($R *.DFM) ფუნქცია ImportSumm(x,y:integer):მთლიანი; გარე "Project1" ინდექსი 1; //იმპორტი რიცხვის მიხედვით ფუნქცია ImportSqr(x,y:real):real; გარე "Project1" სახელი "My_sqr"; //პროცედურების დასახელებისთვის იმპორტი TForm1.Button1Click(Sender: TObject); var t:რეალური; დაწყება //აღმოაჩინე რამდენი იქნება ორი მესამე საფეხურზე t:=ImportSqr(2,3); Showmessage(FloatTostr(t)); დასასრული; პროცედურა TForm1.Button2Click(გამომგზავნი: TObject); var t: მთელი რიცხვი; დაწყება //აღმოაჩინე რამდენი იქნება 10+10 t:=ImportSumm(10,10); Showmessage(IntTostr(t)); დასასრული; დასასრული.

დელფი, MySQL პროგრამისტი. გაანათა ადგილი. სპეციალობა: საინფორმაციო ტექნოლოგიების უსაფრთხოების პროგრამული უზრუნველყოფა.

რა არის DLL მინიმუმ, კომპიუტერის მომხმარებელთა უმეტესობამ იცის, რომ მათ აქვთ მეტი პროგრამა, რომელიც უნდა იცოდეთ ყველაფრის შესახებ და წაიკითხოთ ეს სტატია. ამ სტატიაში მე შევეცდები გავერკვეთ ყველა უსარგებლო საკვებში, რომელსაც DLL ავრცელებს.

მოდით, თავად გადავხედოთ მას:

1. კიდევ ერთხელ, "Hello World" ზონაში, ჩვენ შევქმნით საკუთარ DLL-ს.
2. მოდით ვისწავლოთ როგორ გამოვიყენოთ ამ DLL-ის ფუნქციები ჩვენი პროგრამებიდან.
3. დავიწყოთ DLL სიმღერის ექსპორტის ფუნქციების დათვალიერება.
4. Შეიძლება შეიძლება არა.

DLL შექმნის პროცესი

დავიწყოთ უმარტივესი საქმით - დაწერეთ თქვენი საკუთარი DLL, რათა გქონდეთ მხოლოდ ერთი ფუნქცია, ეს არის "Hello World" შეტყობინების ჩვენება.

1. გაუშვით Delphi (მე ვიყენებ Delphi 6-ს).
2. გადადით: ფაილი -> ახალი -> სხვა

New Doors ჩანართზე დააწკაპუნეთ DLL Wizard ობიექტზე. ახალი პროექტი იწყება. შეინახეთ ის, მაგალითად, MyFirstDLL-ით.

სუფთა მოდულს აქვს მსგავსი რამ:

ბიბლიოთეკა MyFirstDLL; იყენებს SysUtils, Classes; ($R *.res) იწყება დასასრული.

ახლა მოდით დავწეროთ კიდევ ერთი ფუნქცია, როგორიცაა ShowMessage() Dialogs მოდულიდან. ახლა, პროცედურის დაწყებამდე, მოდით დავამატოთ Dialogs მოდული გამოყენების განყოფილებაში. დაახლოებით რისი ნახვა შეგიძლიათ:

ბიბლიოთეკა MyFirstDLL; იყენებს დიალოგებს; პროცედურა MyFirstFunc; stdcall; დაწყება ShowMessage ("Hello World"); დასასრული; ექსპორტს MyFirstFunc; დასაწყისი დასასრული.

მოგეხსენებათ, აქ არაფერია რთული. ნება მომეცით უბრალოდ გითხრათ, რომ თქვენ შეგიძლიათ დარეკოთ ფუნქციები სახელით ან ინდექსით (ნომრით), რისთვისაც თქვენ უნდა დაწეროთ ასე:

ექსპორტი MyFirstFunc ინდექსი 1;

თუ ამ კოდში არაფერი გესმით, მაშინ მაინც შეეცადეთ თავად გაარკვიოთ. მე ვფიქრობ, რომ პრობლემა არ იქნება... Ale yakscho scho, მაშინ ფორუმი! ვნახოთ, როგორ შეგიძლიათ ახლა წვდომა მნიშვნელობის (MyFirstFunc) ფუნქციაზე სხვა პროექტებიდან?

Vikoristannya ფუნქცია DLL

პირველი ნატეხი დამსხვრეულია, მარჯვნივ პატარას უკან... როგორ გავაუმჯობესოთ ეს ფუნქცია?

და, მინიმუმ, ორი მიზიდულობის გზა:

1. სტატიკური
2. დინამიური

სხვა გზა უფრო მარტივია, რათა მიზიდულობის დროს მივყვეთ იმას, რაც მოსალოდნელია და შევძლოთ ვმართოთ ყველა ის სარგებელი, რომელიც წარმოიქმნება მიზიდულობის დროს. ალე, პირველ რიგში, მე მიკვირს პირველი მეთოდი:

მოდით შევქმნათ ახალი პროექტი, დავაგდოთ ერთი ღილაკი ფორმაზე და დავწეროთ OnClick ღილაკის გვერდით:

პროცედურა TForm1.Button1Click(Sender: TObject); დაიწყე MyProc(); დასასრული;

ეს ყველაფერი არ არის! პროექტის განხორციელების განყოფილებაში ჩაწერეთ:

განხორციელების პროცედურა MyProc(); stdcall; გარე "MyFirstDLL.dll" სახელი "MyFirstFunc";

მზადაა! შეადგინეთ პროექტი და დააჭირეთ ღილაკს! როგორც კი თქვენი ინფორმაცია მიიღება, ყველაფერი რიგზეა!

ახლა მოდით შევხედოთ დინამიური მიზიდულობის მეთოდს. ამ მეთოდისთვის გამოიყენეთ LoadLibrary() ფუნქცია და ბოლოს ვიზუალიზაციისთვის გამოიყენეთ FreeLibrary() ფუნქცია.

გაოცება უკანალით:

პროცედურა TForm1.Button1Click(Sender: TObject); ტიპი TMyFunc = პროცედურა; var DLLInstance: THandle; MyFunc: TMyFunc; start DLLInstance:= LoadLibrary(PChar("MyFirstDLL.dll")); if (DLLInstance = 0) მაშინ დაიწყეთ MessageDlg("Unable to enlist DLL", mtError, , 0); გასვლა; დასასრული; სცადეთ @MyFunc:= GetProcAddress(DLLInstance, "MyFirstFunc"); if Assigned(@MyFunc) then MyFunc() else MessageDlg("საჭირო პროცედურა ვერ მოიძებნა!", mtError, , 0); ბოლოს FreeLibrary(DLLInstance); დასასრული; დასასრული;

LoadLibrary() ფუნქციით DLL-ის წარმატებით შეძენის შემდეგ, GetProcAddress()-ის გამოყენებით ჩვენ ვიგებთ ჩვენი ფუნქციის მისამართს, სადაც ჩვენ ვუწოდებთ ჩვენს პროცედურას DLL-დან. საბოლოოდ, რა თქმა უნდა, თქვენ უნდა შექმნათ FreeLibrary(). მნიშვნელოვანია, რომ ყველა კოდი წარმატებული შეძენის შემდეგ, FreeLibrary()-მდე მოთავსდეს საცდელ საბოლოოდ ბლოკში. ეს გარანტირებულია FreeLibrary სისტემის მიერ, რომელიც შესრულდება ცდის შუაში, გარდა ბლოკისა და გამონაკლისი არ გაიგზავნება.

მარჯვნივ არის ის, რომ წარმატებული დაწკაპუნებით LoadLibrary და FreeLibrary, როგორც წესი, ბიჭები არიან. მე ღერძი რატომ. სისტემა კანის ბიბლიოთეკისთვის, რომელიც ჩართულია პროცესში, შეიცავს მკურნალს, რომელიც იზრდება 1-ით, როდესაც კანი წარმატებით დააჭერს LoadLibrary-ს. როგორც ჩანს, როდესაც FreeLibrary წაიშლება, ის ცვლის ამ მნიშვნელობას და ხდება ნულის ტოლი, რაც ნიშნავს, რომ ეს ბიბლიოთეკა აღარ არის საჭირო ამ პროცესისთვის და მისი უსაფრთხოდ წაშლა შესაძლებელია m'yati-დან.

თუ დაწყვილების წესი არ არის დაცული, მაშინ ეს შეიძლება გაკეთდეს ან მეხსიერებიდან ბიბლიოთეკის დაუყოვნებელ აღდგენამდე (თუ FreeLibrary არის დაინსტალირებული), ან მანამდე, სანამ ის იქ „ჩარჩება“ (თუ FreeLibrary არ არის დაინსტალირებული).

ამ წესით, არ არის საჭირო ფიქრი LoadLibrary / FreeLibrary დაწკაპუნების შესაძლო წვლილზე.

სიმღერის DLL ფუნქციების მიმოხილვა

ახლა ჩვენ ვხედავთ, თუ როგორ არის შესაძლებელი ყველა ფუნქციის სახელის ამოღება PE ფორმატის ფაილებიდან, DLL-ების ჩათვლით. თუმცა, PE ფორმატის სტრუქტურა აქ არ ჩანს და პუბლიკაცია ახსნა-განმარტების გარეშე იქნება.

ახლა შექმენით ახალი პროექტი, განათავსეთ იგი ListBox ფორმაში, სადაც ნაჩვენები იქნება ფუნქციების სახელები.

Axis მთელი პროექტი:

ერთეული ერთეული 1; ინტერფეისი იყენებს Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls; ტიპი TForm1 = class(TForm) lb: TListBox; პროცედურა FormCreate(გამომგზავნი: TObject); კერძო (პირადი დეკლარაციები) cmdline: სტრიქონი; ImageBase: DWord; DosHeader: PIMageDosHeader; PeHeader: PimageNtHeaders; PExport: PIMageExportDirectory; pname:PDWord; დასახელება: პჩარ; საჯარო (საჯარო დეკლარაციები) დასასრული; var Form1: TForm1; განხორციელების ($R *.dfm) პროცედურა TForm1.FormCreate(Sender: TObject); პროცედურა FatalOsError; დაწყება ShowMessage(SysErrorMessage(GetLastError())); Გაუქმება; დასასრული; Var i: მთელი რიცხვი; დაიწყეთ ცდა, თუ (ParamCount() IMAGE_DOS_SIGNATURE) შემდეგ FatalOsError; PEHeader:= PimageNtHeaders(DWord(ImageBase) + DWord(DosHeader^._lfanew)); თუ (PEHeader^.ხელმოწერა IMAGE_NT_SIGNATURE) მაშინ FatalOsError; PExport:= PIMageExportDirectory(ImageBase + DWord(PEHeader^.OptionalHeader.DataDirectory.VirtualAddress)); pname:= PDWord(ImageBase + DWord(PExport^.AddressOfNames)); i:= 0-ისთვის PExport^. lb.Items.Add(name); inc(pname); დასასრული; ბოლოს FreeLibrary(ImageBase); დასასრული; გარდა Application.ShowMainForm:= False; განაცხადი.შეწყვეტა; დასასრული; დასასრული; დასასრული.

თუ გსურთ თავად დაიწყოთ კოდის გამოყენება და ახლა ამას ვერ აკეთებთ, მაშინ ჩვენი ფორუმი აუცილებლად დაგეხმარება, შემოდით!

ჩვენ ვამატებთ ჩვენს Viewer-ს ყველა DLL-ს

ჩვენ გვაქვს DLL ფუნქციით მზად და ჩვენ ვუყურებთ ფუნქციას. აღარ იყო შესაძლებელი ფუნქციების დამატება მოქმედებაში შემდგომი რობოტების მოხერხებულობისთვის. ცოტა ფული დავხარჯოთ. Explorer-ს შეუძლია ნებისმიერი საქაღალდის გახსნა. მოდით გადავიდეთ Service -> Folder Power... გადადით "ფაილის ტიპები" ჩანართზე. სია, როგორც ჩანს, DLL ფორმატშია. თუ ასეთი რამ არ არის, მაშინ ღილაკს „Create“ ჩავწერთ და „გაფართოების“ ველში ჩავწერთ DLL-ს. დაბეჭდილი OK. ტიპი, რომელიც ჩვენ ვიცით, არის DLL. თქვენ შეგიძლიათ ნახოთ და დატანილია ბეჭედი "დოდატკოვო". "შექმენის" გვერდით, "დიზაინების" ველში ვწერთ მათ, რომლებიც ნაჩვენებია კონტექსტურ მენიუში, მაგალითად DLL Viewer. ირგვლივ მიმოხილვით აღმოვაჩენთ ჩვენს პროგრამას.

ყველაფერი მზადაა!

ახლა, როდესაც დააწკაპუნებთ DLL ფორმატში არსებულ ფაილზე, მენიუში იქნება ჩვენი DLL Viewer. ჩვენ ვირჩევთ და ვაკვირდებით ყველა ფუნქციას!

სულ ეს იყო, მადლობა პატივისცემისთვის!

აბრევიატურა DLLნიშნავს "ბიბლიოთეკას, რომელიც დინამიურად არის დაკავშირებული." Dll დელფშიეს არის ფაილი, რომელიც შეიცავს კომპიუტერული პროგრამის ფუნქციონირებისთვის აუცილებელ პროცედურებსა და ფუნქციებს, რომელთანაც პროგრამა უერთდება ლოგინგის ეტაპზე.

როგორც ჩანს, ყველა საჭირო ქვეპროგრამა შეიძლება აღწერილი იყოს პროგრამების ნაწილში, რისთვისაც საჭიროა დამატებითი შექმნა dll ფაილიდა შეხვდე მას სიკვდილის ჟამს? სცადეთ შექმნილი პროგრამის მეტი მოქნილობა. დროთა განმავლობაში, მონაცემთა დამუშავების ალგორითმები შეიძლება შეიცვალოს. ვინაიდან დამუშავების პროცედურები განხორციელდება მრავალი პროგრამის მიერ, მათ მოუწევთ ხელახლა შეადგინონ და ხელახლა გადასცენ დიდი ფაილი მენეჯერებს. ბევრად უფრო ადვილია პატარა dll ფაილის გადატანა, რომელიც მოითხოვს რამდენიმე პროცედურას და ავტომატურად გაშვება.

გარდა ამისა, dll ბიბლიოთეკის მუშაობა არ დარჩება პროგრამაში, რომელზეც ის შეიქმნება. ამიტომ, ჩვენი პროგრამებისთვის dll-ების შექმნა შეგვიძლია მივანდოთ მესამე მხარის დეველოპერებს, ჩვენს პროგრამირებაზე ფიქრის გარეშე, რომელიც სუნავს. ეს ყველაფერი, თავდაპირველად, მნიშვნელოვნად დააჩქარებს დასრულებული პროექტის დასრულებას და მენეჯერებისთვის გადაცემას

DLL ბიბლიოთეკის შექმნა

ბიბლიოთეკაპროექტი 1;

( მნიშვნელოვანი შენიშვნა DLL მეხსიერების მართვის შესახებ: ShareMem უნდა იყოს
პირველი ერთეული თქვენი ბიბლიოთეკის "USES" პუნქტში და თქვენს პროექტში (აირჩიეთ
Project-View Source) იყენებს პუნქტს, თუ თქვენი DLL ახდენს რაიმე პროცედურების ექსპორტს ან
ფუნქციები, რომლებიც გადასცემენ სტრიქონებს - პარამეტრებს ან შედეგის ფუნქციებს. ეს
ვრცელდება ყველა სტრიქონზე, რომელიც გადაცემულია თქვენს DLL-ზე და თქვენს DLL-ზე - თუნდაც მათზე
ჩანაწერებში და კლასებშია ჩასმული. ShareMem არის ინტერფეისის ერთეული
BORLNDMM.DLL საზიარო მეხსიერების მენეჯერი, რომელიც უნდა იყოს განლაგებული
თქვენი DLL-ით. BORLNDMM.DLL-ის გამოსაყენებლად, გადაიტანეთ სიმებიანი ინფორმაცია
vikoryst PChar ან ShortString პარამეტრები. )

იყენებს
SysUtils
კლასები;

($R *.res)

დაიწყება
დასასრული.

აირჩიეთ სახელი ახალი dll ბიბლიოთეკისთვის და შეინახეთ იგი ახლომდებარე საქაღალდეში ბრძანების არჩევით ფაილი -> Შეინახე როგორც...მამას აქვს 4 ფაილი, რომელთა შორის dll ფაილი არ შედის. რა თქმა უნდა, ეს მხოლოდ ტექსტური ფაილებია პროექტის აღსაწერად. ბიბლიოთეკის dll ფაილის შესაქმნელად, თქვენ უნდა შეადგინოთ პროექტი. მიჰყევით გუნდს პროექტი -> პროექტის შედგენა. შედეგად, ჩვენს საქაღალდეში გამოჩნდება dll ფაილი, რომელთანაც მთავარი პროგრამა იქნება დაკავშირებული.

ბიბლიოთეკა ისევ ცარიელია.

ტექსტი რედაქტირების ეტაპზეა...