დელფის ინტერფეისის მემკვიდრეობა. დელფიში ინტერფეისებთან მუშაობის მახასიათებლები

მე მაქვს პრობლემა Delphi კლასის C ++ კოდიდან გამოყენებისას. delphi dll დემო ვერსია, რომელიც ახორციელებს ფუნქციის ექსპორტს, რომელიც აბრუნებს ობიექტს.
ჩემი Delphi Dll კოდი ასე გამოიყურება:

ბიბლიოთეკა DelphiTest; // იყენებს ნაწილს .... ტიპი IMyObject = ინტერფეისის პროცედურა DoThis (n: Integer); ფუნქცია DoThat: PWideChar; დასასრული; TMyObject = კლასი (TInterfacedObject, IMyObject) პროცედურა DoThis (n: Integer); ფუნქცია DoThat: PChar; დასასრული; // TMyObject განხორციელება გადადით აქ ... პროცედურა TMyObject.DoThis (n: Integer); დაიწყოს showmessage ("თქვენ ურეკავთ DoThis მეთოდს" + intToStr (n) + "პარამეტრი"); დასასრული; ფუნქცია TMyObject.DoThat: PChar; დაიწყეთ შოუმესიჯი ("თქვენ ურეკავთ DoThat ფუნქციას"); შედეგი: = Pchar ("Hello im Dothat"); დასასრული;

// DLL ფუნქციის ექსპორტი:

ფუნქცია CreateMyObject: IMyObject; stdcall;ექსპორტი; var txt: TextFile; დაიწყოს AssignFile (txt, "C: \ log.log"); გადატვირთვა (txt); Writeln (txt, "გამარჯობა"); შედეგი: = TMyObject.Create; დასასრული; ექსპორტი CreateMyObject;

ჩემს C ++ პროექტში მე გამოვაცხადე IMyObject ინტერფეისი ასე:

კლასი IMyObject (public: IMyObject (); virtual ~ IMyObject (); virtual void DoThis (int n) = 0; ვირტუალური char * DoThat () = 0;);

და ჩემი მთავარი ფუნქცია ასეთია:

Typedef IMyObject * (__stdcall * CreateFn) (); int main () (HMODULE hLib; hLib = LoadLibrary (L "DelphiTest.dll"); მტკიცება (hLib! = NULL); // გავლა !! CreateFn pfnCreate; pfnCreate = (CreateFn) GetProcAddress ((HINSTANCE "byO)h "); if (pfnCreate == NULL) (DWORD erc = GetLastError (); printf ("% u \ n", erc); // ის იღებს შეცდომას 127) სხვა (printf ("წარმატებული ჩატვირთვა \ n");) IMyObject * objptr = pfnCreate (); objptr-> DoThis (5); FreeLibrary (hLib); int in; scanf_s ("% i", & in); დაბრუნება 0;)

ამ მაგალითში, მე მივიღე გაშვების შეცდომა, როდესაც ვცდილობდი ექსპორტირებულ ფუნქციაზე წვდომას. შეცდომები ხაზში:
IMyObject * objptr = pfnCreate ();

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

გამოსავალი

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

შემდეგი პრობლემა არის C ++-ში. თქვენი C ++ ინტერფეისი უნდა მომდინარეობდეს IUnknown-დან. ასევე, მან არ უნდა გამოაცხადოს კონსტრუქტორი ან დესტრუქტორი.

გარდა ამისა, თქვენი Delphi კოდი ექსპორტირებულია PWideChar-ის მიერ, რომელიც არ ასახავს char *-ს, იგი ასახავს wchar_t *-ს.

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

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

ველოდები, რომ სხვა შეცდომებიც არის, მაგრამ ეს არის ყველაფერი, რაც აქამდე ვიპოვე.

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

სწორად მოაწყეთ კომპონენტების გადართვის თანმიმდევრობა

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

კონტეინერის შიგნით კომპონენტების გადართვის რიგი დგინდება TabOrder თვისებით. პირველი ხდება აქტიური კომპონენტი, რომელშიც TabOrder არის 0, მეორე 1-ით და ასე შემდეგ, სანამ ყველა კომპონენტი არ იქნება ჩამოთვლილი. გარდა ამისა, კომპონენტს აქვს TabStop თვისება, რომელიც მიუთითებს, მიიღებს თუ არა კომპონენტი ფოკუსს Tab კლავიშით გადართვისას. თუ რომელიმე კომპონენტზე გადართვის აკრძალვა გჭირდებათ, დააყენეთ მისი TabStop = false. ამ შემთხვევაში, ამ კომპონენტზე გადართვა შეგიძლიათ მხოლოდ მაუსის გამოყენებით.

არის შემთხვევები, როდესაც მომხმარებლები, რომლებიც მიჩვეულები არიან გარკვეული გასაღების ერთ პროგრამაში გადართვას, ჩვევის გამო, აგრძელებენ მის გამოყენებას დანარჩენში. ეს ხშირად ხდება 1C მომხმარებლებთან, სადაც Enter კლავიშის გამოყენება შესაძლებელია შეყვანის ველებში ნავიგაციისთვის. აბა, მივცეთ მათ ეს შესაძლებლობა ჩვენს პროგრამებში, თუ ამას ითხოვენ. დააყენეთ ფორმის KeyPreview თვისება true-ზე და ჩაწერეთ მოვლენის დამმუშავებელი OnKeyPress მოვლენისთვის:

პროცედურა TForm1.FormKeyPress (გამომგზავნი: TObject; var Key: Char);
დაიწყოს
თუ ord (გასაღები) = vk_Return მაშინ
Form1.SelectNext (PriemForm.ActiveControl, true, true);
დასასრული;

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

ნაგულისხმევი ღილაკები

ყველა ერთი და იგივე მომხმარებელი სწრაფად ეჩვევა იმ ფაქტს, რომ განაცხადის დიალოგურ ფანჯარაში, როგორც წესი, შეგიძლიათ დაადასტუროთ თქვენი არჩევანი Enter ღილაკით და გააუქმოთ Esc ღილაკით. ნუ გავუცრუებთ მათ ჩვენს პროგრამებში, მით უმეტეს, რომ ამის გაკეთება ძალიან მარტივია. ღილაკისთვის, რომელიც პასუხობს Enter-ს, დააყენეთ ნაგულისხმევი თვისება true. ღილაკისთვის, რომელიც პასუხობს Esc-ს, დააყენეთ Cancel თვისება true. Და სულ ეს არის.

კი ან არა

ყველა დიალოგურ ფანჯარას, რომელიც ითხოვს მომხმარებლის მოქმედებებს, უნდა ჰქონდეს მინიმუმ ორი ღილაკი: დაადასტურეთ მოქმედება და გააუქმეთ მოქმედება (დიახ / არა, შენახვა / გაუქმება და ა.შ.). მოქმედების გაუქმება შესაძლებელია ფანჯრის სათაურში [X] ღილაკით ფანჯრის დახურვით. დაუშვებელია, თუ არსებობს მხოლოდ ერთი ღილაკი მოქმედების დასადასტურებლად, ხოლო მასზე უარის თქმა სათაურში ღილაკით [X] ფანჯრის დახურვაა, ან საერთოდ არ არსებობს უარის თქმის შესაძლებლობა. ეს აბნევს მომხმარებელს და აჩენს ლოგიკურ კითხვას: როგორ უარი თქვას?

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

ყველა დიალოგური ფანჯარა უნდა გაიხსნას ეკრანის ცენტრში

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

გამონაკლისი კეთდება იმ შემთხვევაში, თუ დიალოგური ფანჯარა არ არის მოდალური და მომხმარებლის მუშაობის შედეგად, ამ ფანჯარაში დაუყოვნებლივ ხდება ცვლილებები მთავარ ფანჯარაში (მაგალითად, მონაცემთა ნაკრების გაფილტვრა, გრაფიკების გადახაზვა და ა.შ.).

Windows არ უნდა იყოს ეკრანზე დიდი

არავითარ შემთხვევაში. სირცხვილია, როცა ფანჯრის ნაწილი ეკრანიდან გადმოდის. ეს მოთხოვნა არ არის დამოკიდებული მომხმარებლის ეკრანის გარჩევადობაზე, ე.ი. საბაბები, როგორიცაა "მოდით, მიიღონ მეტი ნებართვა" არ მუშაობს.

ფანჯრის ელემენტების სწორი ზომის შეცვლა

ფანჯრის ელემენტების ზომა უნდა შეიცვალოს ან სწორად მოძრაობდეს ფანჯრის ზომის შეცვლისას, ფანჯრის მაქსიმალური გაზრდისას და როდესაც ფანჯრის აღდგენა ხდება მაქსიმიზაციის შემდეგ.

ყველაფერი ყოველთვის ჩანს

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

მინიშნებები ყველგან, მინიშნებები ყოველთვის

ღილაკებისთვის, განსაკუთრებით ხელსაწყოების ზოლებზე (როგორიცაა ToolBar), მინიშნებები უნდა იყოს მითითებული ისე, რომ ყოველთვის ნათელი იყოს, რატომ არის საჭირო ესა თუ ის ღილაკი.

ფერის სპექტრი

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

დასკვნა

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

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

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

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

რომ ნახევარი სიცოცხლე არ დაკარგოთ ამის გარკვევაში, ამ სტატიაში ყველაფერს ვერცხლის ლანგარზე მოგიტანთ.

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

Მნიშვნელოვანი ჩანაწერი: სტატიის წაკითხვაა საჭირო თანმიმდევრულად... კოდის მაგალითები მოცემულია მხოლოდ როგორც მაგალითები, სტატიის ყოველ საფეხურზე (აბზაცში) ემატება მაგალითების კოდი ახალი დეტალებით. მაგალითად, სტატიის დასაწყისშივე არ არის შეცდომის დამუშავება, მითითებულია „კლასიკური“ მეთოდები (როგორიცაა GetLastError-ის გამოყენება, sdtcall კონვენციები და ა.შ.), რომლებიც სტატიის მსვლელობისას იცვლება უფრო ადეკვატურით. ეს კეთდება იმ მიზეზით, რომ „ახალი“ („არაჩვეულებრივი“) კონსტრუქციები არ აჩენს კითხვებს. წინააღმდეგ შემთხვევაში, თითოეული მაგალითისთვის, თქვენ მოგიწევთ ჩასვათ ფორმის შენიშვნა: "ეს განხილულია ქვემოთ მოცემულ აბზაცში, მაგრამ ეს არის ამ ერთში." ნებისმიერ შემთხვევაში, სტატიის ბოლოს არის ბმული მზა კოდის შესახებ, რომელიც დაწერილია სტატიაში ნათქვამის გათვალისწინებით. შეგიძლიათ უბრალოდ აიღოთ და გამოიყენოთ. და სტატია განმარტავს რატომ და რატომ. თუ არ გაინტერესებთ "რატომ და რატომ" - გადადით ქვემოთ დასკვნამდე და მაგალითის გადმოსაწერად ბმულზე.

მხოლოდ შედეგისთვის

ვადების მკაცრი დაცვა

გამჭვირვალობა

პროექტის შესრულება

ტექნიკური მხარდაჭერა საჩუქრად

პროგრამირება, რჩევების გადახედვა 1C-ზე

როგორ ვმუშაობთ

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

2. სამუშაოს ვაფასებთ რუბლებში, თუ პროექტი დიდია, თუ არა - საათების სავარაუდო რაოდენობა.

3. ჩვენ ვასრულებთ სამუშაოს.

4. თქვენ იღებთ სამუშაოს თქვენს პროგრამაში, თუ არის რაიმე ხარვეზი, ვასწორებთ მათ.

5. ჩვენ გავცემთ ინვოისს, თქვენ იხდით.

სამუშაოს ღირებულება

1. ყველა სამუშაო დაყოფილია 3 კატეგორიად: კონსულტაცია, ტიპიური კონფიგურაციის განახლება, ახალი ანგარიშის შემუშავება ან დაპროგრამება, დამუშავება, ღილაკები და ა.შ.

3. 10 საათზე მეტი სამუშაოსთვის წინასწარ დგება ტექნიკური დავალება სამუშაოს აღწერით და ღირებულებით. მუშაობა იწყება მას შემდეგ, რაც თქვენთან შეთანხმებით.

Ტექნიკური მხარდაჭერა

1. თუ აღმოაჩენთ რაიმე შეცდომებს ადრე მიღებულ სამუშაოებში, 3 თვის განმავლობაში ვასწორებთ მათ უფასოდ.

2. მუდმივ კლიენტებს ვასწორებთ სამუშაოს ნებისმიერ ხარვეზს მთელი წლის განმავლობაში უფასოდ.

პროგრამები თქვენი ბიზნესის მართვისთვის.

შეიძინეთ 1C: Enterprise

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

• Აღრიცხვა
• მაღაზიის ავტომატიზაცია
• Საბითუმო
• ინსტალაციისა და საწყისი დაყენების დახმარება პაკეტში შედის!
• კონფიგურაციების დახვეწილი რეგულირება მომხმარებლის საჭიროებებისთვის, ახალი მოდულების შემუშავება სტანდარტულ კონფიგურაციაში საჭირო ფუნქციების არარსებობის შემთხვევაში.

1c ბუღალტერია	1C: ვაჭრობის მენეჯმენტი	1C: საცალო ვაჭრობა	1C: ხელფასი და პერსონალის მართვა
3300 რუბლიდან.	6700 რუბლიდან.	3300 რუბლიდან.	7400 რუბლიდან.

სერვერის უზრუნველყოფა.

მყისიერი დაყენების სერვერი + 1C.

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

• ხელმისაწვდომობა 24/7
• არ არის საჭირო თქვენი საკუთარი sysadmin-ის შენარჩუნება (დაზოგვა დაფარავს თქვენი სერვერის ხარჯებს).
• 1C-ის სწრაფი დაყენება და ინსტალაცია სერვერზე, 3 დღეში უკვე გექნებათ სრულად მომუშავე სისტემა.
• ნებისმიერ დროს, შეგიძლიათ გადახვიდეთ ადგილობრივ სერვერზე, თუ გამოსავალი არ შეესაბამება თქვენ.

SMS თქვენი 1C-დან

გსურთ, მომხმარებლებმა დროულად გაიგონ აქციების, ფასდაკლებების შესახებ? მომხმარებლები არ ბრუნდებიან? დააყენეთ SMS გაგზავნა პირდაპირ 1C-დან!

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

• გმადლობთ შეძენისთვის და ბონუსების დარიცხვისთვის, შემდეგი შეძენისთანავე.
• პრემიების დარიცხვა ბარათზე საჩუქრად დაბადების დღისთვის \ სხვა მნიშვნელოვანი ან დღესასწაულისთვის.
• შეტყობინება საწყობში საქონლის მისვლის შესახებ.
• საჩუქრის ბონუსების ვადა გასულია.
• წინასწარი გადახდის და საქონლის დაჯავშნის შესახებ შეტყობინება.
• მისამართი დეტალებით, თუ როგორ მივიდეთ მაღაზიაში/ოფისში, ტელეფონის ნომრები.
• და ა.შ.

პარამეტრები 1C-ში შეიძლება გაკეთდეს ჩვენი სპეციალისტების ან ჩვენი თანამშრომლების მიერ. ტარიფების გაცნობა შეგიძლიათ SMS ტარიფების გვერდზე.

• SMS მიწოდების გარანტია, თანხის ამოღება ხდება მხოლოდ მიწოდებულ SMS-ზე.
• ცალკე ბილინგი თითოეული SMS-ისთვის.
• ბალანსის შევსება სხვადასხვა გზით.
• იხილეთ ყველა გაგზავნილი SMS-ის ისტორია ნებისმიერ დროს.
• გამომგზავნის სახელი ციფრული ნომრის ნაცვლად შეტყობინების მიმღების ტელეფონზე.

ობიექტზე ორიენტირებული პროგრამირება (OOP), გარდა კლასის კონცეფციისა, ასევე ითვალისწინებს ინტერფეისის ფუნდამენტურ კონცეფციას.

რა არის ინტერფეისი და რა თვისებები აქვს მასთან მუშაობას Delphi პროგრამირების ენაზე?

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

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

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

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

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

დელფი / პასკალი

IMyNewInterface = ინტერფეისის პროცედურა InterfaceProc; დასასრული;

IMyNewInterface = ინტერფეისი პროცედურა InterfaceProc; დასასრული;

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

საქმე იმაშია, რომ დელფის ინტერფეისები თავდაპირველად დაინერგა COM ტექნოლოგიის მხარდასაჭერად. ამიტომ, IInterface ინტერფეისი, რომელიც Delphi-ში არის ყველა სხვა ინტერფეისის წინაპარი (TObject-ის ერთგვარი ანალოგი), უკვე შეიცავს ამ ტექნოლოგიასთან მუშაობის სამ ძირითად მეთოდს: QueryInterface, _AddRef, _Release. შედეგად, თუ კლასი ახორციელებს რაიმე ინტერფეისს, მაშინ მან უნდა განახორციელოს ეს მეთოდები უშეცდომოდ. მაშინაც კი, თუ ეს კლასი არ არის შექმნილი COM-თან მუშაობისთვის.

IInterface ინტერფეისის ამ მახასიათებლის გამო, Delphi-ში, ინტერფეისების გამოყენება, უმეტეს შემთხვევაში, იწვევს კლასში განზრახ გამოუყენებელი შესაძლებლობების დამატებას.

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

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

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

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