ការអភិវឌ្ឍន៍កម្មវិធីម៉ាស៊ីនភ្ញៀវដោយប្រើប្រាស់ Indy in Delphi ។ សមាសធាតុ Indy ដែលប្រើនៅក្នុង Delphi ។ ឧទាហរណ៍មួយចំនួននៃការប្រើប្រាស់សមាសធាតុ Indy

ពិធីការ UDP គឺល្អសម្រាប់ការបញ្ជូន សារអត្ថបទនោះគឺអ្នកអាចរៀបចំបាន។ ការជជែកក្នុងស្រុកនិងរឿងស្រដៀងគ្នា។ ខ្ញុំបានសម្រេចចិត្តផ្តល់ឧទាហរណ៍នៃការងារសាមញ្ញបំផុតជាមួយ UDP នៅ Delphi ។

ការណែនាំជាជំហាន ៗ:

ខ្ញុំ​បាន​លើក​ឧទាហរណ៍​មួយ ប៉ុន្តែ​អត់​ទោស​ខ្ញុំ ខ្ញុំ​មិន​បាន​សរសេរ​គ្រប់​បន្ទាត់​ទេ ព្រោះ... ខ្ញុំ​មិន​ឃើញ​មាន​អ្វី​ស្មុគស្មាញ​ទេ ហើយ​អ្នក​ណា​ក៏​អាច​យល់​បាន​ដែរ។

តាមពិតប្រសិនបើមានអ្វីមិនច្បាស់លាស់ អ្នកអាចសួរខ្ញុំមួយសំណួរ។ ហើយនេះគឺជាលេខកូដពិត៖

ប្រើប្រាស់
ប្រព័ន្ធប្រតិបត្តិការ Windows, សារ, SysUtils, វ៉ារ្យ៉ង់, ថ្នាក់, ក្រាហ្វិក, ការត្រួតពិនិត្យ, ទម្រង់,
ប្រអប់, StdCtrls, IdUDPServer, IdBaseComponent, IdComponent, IdUDPBase,
IdUDPClient, IdSocketHandle;

ប្រភេទ
TForm1 = ថ្នាក់ (TForm)
IdUDPClient1៖ TIdUDPClient;
IdUDPServer1៖ TIdUDPServer;
ប៊ូតុង 1: TButton;
ស្លាកលេខ ១៖ ស្លាកលេខ;
នីតិវិធី FormCreate (អ្នកផ្ញើ៖ TObject);
នីតិវិធី FormClose(អ្នកផ្ញើ៖ TObject; var Action: TCloseAction);
ដំណើរការ Button1Click (អ្នកផ្ញើ៖ TObject);
នីតិវិធី IdUDPServer1UDPRead(AThread: TIdUDPListenerThread; AData: TBytes;
ABinding: TIdSocketHandle);
ឯកជន
(សេចក្តីប្រកាសឯកជន)
សាធារណៈ
(សេចក្តីប្រកាសជាសាធារណៈ)
បញ្ចប់;

var
Form1: TForm1;

($R *.dfm)
[b]// នីតិវិធីសម្រាប់ការផ្ញើសារ
នីតិវិធី TForm1.Button1Click(អ្នកផ្ញើ៖ TObject);
ចាប់ផ្តើម
ព្យាយាម
IdUDPClient1.Active:= ពិត;
IdUDPClient1.Host:= "localhost";
IdUDPClient1.Connect;
ប្រសិនបើ IdUDPClient1.បានភ្ជាប់បន្ទាប់មក
ចាប់ផ្តើម
IdUDPClient1.Send(TimeToStr(Time));
Label1.Caption:="ok";
បញ្ចប់;
IdUDPClient1.Active:= មិនពិត;
ប៊ីប ប៊ីប ប៊ីប
លើកលែងតែ
MessageDlg("មានអ្វីមួយខុស =(", mtError, , 0);
បញ្ចប់;
បញ្ចប់;
[ខ]
// បិទ។ ម៉ាស៊ីនមេ UDP នៅពេលចាប់ផ្តើម និងបិទទម្រង់
នីតិវិធី TForm1.FormClose(អ្នកផ្ញើ៖ TObject; var Action: TCloseAction);
ចាប់ផ្តើម
IdUDPServer1.Active:= មិនពិត;
បញ្ចប់;

នីតិវិធី TForm1.FormCreate(អ្នកផ្ញើ៖ TObject);
ចាប់ផ្តើម
IdUDPServer1.Active:= ពិត;
បញ្ចប់;

[b]//នីតិវិធីប្រតិកម្មម៉ាស៊ីនមេ នៅពេលទទួលទិន្នន័យ
នីតិវិធី TForm1.IdUDPServer1UDPRead(AThread: TIdUDPListenerThread;
ទិន្នន័យ៖ TBytes; ABinding: TIdSocketHandle);
វ៉ារ
i: ចំនួនគត់;
s: ខ្សែអក្សរ;
ចាប់ផ្តើម
s:="";
ព្យាយាម
ខ្ញុំ:= 0;
ខណៈពេលដែល (AData[i] 0) ធ្វើ
ចាប់ផ្តើម
s:= s + chr(AData[i]);
i:= i + 1;
បញ្ចប់;
ចុងក្រោយ
Label1.Caption:=s;
បញ្ចប់;
បញ្ចប់;

សរុបមក Indy គឺជាសមាសធាតុសម្រាប់ការងារងាយស្រួលជាមួយពិធីការអ៊ីនធឺណិតដ៏ពេញនិយម។ គោលការណ៍នៃប្រតិបត្តិការរបស់ពួកគេគឺផ្អែកលើការប្រើប្រាស់រន្ធនៅក្នុងរបៀបទប់ស្កាត់។ Indy គឺគួរឱ្យចាប់អារម្មណ៍និងងាយស្រួលព្រោះវាមានលក្ខណៈអរូបីណាស់។ ហើយ​ការ​សរសេរ​កម្មវិធី​នៅ Indy មក​ដល់​ការ​សរសេរ​កម្មវិធី​លីនេអ៊ែរ។ និយាយអីញ្ចឹង អត្ថបទដែលបានបកប្រែត្រូវបានចែកចាយយ៉ាងទូលំទូលាយនៅលើអ៊ីនធឺណិត ដែលក្នុងនោះមានពាក្យថា "របៀបរារាំងមិនមែនជាអារក្ស" :)) នៅពេលមួយខ្ញុំពិតជារីករាយចំពោះការបកប្រែនេះ។ អត្ថបទនេះគឺជាផ្នែកមួយនៃសៀវភៅ "ជម្រៅនៃ Indy" ដោយ Hoover និង Hariri ។ ជាគោលការណ៍ ដើម្បីធ្វើការជាមួយ Indy អ្នកមិនចាំបាច់អានវាទាំងអស់នោះទេ ប៉ុន្តែខ្ញុំនៅតែណែនាំឱ្យស្គាល់ខ្លួនអ្នកជាមួយនឹងគោលការណ៍នៃរបៀបដែលពិធីការអ៊ីនធឺណិតដំណើរការ។ ចំពោះរបប "អារក្ស" ។ ការហៅរន្ធដែលរារាំងមិនត្រឡប់ការគ្រប់គ្រងវិញទេ រហូតដល់វាបានបញ្ចប់កិច្ចការរបស់វា។ នៅពេលដែលការហៅទូរសព្ទត្រូវបានធ្វើឡើងនៅលើខ្សែមេ ចំណុចប្រទាក់កម្មវិធីអាចនឹងបង្កក។ ដើម្បីជៀសវាងស្ថានភាពមិនល្អនេះ អ្នកអភិវឌ្ឍន៍ឥណ្ឌាបានបង្កើតសមាសភាគ TIdAntiFreeze ។ អ្នកគ្រាន់តែត្រូវបោះវានៅលើទម្រង់ - ហើយចំណុចប្រទាក់អ្នកប្រើនឹងត្រូវបានគូរឡើងវិញយ៉ាងងាយស្រួលខណៈពេលដែលការទប់ស្កាត់ការហៅទូរស័ព្ទត្រូវបានធ្វើឡើង។

អ្នកប្រហែលជាធ្លាប់ស្គាល់ខ្លឹមសារនៃផ្ទាំង "Indy (...)" ជាច្រើននៅក្នុង Delphi រួចហើយ។ មានសមាសធាតុជាច្រើននៅទីនោះ ហើយពួកវានីមួយៗអាចមានប្រយោជន៍។ ខ្លួនខ្ញុំផ្ទាល់មិនបានធ្វើការជាមួយមនុស្សគ្រប់គ្នាទេ ព្រោះខ្ញុំមិនឃើញតម្រូវការក្នុងការសិក្សាពួកគេដោយគ្មានកិច្ចការជាក់លាក់នោះទេ។

ការចែកចាយ Delphi ជាមូលដ្ឋានរួមមាន Indy v.9 ជាមួយនឹងកាក់។ វាប្រហែលជាត្រូវបានណែនាំឱ្យដំឡើងកំណែជាបន្ទាន់ទៅច្រើនទៀត កំណែ​ថ្មី(ឧទាហរណ៍ បច្ចុប្បន្ននេះ ខ្ញុំមាន 10.0.76 ប៉ុន្តែក៏មានជំនាន់ក្រោយដែរ វាហាក់បីដូចជា)។

មានសមាសភាគម៉ាស៊ីនភ្ញៀវ និងម៉ាស៊ីនមេសម្រាប់ធ្វើការជាមួយពិធីការដូចគ្នា។ Indy ពិតជាសម្រួលដល់ការអភិវឌ្ឍន៍កម្មវិធី មិនដូចជម្រើសនៃការអភិវឌ្ឍន៍មុខងារដូចគ្នានៅលើរន្ធនោះទេ។ ឧទាហរណ៍ ដើម្បីបង្កើតការតភ្ជាប់ជាមួយម៉ាស៊ីនមេ អ្នកគ្រាន់តែហៅវិធីសាស្ត្រតភ្ជាប់។ ការបង្កើតការតភ្ជាប់ដោយជោគជ័យនឹងត្រូវបានសម្គាល់ដោយវិធីត្រឡប់ដោយមិនបង្កឱ្យមានករណីលើកលែង។ ប្រសិនបើការតភ្ជាប់មិនត្រូវបានបង្កើតឡើង ករណីលើកលែងមួយនឹងត្រូវបានបោះចោល។

ឧទាហរណ៍ "សិក្សា" (កូដមិនដំណើរការទេ កុំដំណើរការវា :)):

ជាមួយ IndyClient ធ្វើ
ចាប់ផ្តើម
ម៉ាស៊ីន៖= "test.com";
ច្រក:= 2000;
ភ្ជាប់;
ព្យាយាម
// ធ្វើការជាមួយទិន្នន័យ (អានសរសេរ ... )
ចុងក្រោយ
ផ្តាច់ទំនាក់ទំនង;
បញ្ចប់;
បញ្ចប់;

ម៉ាស៊ីន និងច្រកអាចត្រូវបានកំណត់នៅក្នុងឧបករណ៍ត្រួតពិនិត្យវត្ថុ ឬក្នុងពេលដំណើរការ។

ហេតុអ្វីបានជាអ្នកអាចប្រើសមាសធាតុ Indy ក្នុងការញែកភារកិច្ច? ការប្រើប្រាស់ផ្សេងៗ! អ្វី​ដែល​សាមញ្ញ​បំផុត​គឺ​ទទួល​បាន​មាតិកា​នៃ​ទំព័រ (អ្នក​រាល់​គ្នា​ប្រហែល​ជា​បាន​ជួប​ប្រទះ​នឹង​បញ្ហា​នេះ​ហើយ) ដោយ​ប្រើ​សមាសភាគ IdHTTP៖

វ៉ារ
rcvrdata៖ TMemoryStream;
idHttp1: TidHttp;
ចាប់ផ្តើម
idHttp1:= TidHttp.Create(nil);
rcvrdata:= TMemoryStream.Create;
idHttp1.Request.UserAgent:= "Mozilla/4.0 (ឆបគ្នា; MSIE 5.5; Windows 98)";
idHttp1.Request.AcceptLanguage:= "ru";
idHttp1.Response.KeepAlive:= true;
idHttp1.HandleRedirects:= true;
ព្យាយាម
idHttp1.Get(Edit1.Text, rcvrdata);
ចុងក្រោយ
idHttp1.Free;
បញ្ចប់;
ប្រសិនបើ rcvrdata.Size > 0 បន្ទាប់មកចាប់ផ្តើម
ShowMessage("ទទួល" + inttostr(rcvrdata.Size));
rcvrdata.SaveToFile("c:\111.tmp");
បញ្ចប់;
rcvrdata.Free;
បញ្ចប់;

ដូចដែលអ្នកអាចឃើញអ្នកមិនត្រឹមតែអាចទទួលបានមាតិកានៃទំព័រប៉ុណ្ណោះទេប៉ុន្តែថែមទាំងក្លែងធ្វើការទាញយកឯកសារពីម៉ាស៊ីនភ្ញៀវជាក់លាក់ផងដែរ។ សមាសធាតុ Indyជាទូទៅមានភាពងាយស្រួលសម្រាប់ការបង្កើតបឋមកថា និងសំណើ POST ។ បន្ថែមទៀតអំពីរឿងនេះជាមួយនឹងឧទាហរណ៍នៅពេលក្រោយ។

ដើម្បីបន្តធ្វើបច្ចុប្បន្នភាពជាមួយការអាប់ដេតប្លក់ អ្នកអាចធ្វើបាន

ការណែនាំអំពី Indy

ការណែនាំអំពី Indy
បានដាក់ប្រកាសដោយ Chad Z. Hower
គេហទំព័រ៖ http://www.atozedsoftware.com
ការបកប្រែ: Anatoly Podgoretsky
ការណែនាំ
ខ្ញុំបានសរសេរអត្ថបទនេះនៅពេលដែលកំណែបច្ចុប្បន្នគឺ Indy 8.0 ។ ភាគច្រើននៃអត្ថបទនេះគឺអាចអនុវត្តបាន និងមានប្រយោជន៍ខ្លាំងណាស់នៅក្នុងកំណែអនាគតរបស់ Indy ។ ប្រសិនបើអ្នកចូលចិត្តអត្ថបទនេះ ហើយចង់អានអត្ថបទស៊ីជម្រៅបន្ថែមទៀត សូមពិនិត្យមើលសៀវភៅ Indy in Depth ។
Indy កំពុងដំណើរការក្នុងរបៀបទប់ស្កាត់
Indy ប្រើរន្ធបិទ។ របៀបទប់ស្កាត់គឺស្រដៀងនឹងឯកសារអាន-សរសេរ។ នៅពេលអាន ឬសរសេរទិន្នន័យ មុខងារមិនត្រឡប់ការគ្រប់គ្រងវិញទេ រហូតដល់ប្រតិបត្តិការត្រូវបានបញ្ចប់។ ភាពខុសគ្នាពីការធ្វើការជាមួយឯកសារគឺថាការហៅទូរសព្ទអាចចំណាយពេលយូរជាងនេះ ដោយសារទិន្នន័យដែលបានស្នើសុំមិនទាន់មាននៅឡើយ វាអាស្រ័យលើល្បឿនដែលបណ្តាញ ឬម៉ូដឹមរបស់អ្នកដំណើរការ។
ឧទាហរណ៍ វិធីសាស្ត្រមួយត្រូវបានហៅយ៉ាងសាមញ្ញ ហើយរង់ចាំរហូតដល់ការគ្រប់គ្រងត្រូវបានត្រលប់ទៅចំណុចហៅវិញ។ ប្រសិនបើការហៅទូរសព្ទបានជោគជ័យ ការគ្រប់គ្រងនឹងត្រលប់មកវិញពីវិធីសាស្រ្ដ ប្រសិនបើមានបញ្ហាកើតឡើង ករណីលើកលែងមួយនឹងត្រូវបានលើកឡើង។
ការចាក់សោរមិនស្លាប់ទេ។
ដោយ​សារ​របៀប​រារាំង​យើង​ត្រូវ​បាន​គូប្រកួត​វាយ​ជា​ច្រើន​ដង ប៉ុន្តែ​របៀប​ទប់ស្កាត់​មិន​មែន​ជា​អារក្ស​ទេ។
បញ្ហាបានលេចចេញបន្ទាប់ពីភ្ជាប់ Winsock ទៅ Windows ។ នៅក្នុង Unix បញ្ហាត្រូវបានដោះស្រាយជាធម្មតាដោយ forking (ស្រដៀងទៅនឹង multi-threading ប៉ុន្តែដោយសារតែ ដំណើរការបុគ្គលជំនួសឱ្យស្ទ្រីម) ។ ម៉ាស៊ីនភ្ញៀវ និងដេមិន Unix ត្រូវបំបែកដំណើរការដែលគួរដំណើរការ និងប្រើរបៀបទប់ស្កាត់។ Windows 3.x មិន​អាច​ត្រូវ​បាន​ប៉ារ៉ាឡែល​និង​មិន​គាំទ្រ​ការ​ខ្សែស្រឡាយ​ច្រើន​។ ការប្រើចំណុចប្រទាក់ទប់ស្កាត់បានបង្កកចំណុចប្រទាក់អ្នកប្រើ និងធ្វើឱ្យកម្មវិធីមិនឆ្លើយតប។ ដូច្នេះ របៀបមិនទប់ស្កាត់ត្រូវបានបន្ថែមទៅ WinSock ដែលអនុញ្ញាតឱ្យ Windows 3.x ជាមួយនឹងដែនកំណត់របស់វាប្រើ Winsock ដោយមិនរារាំងខ្សែស្រឡាយសំខាន់ និងតែមួយគត់នៃកម្មវិធី។ នេះតម្រូវឱ្យមានការសរសេរកម្មវិធីផ្សេងៗគ្នា ក្រុមហ៊ុន Microsoft និងអ្នកផ្សេងទៀតបានបំពានយ៉ាងខ្លាំងចំពោះរបបទប់ស្កាត់ដើម្បីលាក់ គុណវិបត្តិវីនដូ 3.x.
បន្ទាប់មកបានមក Win32 ដែលអាចគាំទ្រដល់ពហុខ្សែ។ ប៉ុន្តែមកដល់ពេលនេះ ខួរក្បាលរបស់ពួកគេបានច្របូកច្របល់ហើយ (នោះគឺអ្នកអភិវឌ្ឍន៍បានចាត់ទុកការបិទរន្ធថាជាការបង្កើតរបស់អារក្ស) ហើយវាពិបាកក្នុងការផ្លាស់ប្តូរអ្វីដែលពួកគេបានធ្វើ។ ដូច្នេះ​ការ​ប្រមាថ​នៃ​របប​រារាំង​នៅ​តែ​បន្ត។
តាមពិត Unix មានតែរន្ធបិទប៉ុណ្ណោះ។ រន្ធបិទក៏មានគុណសម្បត្តិរបស់វាដែរ ហើយល្អជាងសម្រាប់ពហុខ្សែ សុវត្ថិភាព និងទិដ្ឋភាពផ្សេងៗទៀត។ ផ្នែកបន្ថែមមួយចំនួនត្រូវបានបន្ថែមទៅយូនីកសម្រាប់រន្ធដែលមិនរារាំង។ ទោះយ៉ាងណាក៏ដោយពួកគេធ្វើការខុសគ្នាខ្លាំងជាងនៅលើវីនដូ។ ពួកវាក៏មិនមានលក្ខណៈស្តង់ដារដែរ និងមិនទូទៅ។ ការទប់ស្កាត់រន្ធនៅក្នុងយូនីកត្រូវបានប្រើប្រាស់ស្ទើរតែគ្រប់ករណីទាំងអស់ ហើយនឹងបន្តប្រើប្រាស់។
អត្ថប្រយោជន៍នៃរបៀបទប់ស្កាត់ · ងាយស្រួលជាងក្នុងកម្មវិធី - របៀបទប់ស្កាត់គឺងាយស្រួលដាក់កម្មវិធី។ កូដអ្នកប្រើប្រាស់ទាំងអស់អាចនៅនឹងកន្លែងមួយ ហើយប្រតិបត្តិតាមលំដាប់លំដោយធម្មជាតិ។ ងាយស្រួលច្រកទៅយូនីក - ដោយសារយូនីកប្រើរន្ធបិទ សូមសរសេរកូដចល័តចូល ក្នុងករណី​នេះងាយស្រួលជាង។ Indy ប្រើការពិតនេះដើម្បីសរសេរកូដឯកសណ្ឋាន។ · វាងាយស្រួលជាងក្នុងការធ្វើការជាមួយខ្សែស្រឡាយ - ដោយសាររន្ធបិទមានលំដាប់ដែលទទួលបានដោយតំណពូជ ដូច្នេះពួកវាងាយស្រួលប្រើក្នុងខ្សែស្រឡាយ។
គុណវិបត្តិនៃរបៀបទប់ស្កាត់ · ចំណុចប្រទាក់អ្នកប្រើបង្កកក្នុងម៉ាស៊ីនភ្ញៀវ - ការហៅរន្ធបិទមិនត្រឡប់ការគ្រប់គ្រងវិញទេ រហូតដល់វាបានបញ្ចប់កិច្ចការរបស់វា។ នៅពេលដែលការហៅទូរសព្ទបែបនេះត្រូវបានធ្វើឡើងនៅលើខ្សែស្រឡាយសំខាន់របស់កម្មវិធី កម្មវិធីមិនអាចដំណើរការសាររបស់អ្នកប្រើបានទេ។ វាបណ្តាលឱ្យចំណុចប្រទាក់អ្នកប្រើបង្កក វីនដូមិនធ្វើឱ្យស្រស់ និងគ្មានសារផ្សេងទៀតដែលត្រូវដំណើរការរហូតដល់ការគ្រប់គ្រងត្រូវបានត្រឡប់ពីរន្ធបិទ។
សមាសធាតុ TIdAntiFreeze
Indy មានសមាសធាតុពិសេសដែលដោះស្រាយបញ្ហានៃការកក ចំណុចប្រទាក់អ្នកប្រើ. គ្រាន់តែបន្ថែមសមាសភាគ TIdAntiFreeze មួយកន្លែងនៅក្នុងកម្មវិធីរបស់អ្នក ហើយអ្នកអាចធ្វើការទប់ស្កាត់ការហៅទូរសព្ទដោយមិនបង្កក UI ។
TIdAntiFreeze ដំណើរការលើកម្មវិធីកំណត់ម៉ោងខាងក្នុងនៅខាងក្រៅជង់ការហៅទូរសព្ទ ហើយហៅទៅកាន់ Application.ProcessMessages នៅពេលដែលអស់ពេលផុតកំណត់។ ការហៅខាងក្រៅទៅកាន់ Indy នៅតែបន្តរារាំង ហើយដូច្នេះដំណើរការដូចគ្នាដោយមិនប្រើសមាសភាគ TIdAntiFreeze ។ ការប្រើប្រាស់ TIdAntiFreeze អនុញ្ញាតឱ្យអ្នកទទួលបានគុណសម្បត្តិទាំងអស់នៃការបិទរន្ធដោយគ្មានគុណវិបត្តិ។
ខ្សែអក្សរកូដ (Threading)
ជាមួយនឹងរន្ធបិទ ស្ទ្រីមកូដត្រូវបានប្រើប្រាស់ស្ទើរតែគ្រប់ពេល។ រន្ធដែលមិនរារាំងក៏អាចប្រើខ្សែស្រឡាយបានដែរ ប៉ុន្តែនេះតម្រូវឱ្យមានដំណើរការបន្ថែមមួយចំនួន ហើយអត្ថប្រយោជន៍របស់វាត្រូវបានបាត់បង់បើប្រៀបធៀបទៅនឹងរន្ធបិទ។
អត្ថប្រយោជន៍នៃខ្សែស្រឡាយ·ការកំណត់អាទិភាព - អាទិភាពនៃខ្សែស្រឡាយនីមួយៗអាចត្រូវបានកំណត់រចនាសម្ព័ន្ធ។ នេះអនុញ្ញាតឱ្យកិច្ចការនីមួយៗត្រូវបានបែងចែកពេលវេលា CPU ច្រើន ឬតិច។ · Encapsulation - ការ​តភ្ជាប់​គ្នា​អាច​មាន​ភាព​ស្រដៀង​គ្នា​មួយ​ចំនួន​នៃ​ចំណុច​ប្រទាក់​មួយ​នឹង​ការ​តភ្ជាប់​ផ្សេង​ទៀត​។ ·សុវត្ថិភាព - ខ្សែនីមួយៗអាចមានលក្ខណៈសុវត្ថិភាពខុសៗគ្នា។ ·ប្រព័ន្ធដំណើរការច្រើន - ផ្តល់អត្ថប្រយោជន៍លើប្រព័ន្ធដែលមាន processors ច្រើន។ ·មិនត្រូវការសៀរៀលទេ - ផ្តល់នូវការស្របគ្នាពេញលេញ។ ដោយគ្មានខ្សែស្រឡាយច្រើន សំណើទាំងអស់ត្រូវតែដំណើរការក្នុងខ្សែតែមួយ។ ដូច្នេះ ការងារនីមួយៗត្រូវបែងចែកជាកំណាត់តូចៗ ទើបអាចដំណើរការបានលឿន។ ខណៈពេលដែលប្លុកមួយកំពុងដំណើរការ អ្នកផ្សេងទៀតត្រូវបានបង្ខំឱ្យរង់ចាំឱ្យវាបញ្ចប់។ នៅចុងបញ្ចប់នៃប្លុកមួយ ប្លុកបន្ទាប់ត្រូវបានប្រតិបត្តិ ហើយដូច្នេះនៅលើ។ ជាមួយនឹង multithreading កិច្ចការនីមួយៗអាចត្រូវបានសរសេរកម្មវិធីជាឯកតាតែមួយ និង ប្រព័ន្ធ​ប្រតិបត្តិការបែងចែកពេលវេលារវាងកិច្ចការទាំងអស់។
ខ្សែស្រឡាយបោះឆ្នោត
ការបង្កើត និងបំផ្លាញខ្សែស្រឡាយគឺពឹងផ្អែកខ្លាំងលើធនធាន។ នេះគឺជាកិច្ចការដ៏លំបាកជាពិសេសសម្រាប់ម៉ាស៊ីនមេដែលមានការតភ្ជាប់រយៈពេលខ្លី។ ម៉ាស៊ីនមេនីមួយៗបង្កើតខ្សែស្រឡាយ ប្រើវា។ ពេលខ្លីហើយបន្ទាប់មកបំផ្លាញវា។ នេះ​ជា​លទ្ធផល​ដែល​ខ្សែ​ស្រឡាយ​ត្រូវ​បាន​បង្កើត និង​លុប​ញឹកញាប់​ណាស់។ ឧទាហរណ៍នៃនេះគឺជាម៉ាស៊ីនមេបណ្តាញ។ សំណើតែមួយត្រូវបានផ្ញើ ហើយការឆ្លើយតបដ៏សាមញ្ញមួយត្រូវបានបញ្ជូនមកវិញ។ នៅពេលប្រើកម្មវិធីរុករកតាមអ៊ីនធឺណិត ការតភ្ជាប់ និងការផ្តាច់រាប់រយអាចកើតឡើងនៅពេលមើលគេហទំព័រណាមួយ។
បណ្តាញបោះឆ្នោតអាចកែតម្រូវស្ថានភាពនេះបាន។ ជំនួសឱ្យការបង្កើត និងបំផ្លាញខ្សែស្រឡាយតាមតម្រូវការ ខ្សែស្រឡាយត្រូវបានជ្រើសរើសពីបញ្ជីនៃខ្សែស្រឡាយដែលមិនប្រើ ប៉ុន្តែបានបង្កើតរួចហើយពីអាង។ នៅពេលដែលខ្សែស្រឡាយលែងត្រូវការវាត្រូវត្រលប់ទៅអាងទឹកវិញជំនួសឱ្យការបំផ្លាញ។ ខ្សែស្រឡាយនៅក្នុងអាងត្រូវបានសម្គាល់ថាមិនបានប្រើ ដូច្នេះហើយមិនប្រើប្រាស់ពេលវេលាស៊ីភីយូទេ។ សម្រាប់ច្រើនទៀត ការកែលម្អបន្ថែមទៀតខ្សែស្រឡាយអាចសម្របខ្លួនតាមតម្រូវការបច្ចុប្បន្ននៃប្រព័ន្ធ។
Indy គាំទ្រ​ការ​បោះឆ្នោត​ជ្រើសរើស​ខ្សែ​ស្រឡាយ។ បណ្តុំខ្សែស្រឡាយនៅក្នុង Indy អាចចូលប្រើបានតាមរយៈសមាសភាគ TIdThreadMgrPool ។
ខ្សែស្រឡាយជាច្រើន។
ម៉ាស៊ីនមេដែលផ្ទុកខ្លាំងអាចត្រូវការខ្សែស្រឡាយរាប់រយ ឬរាប់ពាន់។ មានជំនឿទូទៅមួយថា ខ្សែស្រឡាយរាប់រយរាប់ពាន់អាចសម្លាប់ប្រព័ន្ធរបស់អ្នក។ នេះគឺជាជំនឿមិនពិត។
នៅក្នុងម៉ាស៊ីនមេភាគច្រើន ខ្សែស្រឡាយរង់ចាំទិន្នន័យ។ ខណៈពេលកំពុងរង់ចាំការហៅដែលរារាំង ខ្សែស្រលាយគឺអសកម្ម។ នៅក្នុងម៉ាស៊ីនមេដែលមាន 500 threads មានតែ 50 ប៉ុណ្ណោះដែលអាចសកម្មក្នុងពេលតែមួយ។
ចំនួនខ្សែស្រឡាយដែលកំពុងដំណើរការលើប្រព័ន្ធរបស់អ្នកអាចធ្វើអោយអ្នកភ្ញាក់ផ្អើល។ នៅ បរិមាណអប្បបរមាកំពុងដំណើរការម៉ាស៊ីនមេ និងកម្មវិធីដែលកំពុងដំណើរការដែលបានបញ្ជាក់ ប្រព័ន្ធរបស់ខ្ញុំមាន 333 threads ដែលត្រូវបានបង្កើតឡើង ទោះបីជាមាន 333 threads ខួរក្បាលត្រូវបានផ្ទុកត្រឹមតែ 1% ប៉ុណ្ណោះ។ ម៉ាស៊ីនមេ IIS ដែលផ្ទុកយ៉ាងខ្លាំង ( Microsoft អ៊ីនធឺណិត Information Server) អាចបង្កើត threads រាប់រយរាប់ពាន់។
ខ្សែស្រឡាយនិងផ្នែកសកល
ជាមួយនឹងខ្សែស្រឡាយច្រើន អ្នកត្រូវតែធានានូវភាពត្រឹមត្រូវនៃទិន្នន័យ នៅពេលចូលប្រើវា។ នេះប្រហែលជាពិបាកសម្រាប់អ្នកសរសេរកម្មវិធីដែលមិនបានធ្វើការជាមួយខ្សែស្រឡាយ។ ប៉ុន្តែជាទូទៅ ម៉ាស៊ីនមេភាគច្រើនមិនចាំបាច់ប្រើទិន្នន័យសកលទេ។ ម៉ាស៊ីនមេភាគច្រើនអនុវត្តមុខងារដាច់ដោយឡែក។ ខ្សែនីមួយៗអនុវត្តកិច្ចការដាច់ពីគេរបស់ខ្លួន។ ផ្នែកអាន/សរសេរជាសកលគឺជាលក្ខណៈនៃកម្មវិធីពហុខ្សែអក្សរជាច្រើន ប៉ុន្តែមិនមែនជាលក្ខណៈធម្មតាសម្រាប់ម៉ាស៊ីនមេទេ។
វិធីសាស្រ្ត Indy
Indy គឺខុសពីសមាសធាតុ Winsock ផ្សេងទៀតដែលអ្នកធ្លាប់ប្រើ។ ប្រសិនបើអ្នកបានធ្វើការជាមួយសមាសធាតុផ្សេងទៀតបន្ទាប់មក ដំណោះស្រាយដ៏ល្អបំផុតនឹងភ្លេចពីរបៀបដែលពួកគេធ្វើការ។ សមាសធាតុជាច្រើនផ្សេងទៀតប្រើការហៅទូរសព្ទដែលមិនរារាំង (អសមកាល) និងដំណើរការដោយអសមកាល។ ពួកគេត្រូវឆ្លើយតបទៅនឹងព្រឹត្តិការណ៍ បង្កើតម៉ាស៊ីនរដ្ឋ និងប្រតិបត្តិរង្វិលជុំរង់ចាំញឹកញាប់។
ឧទាហរណ៍ ជាមួយនឹងសមាសធាតុផ្សេងទៀត នៅពេលអ្នកហៅការតភ្ជាប់ អ្នកត្រូវតែរង់ចាំព្រឹត្តិការណ៍នៃការតភ្ជាប់កើតឡើង ឬរង់ចាំនៅក្នុងរង្វិលជុំសម្រាប់លក្ខណសម្បត្តិដើម្បីបង្ហាញថាការតភ្ជាប់បានកើតឡើង។ ជាមួយ Indy អ្នកអាចហៅវិធីសាស្ត្រ Connect ហើយរង់ចាំវាត្រឡប់មកវិញ។ ការសងប្រាក់វិញនឹងត្រូវបានចេញប្រសិនបើការតភ្ជាប់បានជោគជ័យ ឬករណីលើកលែងមួយត្រូវបានលើកឡើងប្រសិនបើមានបញ្ហា។ ដូច្នេះការធ្វើការជាមួយ Indy គឺស្រដៀងទៅនឹងការធ្វើការជាមួយឯកសារ។ Indy អនុញ្ញាតឱ្យអ្នកដាក់លេខកូដរបស់អ្នកទាំងអស់នៅកន្លែងតែមួយ ជំនួសឱ្យការផ្សព្វផ្សាយវាទាំងអស់។ ព្រឹត្តិការណ៍ផ្សេងៗ. លើសពីនេះទៀត Indy គឺសាមញ្ញបំផុតនិងងាយស្រួលបំផុតនៅពេលធ្វើការជាមួយខ្សែស្រឡាយ។
តើ Indy ខុសគ្នាយ៉ាងណា?
ទិដ្ឋភាពទូទៅសង្ខេប · ការទប់ស្កាត់ការហៅទូរសព្ទត្រូវបានប្រើ · មិនផ្តោតលើព្រឹត្តិការណ៍ទេ - មានព្រឹត្តិការណ៍ ប៉ុន្តែពួកវាត្រូវបានប្រើសម្រាប់តម្រូវការព័ត៌មាន និងមិនត្រូវបានទាមទារពិតប្រាកដ។ ·រចនាសម្រាប់ Threads - Indy ត្រូវបានរចនាឡើងសម្រាប់ខ្សែស្រឡាយ ប៉ុន្តែអាចប្រើដោយគ្មានខ្សែស្រឡាយ។ កម្មវិធីតាមលំដាប់លំដោយ
ការពិនិត្យលម្អិត
Indy មិន​ត្រឹម​តែ​ប្រើ​ការ​ទប់ស្កាត់​ការ​ហៅ​ទូរសព្ទ​ប៉ុណ្ណោះ​ទេ (ធ្វើ​សមកាលកម្ម) ប៉ុន្តែ​ក៏​ដំណើរការ​បែប​នេះ​ដែរ។ សម័យ Indy ធម្មតាមើលទៅដូចនេះ៖
ជាមួយ IndyClient ចាប់ផ្តើម
ភ្ជាប់; ព្យាយាម
// ធ្វើកិច្ចការរបស់អ្នកនៅទីនេះ
ទីបំផុតផ្តាច់; បញ្ចប់;
បញ្ចប់;
ជាមួយនឹងសមាសធាតុផ្សេងទៀតវាមើលទៅដូចនេះ:
នីតិវិធី TFormMain.TestOnClick(អ្នកផ្ញើ៖ TComponent);
ចាប់ផ្តើម
ជាមួយ SocketComponent ចាប់ផ្តើម
ភ្ជាប់; ព្យាយាម
ខណៈពេលដែលមិនភ្ជាប់សូមចាប់ផ្តើម
ប្រសិនបើ IsError បន្ទាប់មកចាប់ផ្តើម
រំលូតកូន;
បញ្ចប់;

OutData:= "ទិន្នន័យដែលត្រូវផ្ញើ";
ខណៈពេលដែលប្រវែង (OutData) > 0 ចាប់ផ្តើម
Application.ProcessMessages;
បញ្ចប់;
ទីបំផុតផ្តាច់; បញ្ចប់;
បញ្ចប់;
បញ្ចប់;
នីតិវិធី TFormMain.OnConnectError;
ចាប់ផ្តើម
កំហុស៖= ពិត;
បញ្ចប់;
នីតិវិធី TFormMain.OnRead;
var
ខ្ញុំ៖ ចំនួនគត់;
ចាប់ផ្តើម
i:= SocketComponent.Send(OutData);
OutData:= Copy(OutData, i + 1, MaxInt);
បញ្ចប់;
សមាសធាតុជាច្រើនមិនធ្វើការងារបានល្អក្នុងការញែកអ្នកសរសេរកម្មវិធីចេញពីជង់នោះទេ។ សមាសធាតុជាច្រើន ជំនួសឱ្យការញែកអ្នកប្រើប្រាស់ចេញពីភាពស្មុគស្មាញនៃជង់ គ្រាន់តែទុកអ្នកប្រើប្រាស់ឱ្យវា ឬផ្តល់កញ្ចប់រុំពីលើជង់។
Indy វិធីពិសេស
Indy ត្រូវ​បាន​រចនា​ឡើង​ពី​ដី​ឡើង​ទៅ​ជា​ពហុ​ខ្សែ។ ការកសាងម៉ាស៊ីនមេ និងម៉ាស៊ីនភ្ញៀវនៅក្នុង Indy គឺស្រដៀងទៅនឹងការកសាងម៉ាស៊ីនមេ និងម៉ាស៊ីនភ្ញៀវនៅក្នុងយូនីក។ កម្មវិធី Unix ជាធម្មតាហៅជង់ដោយផ្ទាល់ជាមួយនឹងស្រទាប់អរូបីតិចតួច ឬគ្មាន។
ជាធម្មតា ម៉ាស៊ីនមេ Unix មានដំណើរការស្តាប់មួយ ឬច្រើនដែលតាមដានសំណើរបស់អតិថិជនចូលមក។ សម្រាប់អតិថិជននីមួយៗដែលត្រូវការបម្រើ ក ដំណើរការថ្មី។. នេះធ្វើឱ្យកម្មវិធីសាមញ្ញ ដំណើរការនីមួយៗសម្រាប់តែអតិថិជនម្នាក់ប៉ុណ្ណោះ។ ដំណើរការនីមួយៗដំណើរការដោយខ្លួនឯង។ បរិបទផ្ទាល់ខ្លួនសុវត្ថិភាព ដែលត្រូវបានបញ្ជាក់ដោយដំណើរការស្តាប់ ឬដំណើរការដោយផ្អែកលើសិទ្ធិដែលមានស្រាប់ ការកំណត់អត្តសញ្ញាណ ឬវត្ថុផ្សេងទៀត។
ម៉ាស៊ីនមេ Indy ដំណើរការតាមរបៀបដូចគ្នា។ វីនដូ មិនដូចយូនីកទេ មិនអាចគុណដំណើរការបានល្អទេ ប៉ុន្តែវាដំណើរការល្អជាមួយខ្សែស្រឡាយ។ ម៉ាស៊ីនមេ Indy បង្កើតខ្សែស្រឡាយដាច់ដោយឡែកសម្រាប់ការតភ្ជាប់ម៉ាស៊ីនភ្ញៀវនីមួយៗ។
ម៉ាស៊ីនមេ Indy កំណត់ខ្សែស្រឡាយស្តាប់ដែលដាច់ដោយឡែកពីខ្សែកូដចម្បងរបស់កម្មវិធី។ ខ្សែស្រលាយស្តាប់ការស្នើសុំចូលពីអតិថិជន។ សម្រាប់អតិថិជននីមួយៗដែលវាឆ្លើយតប ក ខ្សែស្រឡាយថ្មី។សម្រាប់សេវាកម្មអតិថិជន។ បន្ទាប់មកព្រឹត្តិការណ៍ដែលត្រូវគ្នាត្រូវបានផ្តល់សេវានៅក្នុងបរិបទនៃខ្សែស្រឡាយនោះ។
ការពិនិត្យអតិថិជន Indy
Indy ត្រូវបានរចនាឡើងដើម្បីផ្តល់យ៉ាងខ្លាំង កម្រិតខ្ពស់អរូបី។ ភាពស្មុគ្រស្មាញ និងព័ត៌មានលម្អិតនៃជង់ TCP/IP ត្រូវបានលាក់ពីអ្នកសរសេរកម្មវិធី ជាធម្មតា វគ្គអតិថិជនធម្មតានៅក្នុង Indy មើលទៅដូចនេះ៖
ជាមួយ IndyClient ចាប់ផ្តើម
ម៉ាស៊ីន៖= "zip.pbe.com"; // ម្ចាស់ផ្ទះដើម្បីហៅ
ច្រក:= 6000; // ច្រកដើម្បីហៅម៉ាស៊ីនមេ
ភ្ជាប់; ព្យាយាម
// ធ្វើកិច្ចការរបស់អ្នកនៅទីនេះ
ទីបំផុតផ្តាច់; បញ្ចប់;
បញ្ចប់;
ទិដ្ឋភាពទូទៅនៃម៉ាស៊ីនមេ Indy
សមាសធាតុម៉ាស៊ីនមេ Indy បង្កើតខ្សែស្រលាយស្តាប់ដែលដាច់ចេញពីខ្សែស្រឡាយកូដកម្មវិធីសំខាន់។ ខ្សែស្រលាយស្តាប់ការស្នើសុំចូលពីអតិថិជន។ សម្រាប់អតិថិជននីមួយៗដែលវាឆ្លើយតប ខ្សែថ្មីត្រូវបានបង្កើតឡើងដើម្បីបម្រើអតិថិជន។ បន្ទាប់មកព្រឹត្តិការណ៍ដែលត្រូវគ្នាត្រូវបានផ្តល់សេវានៅក្នុងបរិបទនៃខ្សែស្រឡាយនោះ។

ឧទាហរណ៍ជាក់ស្តែង
ឧទាហរណ៍ខាងក្រោមគួរតែជួយអ្នកចាប់ផ្តើមជាមួយសមាសធាតុសម្រាប់ ងាយស្រួល​ប្រើប៉ុន្តែដើម្បីបង្ហាញពីឧទាហរណ៍ដែលបានធ្វើ កម្មវិធីសាមញ្ញ. គម្រោង​មួយ​ចំនួន​ត្រូវ​បាន​បង្កើត​ឡើង​ក្នុង​គោល​បំណង​ធ្វើ​បាតុកម្ម ស្ថានភាពផ្សេងៗ. ឧទាហរណ៍ទាំងនេះក៏មានសម្រាប់ទាញយកជាឯកសារ zip ផងដែរ។
ចំណាំពីអ្នកបកប្រែ៖ តំណភ្ជាប់នៅលើគេហទំព័រមិនដំណើរការទេ។
ឧទាហរណ៍ទី 1 - ការផ្ទៀងផ្ទាត់លេខកូដប្រៃសណីយ៍
គម្រោងទីមួយត្រូវបានធ្វើឡើងយ៉ាងសាមញ្ញតាមដែលអាចធ្វើទៅបាន។ ស្វែងរកតាមលេខកូដតំបន់ អតិថិជនសួរម៉ាស៊ីនមេថាតើទីក្រុងមួយណា ហើយបញ្ជាក់លេខកូដតំបន់ដែលបានបញ្ជាក់ជាកម្មសិទ្ធិ។
សម្រាប់អ្នកដែលរស់នៅក្រៅសហរដ្ឋអាមេរិក ហើយមិនដឹងថាលេខកូដប្រៃសណីយ៍ជាអ្វីនោះទេ វាគឺជាលេខកូដប្រៃសណីយ៍ដែលបង្ហាញពីទីតាំងដឹកជញ្ជូន។ លេខកូដប្រៃសណីយ៍មាន 5 ខ្ទង់។
ពិធីការ
ជំហានដំបូងក្នុងការបង្កើតម៉ាស៊ីនមេ និងម៉ាស៊ីនភ្ញៀវកំពុងបង្កើតពិធីការ។ សម្រាប់ពិធីការស្តង់ដារ នេះត្រូវបានកំណត់ដោយ RFC ដែលត្រូវគ្នា។ សម្រាប់លេខកូដប្រៃសណីយ៍ ពិធីការត្រូវបានកំណត់ដូចខាងក្រោម។
ពិធីការទំនាក់ទំនងភាគច្រើនដំណើរការក្នុងទម្រង់អត្ថបទ។ ការផ្លាស់ប្តូរមានន័យថាពាក្យបញ្ជាមួយត្រូវបានបញ្ជូន ហើយនៅក្នុងការឆ្លើយតប ស្ថានភាព និងទិន្នន័យដែលអាចកើតមាន។ ពិធីការមិនត្រូវបានកំណត់ចំពោះការផ្លាស់ប្តូរទេ ប៉ុន្តែអត្ថបទធម្មតានៅតែត្រូវបានប្រើប្រាស់។ ពិធីការសម្រាប់កំណត់លេខកូដប្រៃសណីយ៍ក៏ផ្អែកលើអត្ថបទផងដែរ។ អត្ថបទធម្មតាធ្វើឱ្យពិធីការងាយស្រួលក្នុងការបំបាត់កំហុស និងអនុញ្ញាតឱ្យទំនាក់ទំនង ភាសាផ្សេងគ្នាកម្មវិធី និងប្រព័ន្ធប្រតិបត្តិការ។
បន្ទាប់ពីភ្ជាប់រួច ម៉ាស៊ីនមេផ្ញើសារជំរាបសួរ បន្ទាប់មកទទួលយកពាក្យបញ្ជា។ ពាក្យបញ្ជានេះអាចជា "ZipCode x" (កន្លែងដែល x ជាលេខកូដតំបន់) ឬ "ចេញ" ។ ក្នុងការឆ្លើយតបទៅនឹងពាក្យបញ្ជា ZipCode ការឆ្លើយតបមួយត្រូវបានផ្ញើក្នុងទម្រង់នៃបន្ទាត់មួយជាមួយនឹងចម្លើយ ឬបន្ទាត់ទទេ ប្រសិនបើលេខកូដមិនត្រូវបានរកឃើញ។ ពាក្យបញ្ជា Quit បណ្តាលឱ្យម៉ាស៊ីនមេបិទការតភ្ជាប់។ ម៉ាស៊ីនមេអាចទទួលយកពាក្យបញ្ជាជាច្រើន មុនពេលពាក្យបញ្ជា Quit ត្រូវបានផ្ញើ។
កូដប្រភពម៉ាស៊ីនមេ

ឯកតា ServerMain;

ចំណុចប្រទាក់

ប្រើប្រាស់

ប្រភេទ

TformMain = ថ្នាក់ (TForm)

IdTCPServer1៖ TIdTCPServer;

នីតិវិធី FormCreate (អ្នកផ្ញើ៖ TObject);

នីតិវិធី FormDestroy (អ្នកផ្ញើ៖ វត្ថុ) ;

នីតិវិធី IdTCPServer1Connect(AThread: TIdPeerThread);

ឯកជន

ZipCodeList៖ TSstrings;

សាធារណៈ

បញ្ចប់;

FormMain៖ TformMain;

ការអនុវត្ត

(R*.DFM)

នីតិវិធី TformMain.IdTCPServer1Connect (AThread: TIdPeerThread);

ចាប់ផ្តើម

AThread.Connection .WriteLn ( "Indy Zip Code Server Ready" ) ;

បញ្ចប់;

SCommand: ខ្សែអក្សរ;

ចាប់ផ្តើម

SCommand:= ReadLn ;

បញ្ចប់;

បញ្ចប់;

បញ្ចប់;

នីតិវិធី TformMain.FormCreate (អ្នកផ្ញើ៖ TObject );

ចាប់ផ្តើម

ZipCodeList:= TStringList.Create ;

ZipCodeList.LoadFromFile(ExtractFilePath(Application.EXEName) + "ZipCodes.dat");

បញ្ចប់;

នីតិវិធី TformMain.FormDestroy (អ្នកផ្ញើ៖ TObject );

ចាប់ផ្តើម

ZipCodeList.Free ;

បញ្ចប់;

ចប់។

ផ្នែកតែមួយគត់នៅក្នុងគម្រោងដែល Indy ជាក់លាក់គឺសមាសភាគ IdTCPServer1 វិធីសាស្ត្រ IdTCPServer1Connect និង IdTCPServer1Execute ។
ទម្រង់នេះមានសមាសភាគ IdTCPServer1 នៃប្រភេទ TIdTCPServer ។ លក្ខណៈសម្បត្តិខាងក្រោមត្រូវបានផ្លាស់ប្តូរ៖ · សកម្ម = ពិត - បន្ទាប់ពីកម្មវិធីចាប់ផ្តើម ម៉ាស៊ីនមេនឹងស្តាប់។ DefaultPort = 6000 - តម្លៃច្រកសម្រាប់ នៃគម្រោងនេះ។. ម៉ាស៊ីនមេស្តាប់សំណើរបស់អតិថិជននៅលើច្រកនេះ។
វិធីសាស្ត្រ IdTCPServer1Execute ត្រូវបានភ្ជាប់ជាមួយព្រឹត្តិការណ៍ OnExecute របស់ម៉ាស៊ីនមេ។ ព្រឹត្តិការណ៍ OnExecute ត្រូវបានលើកឡើងបន្ទាប់ពីការភ្ជាប់អតិថិជនត្រូវបានទទួលយក។ ព្រឹត្តិការណ៍ OnExecute ខុសពីព្រឹត្តិការណ៍ផ្សេងទៀតដែលអ្នកដឹង។ OnExecute ដំណើរការក្នុងបរិបទនៃខ្សែស្រឡាយ។ ព្រឹត្តិការណ៍ខ្សែស្រឡាយត្រូវបានលើកឡើង និងផ្តល់អាគុយម៉ង់ AThread ឆ្លងទៅវិធីសាស្ត្រ។ នេះមានសារៈសំខាន់ព្រោះព្រឹត្តិការណ៍ OnExecute ច្រើនអាចត្រូវបានប្រតិបត្តិក្នុងពេលតែមួយ។ នេះត្រូវបានធ្វើដូច្នេះម៉ាស៊ីនមេអាចដំណើរការដោយមិនចាំបាច់បង្កើតសមាសភាគថ្មី។ វាក៏មានវិធីសាស្រ្តដែលអាចត្រូវបានបដិសេធនៅពេលសាងសង់អ្នកស្នង។
ព្រឹត្តិការណ៍ OnConnect ត្រូវបានបណ្តេញចេញ បន្ទាប់ពីការតភ្ជាប់ត្រូវបានទទួលយក ហើយខ្សែស្រឡាយមួយត្រូវបានបង្កើតឡើងសម្រាប់វា។ នៅក្នុងម៉ាស៊ីនមេ នេះត្រូវបានប្រើដើម្បីផ្ញើសារស្វាគមន៍ទៅកាន់អតិថិជន។ ប្រសិនបើចង់បាន នេះក៏អាចត្រូវបានធ្វើនៅក្នុងព្រឹត្តិការណ៍ OnExecute ផងដែរ។
ព្រឹត្តិការណ៍ OnExecute អាចត្រូវបានបញ្ឆេះច្រើនដងរហូតដល់ការតភ្ជាប់ត្រូវបានផ្តាច់ ឬបាត់បង់។ នេះលុបបំបាត់តម្រូវការក្នុងការត្រួតពិនិត្យការតភ្ជាប់សម្រាប់ការផ្តាច់ឬការបាត់បង់នៅក្នុងរង្វិលជុំនៅក្នុងព្រឹត្តិការណ៍មួយ។
IdTCPServer1Execute ប្រើមុខងារមូលដ្ឋានពីរគឺ ReadLn និង WriteLn ។ ReadLn អានខ្សែអក្សរពីការតភ្ជាប់ ហើយ WriteLn ផ្ញើខ្សែអក្សរទៅការតភ្ជាប់។
sCommand:= ReadLn;
កូដខាងលើយកខ្សែអក្សរពីម៉ាស៊ីនភ្ញៀវ ហើយដាក់វានៅក្នុងអថេរខ្សែអក្សរ sCommand មូលដ្ឋាន។

ប្រសិនបើ SameText (sCommand, "QUIT") បន្ទាប់មកចាប់ផ្តើម

បញ្ចប់ផ្សេងទៀតប្រសិនបើ SameText (ចម្លង (sCommand, 1, 8) , "ZipCode") បន្ទាប់មកចាប់ផ្តើម

WriteLn(ZipCodeList.Values[Copy(sCommand, 9, MaxInt)]);

បញ្ចប់;

បន្ទាប់មក sCommand ត្រូវបានពិនិត្យសម្រាប់ពាក្យបញ្ជាត្រឹមត្រូវ។
ប្រសិនបើពាក្យបញ្ជាគឺ "ចេញ" នោះការផ្តាច់ត្រូវបានអនុវត្ត។ គ្មានការអាន ឬការសរសេរត្រូវបានអនុញ្ញាតបន្ទាប់ពីការផ្តាច់។ បន្ទាប់​ពី​ព្រឹត្តិការណ៍​នេះ​បាន​បញ្ចប់ ខ្សែ​ស្រឡាយ​ស្តាប់​លែង​ហៅ​វា​ទៀត​ហើយ ប៉ុន្តែ​ជម្រះ​ខ្សែ​ស្រឡាយ​ហើយ​បិទ​ការ​តភ្ជាប់។
ប្រសិនបើពាក្យបញ្ជាគឺ "ZipCode" បន្ទាប់មកប៉ារ៉ាម៉ែត្របន្ទាប់ពីពាក្យបញ្ជាត្រូវបានស្រង់ចេញហើយតារាងត្រូវបានស្កេនសម្រាប់វត្តមាននៃទីក្រុងនិងរដ្ឋ។ បន្ទាប់មក ទីក្រុង និងរដ្ឋត្រូវបានបញ្ជូនទៅអតិថិជន ឬខ្សែអក្សរទទេត្រូវបានឆ្លងកាត់ ប្រសិនបើមិនមានការផ្គូផ្គង។
បន្ទាប់​មក​វិធី​សា​ស្រ្ត​ចេញ​។ ម៉ាស៊ីនមេនឹងធ្វើការហៅព្រឹត្តិការណ៍ម្តងទៀតភ្លាមៗនៅពេលវាមកដល់ ក្រុមថ្មី។អនុញ្ញាតឱ្យអតិថិជនផ្ញើពាក្យបញ្ជាច្រើន។
កូដប្រភពអតិថិជន

ឯកតា ClientMain;

ចំណុចប្រទាក់

ប្រើប្រាស់

Windows, សារ, SysUtils, ថ្នាក់, ក្រាហ្វិក, ការត្រួតពិនិត្យ, ទម្រង់, ប្រអប់,

StdCtrls, ExtCtrls, IdAntiFreezeBase,

IdAntiFreeze, IdBaseComponent, IdComponent, IdTCPConnection, IdTCPClient;

ប្រភេទ

TformMain = ថ្នាក់ (TForm)

អតិថិជន៖ TIdTCPCclient;

IdAntiFreeze1៖ TIdAntiFreeze;

បន្ទះទី 1: TPanel;

បន្ទះទី 2: TPanel;

MemoInput: TMemo;

លទ្ធផល Lbox៖ TListBox;

បន្ទះទី 3: TPanel;

ប៊ូតុង 1: TButton;

ប៊ូតុង 2: TButton;

ស្លាកលេខ ១៖ ស្លាកលេខ;

ដំណើរការ Button2Click(អ្នកផ្ញើ៖ TObject);

ដំណើរការ Button1Click(អ្នកផ្ញើ: TObject);

ឯកជន

សាធារណៈ

បញ្ចប់;

FormMain៖ TformMain;

ការអនុវត្ត

(R*.DFM)

នីតិវិធី TformMain.Button2Click (អ្នកផ្ញើ៖ TObject );

ចាប់ផ្តើម

MemoInput.ជម្រះ ;

LboxResults.Clear ;

បញ្ចប់;

នីតិវិធី TformMain.Button1Click (អ្នកផ្ញើ៖ TObject );

ខ្ញុំ៖ ចំនួនគត់;

S: ខ្សែអក្សរ;

ចាប់ផ្តើម

ButnLookup.Enabled := true ; ព្យាយាម

LboxResults.Clear ;

ជាមួយអតិថិជនចាប់ផ្តើម

ភ្ជាប់; ព្យាយាម

LboxResults.Items.Add(ReadLn);

សម្រាប់ i:= 0 ទៅ memoInput.Lines .Count - 1 ចាប់ផ្តើម

WriteLn("ZipCode" + memoInput.Lines[i]);

LboxResults.Items.Add(memoInput.Lines[i]);

S:= ReadLn ;

ប្រសិនបើ s = "" បន្ទាប់មកចាប់ផ្តើម

ស៖= "-- រកមិនឃើញធាតុសម្រាប់លេខកូដតំបន់នេះទេ។";

បញ្ចប់;

LboxResults.Items.Add(s);

LboxResults.Items.Add("");

បញ្ចប់;

WriteLn("ចេញ");

ទីបំផុតផ្តាច់; បញ្ចប់;

បញ្ចប់;

ទីបំផុត butnLookup.Enabled := true ; បញ្ចប់;

បញ្ចប់;

ចប់។

ផ្នែកតែមួយគត់ដែលជាក់លាក់ចំពោះសមាសភាគអតិថិជនគឺវិធីសាស្ត្រ Button1Click ។
សមាសភាគអតិថិជនគឺប្រភេទ TIdTCPClient ហើយដាក់នៅលើទម្រង់។ លក្ខណសម្បត្តិខាងក្រោមត្រូវបានផ្លាស់ប្តូរ៖ · ម៉ាស៊ីន = 127.0.0.1 - ម៉ាស៊ីនមេមានទីតាំងនៅលើម៉ាស៊ីនដូចគ្នាជាមួយម៉ាស៊ីនភ្ញៀវ។ · ច្រក = 6000 - ច្រកម៉ាស៊ីនមេ
វិធីសាស្ត្រ Button1Click ត្រូវបានភ្ជាប់ជាមួយព្រឹត្តិការណ៍ OnClick នៃសមាសភាគ Button1។ នៅពេលដែលប៊ូតុងត្រូវបានចុចវិធីសាស្ត្រនេះត្រូវបានគេហៅថា។ ផ្នែក Indy នៃវិធីសាស្រ្តនេះអាចត្រូវបានកាត់បន្ថយទៅដូចខាងក្រោម: 1.Connect to the server (Connect;) 1.Read the greeting from the server. 1. សម្រាប់បន្ទាត់នីមួយៗដែលបញ្ចូលដោយអ្នកប្រើប្រាស់នៅក្នុង TMemo: 1. ការផ្ញើសំណើទៅកាន់ម៉ាស៊ីនមេ (WriteLn("ZipCode" + memoInput.Lines[i]);) 1. ការអានការឆ្លើយតបពីម៉ាស៊ីនមេ (s:= ReadLn; ) 1. ការផ្ញើពាក្យបញ្ជា Quit (WriteLn("ចេញ");) 1.Disconnect (ផ្តាច់;)
ការធ្វើតេស្ត
ឧទាហរណ៍នេះត្រូវបានសាកល្បង និងដំណើរការជាមួយ TCP/IP ដែលបានដំឡើង។ អ្នកអាចផ្លាស់ប្តូរវាឱ្យដំណើរការលើបណ្តាញពីកុំព្យូទ័រមួយទៅកុំព្យូទ័រមួយទៀត។ ដោយចាប់ផ្តើមម៉ាស៊ីនមេនៅលើកុំព្យូទ័រមួយផ្សេងទៀត និងផ្លាស់ប្តូរឈ្មោះ ឬ IP របស់ម៉ាស៊ីនមេនៅលើម៉ាស៊ីនភ្ញៀវ។
ដើម្បីសាកល្បងគម្រោង ចងក្រង និងដំណើរការម៉ាស៊ីនមេ។ បន្ទាប់មកចងក្រង និងដំណើរការម៉ាស៊ីនភ្ញៀវ។ បញ្ចូល​លេខ​កូដ​ប្រៃសណីយ៍​របស់​អ្នក​ក្នុង​វាល​អនុស្សរណៈ ហើយ​ចុច​គ្រាប់ចុច​រកមើល។
ការបំបាត់កំហុស
ពិធីការ​អត្ថបទ​គឺ​ងាយ​ស្រួល​ក្នុង​ការ​បំបាត់​កំហុស ព្រោះ​វា​អាច​ត្រូវ​បាន​សាកល្បង​ដោយ​ប្រើ Telnet។ ដើម្បីធ្វើដូចនេះវាគ្រប់គ្រាន់ដើម្បីដឹងពីច្រកម៉ាស៊ីនមេ។ ម៉ាស៊ីនបម្រើរកមើលលេខកូដប្រៃសណីយ៍ស្តាប់នៅលើច្រក 6000 ។
ចាប់ផ្តើមម៉ាស៊ីនមេស្វែងរកលេខកូដប្រៃសណីយ៍ម្តងទៀត។ បន្ទាប់មកបើកកុងសូល (ឧ. បង្អួច Dos)។ ឥឡូវបញ្ចូល៖
telnet 127.0.0.1 6000
ឥឡូវនេះអ្នកបានភ្ជាប់ទៅម៉ាស៊ីនមេ។ ម៉ាស៊ីនមេខ្លះក៏ផ្ញើសារស្វាគមន៍ផងដែរ។ អ្នកខ្លះមិនធ្វើ។ អ្នកនឹងមិនឃើញបន្ទាត់ដែលអ្នកបញ្ចូលទេ។ ម៉ាស៊ីនមេភាគច្រើនមិនបញ្ចេញសំឡេង ដើម្បីរក្សាទុកចរាចរណ៍។ ទោះយ៉ាងណាក៏ដោយ អ្នកអាចផ្លាស់ប្តូរការកំណត់ telnet ដោយកំណត់ជម្រើស "Echo On"។ វា​ត្រូវ​បាន​ធ្វើ​ខុស​គ្នា​ក្នុង​ម៉ាស៊ីន​ភ្ញៀវ telnet ផ្សេង​គ្នា ហើយ​ខ្លះ​មិន​មាន​លក្ខណៈ​ពិសេស​នេះ​ទាល់​តែ​សោះ។ ឥឡូវបញ្ចូល៖
លេខ​កូដ​តំបន់ 37642
អ្នកនឹងឃើញការឆ្លើយតបរបស់ម៉ាស៊ីនមេ៖
ព្រះវិហារ HILL, TN
ដើម្បីផ្តាច់ចេញពីម៉ាស៊ីនមេ សូមបញ្ចូល៖
ឈប់
ឧទាហរណ៍ទី 2 - ការចូលប្រើមូលដ្ឋានទិន្នន័យ
ឧទាហរណ៍នេះត្រាប់តាមម៉ាស៊ីនមេដែលត្រូវតែអនុវត្តភារកិច្ចទប់ស្កាត់ក្រៅពីការហៅតាមរន្ធ។ ម៉ាស៊ីនមេជាច្រើនត្រូវបានបង្ខំឱ្យធ្វើការក្នុងលក្ខខណ្ឌបែបនេះ។ ម៉ាស៊ីនមេដែលត្រូវការចូលប្រើមូលដ្ឋានទិន្នន័យ ហៅនីតិវិធីខាងក្រៅ ឬការគណនា ជារឿយៗមិនអាចរំខានការហៅទាំងនេះបានទេ ព្រោះវាជាការហៅខាងក្រៅ ឬដោយសារភាពស្មុគស្មាញនេះ។ ការចូលប្រើមូលដ្ឋានទិន្នន័យមិនអាចបំបែកជាបំណែកតូចៗបានទេ ហើយអ្នកអភិវឌ្ឍន៍ត្រូវតែរង់ចាំប្រតិបត្តិការជាមួយមូលដ្ឋានទិន្នន័យដើម្បីបញ្ចប់។ នេះគឺជាលក្ខណៈពិសេសមិនត្រឹមតែនៃការហៅទិន្នន័យប៉ុណ្ណោះទេ ប៉ុន្តែក៏មានប្រតិបត្តិការផ្សេងទៀតផងដែរ ដូចជាការបង្ហាប់ ការគណនា និងដំណើរការផ្សេងទៀតនៃប្រភេទដូចគ្នា។
សម្រាប់គោលបំណងបង្ហាញ សូមស្រមៃថាម៉ាស៊ីនមេធ្វើការហៅទិន្នន័យដែលចំណាយពេល 5 វិនាទីដើម្បីបញ្ចប់។ ដើម្បីធ្វើឲ្យសាមញ្ញ យើងធ្វើវាដោយគ្រាន់តែផ្អាកមួយសិន ប្រើមុខងារ Sleep(5000) សម្រាប់ការនេះ ជំនួសឱ្យការហៅតាមពិត។
ឧទាហរណ៍​នេះ​ក៏​ទាមទារ​លម្អិត​តិច​ជាង​ឧទាហរណ៍​មុន​ដែរ ព្រោះ​គោល​គំនិត​ជា​ច្រើន​មិន​ទាន់​យល់។
ប្រភព

ឯកតាសំខាន់;

ចំណុចប្រទាក់

ប្រើប្រាស់

Windows, សារ, SysUtils, ថ្នាក់, ក្រាហ្វិក, ការត្រួតពិនិត្យ, ទម្រង់, ប្រអប់,

IdBaseComponent, IdComponent, IdTCPServer;

ប្រភេទ

TformMain = ថ្នាក់ (TForm)

IdTCPServer1៖ TIdTCPServer;

នីតិវិធី IdTCPServer1Execute(AThread: TIdPeerThread);

ឯកជន

សាធារណៈ

បញ្ចប់;

FormMain៖ TformMain;

ការអនុវត្ត

(R*.DFM)

នីតិវិធី TformMain.IdTCPServer1Execute (AThread: TIdPeerThread);

ខ្ញុំ៖ ចំនួនគត់;

ចាប់ផ្តើម

ជាមួយ AThread.Connection ចាប់ផ្តើម

WriteLn("ជំរាបសួរ។ DB Server រួចរាល់។");

ខ្ញុំ៖= StrToIntDef(ReadLn, 0);

// ការគេងត្រូវបានជំនួសដោយការហៅវែង DB ឬការហៅផ្សេងទៀត។

គេង (5000);

WriteLn(IntToStr(i * 7));

បញ្ចប់;

បញ្ចប់;

ចប់។

ដោយសារតែព្រឹត្តិការណ៍ Execute កើតឡើងនៅក្នុងបរិបទនៃខ្សែស្រឡាយ កូដដំណើរការអាចមានប្រវែងណាមួយ។ អតិថិជននីមួយៗមានខ្សែស្រឡាយផ្ទាល់ខ្លួន ហើយមិនរារាំងអតិថិជនផ្សេងទៀតទេ។
ការធ្វើតេស្ត
ដើម្បីសាកល្បងម៉ាស៊ីនមេ DB សូមចងក្រង និងដំណើរការវា។ ភ្ជាប់ទៅវាដោយប្រើ Telnet ទៅកាន់ច្រក 6001។ ម៉ាស៊ីនមេនឹងឆ្លើយតបជាមួយនឹងសារស្វាគមន៍។ បញ្ចូលលេខ។ ម៉ាស៊ីនមេនឹង "ដំណើរការ" សំណើរបស់អ្នក ហើយឆ្លើយតបក្នុងរយៈពេល 5 វិនាទី។

សួស្តី​អ្នក​ទាំងអស់គ្នា!

នៅពេលបង្កើតគម្រោងបណ្តាញបន្ទាប់ ភារកិច្ចបានកើតឡើង - ដើម្បីអនុវត្តកម្មវិធីអតិថិជននៅក្នុង Delphi ដែលនឹងផ្ទេរទិន្នន័យទៅម៉ាស៊ីនមេដោយប្រើវិធីសាស្ត្រ POST ។ កម្មវិធីត្រូវតែបញ្ជូនអត្ថបទ និងផ្ទុកឡើងឯកសារទៅកាន់ម៉ាស៊ីនមេគេហទំព័រ។

ការអនុវត្តការបញ្ជូនទិន្នន័យបែបនេះដោយប្រើភាសាអភិវឌ្ឍន៍គេហទំព័រផ្នែកខាងម៉ាស៊ីនមេ (ឧទាហរណ៍ PHP) គឺសាមញ្ញណាស់ ប៉ុន្តែប្រសិនបើអ្នកត្រូវការសរសេរកម្មវិធីដែលមានមូលដ្ឋានលើកម្មវិធីពហុអ្នកប្រើប្រាស់ដែលធ្វើអន្តរកម្មជាមួយម៉ាស៊ីនមេ នោះវាបន្តិចទៀត។ ភាព​ស្មុគស្មាញ។ វិធីសាស្រ្តនៃការតភ្ជាប់ដោយផ្ទាល់ទៅមូលដ្ឋានទិន្នន័យ និងតាមរយៈ FTP ទៅកាន់ម៉ាស៊ីនមេពី Delphi គឺមិនចាំបាច់ទៀតទេព្រោះ វាមិនមានសុវត្ថិភាព មិនគួរឱ្យទុកចិត្ត (ការផ្លាស់ប្តូរពាក្យសម្ងាត់ ទិន្នន័យការតភ្ជាប់។ បញ្ហាភាពឆបគ្នានៃកម្មវិធីនៅផ្នែកអតិថិជន។ ដើម្បីដោះស្រាយបញ្ហា ខ្ញុំបានសម្រេចចិត្តសរសេរស្គ្រីបនៅក្នុង PHP (ផ្នែកម៉ាស៊ីនមេ) ដែលនឹងដំណើរការសំណើ POST ចូល ហើយត្រឡប់លទ្ធផលទៅអតិថិជន (កម្មវិធី Delphi) ។ គុណសម្បត្តិនៃវិធីសាស្រ្តនេះគឺថាការតភ្ជាប់ និងដំណើរការទិន្នន័យទាំងអស់កើតឡើងនៅលើម៉ាស៊ីនមេ ដែលមានសុវត្ថិភាពជាង "ការតភ្ជាប់" ដោយផ្ទាល់។

នៅពេលខ្ញុំចាប់ផ្តើមហ្គូហ្គល ព័ត៌មានដែលខ្ចាត់ខ្ចាយជាច្រើនត្រូវបានបោះបង់ចោល ដែលភាគច្រើននៅលើវេទិការ ប៉ុន្តែវាជាបំណែកៗទាំងអស់។ រឿងមួយគឺប្រាកដថា Indy នឹងត្រូវបានប្រើប្រាស់ ពោលគឺសមាសភាគ IdHTTP ជាមួយនឹងវិធីសាស្ត្រ POST ដែលត្រូវបានអនុវត្ត។ នៅក្នុងខ្លឹមសារ អ្វីគ្រប់យ៉ាងគឺសាមញ្ញ វិធីសាស្ត្រនេះយកប៉ារ៉ាម៉ែត្រពីរ Url នៃធនធាន និង DataStream (ស្ទ្រីមទិន្នន័យ) ហើយជាការឆ្លើយតប វាត្រឡប់លទ្ធផលជាទម្រង់អត្ថបទ (វាអាចជាកូដ HTML នៃទំព័រផងដែរ)។ រឿងចំបងគឺ ការបង្កើតត្រឹមត្រូវ។ DataStream (ស្ទ្រីមនៃទិន្នន័យដែលបានបញ្ជូន) ប៉ុន្តែនៅតាមផ្លូវមានរណ្តៅបន្ថែមចេញមក ពោលគឺការអ៊ិនកូដជាភាសារុស្សី (ប្រសិនបើវាមិនល្អ)។ នេះគឺជាកន្លែងដែលភាពសប្បាយរីករាយបានចាប់ផ្តើមអស់រយៈពេលជាច្រើនម៉ោងនៃការដើរជុំវិញអ៊ីនធឺណិត។ ជាទូទៅ ការជជែកគ្នាគ្រប់គ្រាន់ ចូរយើងបន្តទៅការអនុវត្ត និងការអនុវត្តកម្មវិធី។

ដូច្នេះកម្មវិធីគឺសាមញ្ញ។ នាងត្រូវតែផ្ញើទិន្នន័យទៅម៉ាស៊ីនមេដោយប្រើវិធីសាស្ត្រ POST ទិន្នន័យមាន " ក្បាល "(បន្ទាត់)," ការពិពណ៌នា " (អត្ថបទច្រើន) និង ឯកសារក្រាហ្វិក(jpg, png, gif-ទិន្នន័យគោលពីរ) ។ ម៉ាស៊ីនមេត្រូវតែទទួលយកទិន្នន័យនេះ ដំណើរការវា រក្សាទុកឯកសារក្រាហ្វិកនៅលើម៉ាស៊ីនមេ ហើយត្រឡប់ការឆ្លើយតបវិញ។ ជាការឆ្លើយតប យើងនឹងប្រគល់ Delphi ទៅកាន់កម្មវិធីវិញ អត្ថបទដូចគ្នាតែជាមួយស្លាកដែលបានបន្ថែម និងតំណទៅកាន់ឯកសារដែលបានទាញយកប៉ុណ្ណោះ។ គ្មានអ្វី​ទៀត​ទេ។

ចូរចាប់ផ្តើមជាមួយនឹងការអនុវត្តផ្នែកម៉ាស៊ីនមេ (ស្រដៀងទៅនឹង API របស់គេហទំព័រ)។ បើកកម្មវិធីនិពន្ធអត្ថបទណាមួយ (notepad) ហើយសរសេរកូដខាងក្រោមនៅក្នុងវា៖

";) else (បន្ទរ "ចំណងជើង៖ បាត់"។
"; ) // ពិនិត្យមើលទិន្នន័យចូលសម្រាប់វត្តមាននៃទិន្នន័យវាល "មាតិកា" ប្រសិនបើ (!empty($_POST["content"]))(បន្ទរ "មាតិកា៖ ".$_POST["មាតិកា"]។
";) else (បន្ទរ "ខ្លឹមសារ៖ បាត់"។
"; ) // ពិនិត្យមើលទិន្នន័យចូលសម្រាប់វត្តមាននៃឯកសារភ្ជាប់ "ឯកសារ" ប្រសិនបើ (!empty($_FILES["file"])) ( $finfo = pathinfo($_FILES["file"]["name" ]); // ទទួលបានព័ត៌មានអំពីឯកសារ (ឈ្មោះ ផ្នែកបន្ថែម។ )==0)( បន្ទរ ">>>>>>> ប្រភេទឯកសារមិនត្រឹមត្រូវ<<<<<<<<"; exit; //Если не допустим тип, полностью останавливаем скрипт } $fname = "files/" . "testimgfile." . $finfo["extension"]; //формируем путь и новое имя файла move_uploaded_file($_FILES["file"]["tmp_name"],$fname);//сохраняем временный файл "tmp_name" в файл $fname echo "http://".$_SERVER["HTTP_HOST"]."/".$fname; //возвращаем полный путь к файлу } ?>

ចំណាំ! នៅពេលរក្សាទុក (តាមរយៈ notepad) អ្នកត្រូវតែបញ្ជាក់ការអ៊ិនកូដ "UTF-8" បើមិនដូច្នេះទេវានឹងមានបញ្ហាជាមួយការបង្ហាញអក្ខរក្រម Cyrillic!

ស្គ្រីបបានព្យាយាមផ្តល់មតិលម្អិត។ ចម្លងស្គ្រីបនេះទៅម៉ាស៊ីនមេគេហទំព័ររបស់អ្នក ប្រសិនបើអ្នកមិនមានទេ អ្នកអាចប្រើស្គ្រីបរបស់ខ្ញុំសម្រាប់ការសាកល្បង វាមានទីតាំងនៅ៖ http://api..php

ប្លង់ប្រើប្រាស់សមាសធាតុដូចខាងក្រោម៖ ស្លាក ប៊ូតុង (2 កុំព្យូទ័រ) កែសម្រួល (2 កុំព្យូទ័រ) អនុស្សរណៈ (2 កុំព្យូទ័រ) ប្រអប់ធីកប្រអប់ OpenDialog IdHTTP ។ ផ្តល់ឈ្មោះសមាសភាគខាងក្រោម (លក្ខណសម្បត្តិ " ឈ្មោះ”):

1. កែសម្រួល (ចំណងជើង) - ឈ្មោះ = ចំណងជើង;
2. កែសម្រួល (ផ្លូវទៅកាន់ឯកសារ) – ឈ្មោះ = imgfile;
3. អនុស្សរណៈ (មាតិកា) – ឈ្មោះ = មាតិកា;
4. អនុស្សរណៈ (លទ្ធផល) - ឈ្មោះ = ការឆ្លើយតប;
5. ប៊ូតុង (...) - ឈ្មោះ = chkfile;
6. ប៊ូតុង (POST) - ឈ្មោះ = PostBut;
7. OpenDialog (ប្រអប់ជ្រើសរើសឯកសារ) - ឈ្មោះ = PictDialog;

តោះទុក IdHTTP1 និង CheckBox1 មិនផ្លាស់ប្តូរ (ធុញ! :)))) ។

ដើម្បីកុំឱ្យចៃដន្យ” កែសម្រួល» ផ្លូវដើម្បីកែសម្រួល ( imgfile) កំណត់លក្ខណៈសម្បត្តិ ReadOnly របស់វាទៅជាពិត។ ដូចគ្នានេះដែរនៅ imgfileនិង chkfileកំណត់លក្ខណៈសម្បត្តិដែលបានបើកទៅជាមិនពិត។ យើងនឹងធ្វើឱ្យពួកវាសកម្មដោយប្រើ CheckBox, i.e. យើងនឹងផ្តល់ឱកាសដើម្បីជ្រើសរើសថាតើត្រូវបង្ហោះរូបភាពឬអត់។

សម្រាប់ OpenDialog( PictDialog) អ្នកត្រូវកំណត់តម្រង (Filter property) ដូចតទៅ៖

ការរៀបចំជាក់ស្តែងគឺចប់ហើយ! តោះចាប់ផ្តើមសរសេរកូដ!

នៅក្នុងគម្រោង យើងនឹងបង្កើតលំហូរទិន្នន័យដោយប្រើប្រភេទរួមបញ្ចូលជាមួយ Indy - TidMultiPartFormDataStreamទោះបីជាយើងបានឆ្លងកាត់ជម្រើសនៃការអនុវត្តដោយប្រើ TStream ដោយធ្វើការជាមួយ TidMultiPartFormDataStream –កាន់តែងាយស្រួល!

ដើម្បីធ្វើឱ្យប្រភេទនេះមាននៅក្នុងគម្រោងរបស់យើង យើងត្រូវបន្ថែមបណ្ណាល័យខាងក្រោមទៅការប្រើប្រាស់៖ IdMultipartFormData.

សម្រាប់ CheckBox1 បង្កើតព្រឹត្តិការណ៍ OnClick (ដោយចុចពីរដងលើវត្ថុ) ហើយបន្ថែមកូដខាងក្រោមទៅព្រឹត្តិការណ៍នេះ៖

នីតិវិធី TForm1.CheckBox1Click(Sender: TObject); ចាប់ផ្តើម // ធ្វើឱ្យសកម្ម ឬអសកម្មធាតុផ្លូវឯកសារ និងប៊ូតុងប្រអប់ imgfile.Enabled:=CheckBox1.Checked; chkfile.Enabled:=CheckBox1.Checked; បញ្ចប់;

នៅទីនេះយើងធ្វើឱ្យវត្ថុសកម្ម imgfile និងchkfileអាស្រ័យលើវត្តមាននៃសញ្ញាធីក (ប្រសិនបើប្រអប់ធីកត្រូវបានធីក នោះវត្ថុក្លាយជាសកម្ម)។

ឥឡូវនេះសូមរៀបចំការជ្រើសរើសរូបភាព។ ដើម្បីធ្វើដូចនេះបង្កើតព្រឹត្តិការណ៍ OnClick នៅលើប៊ូតុង chkfile(ដោយចុចពីរដងលើវត្ថុ) ហើយសរសេរដូចខាងក្រោមៈ

នីតិវិធី TForm1.chkfileClick(អ្នកផ្ញើ៖ TObject); ចាប់ផ្តើម // បើកប្រអប់ ហើយបញ្ចូលផ្លូវពេញទៅកាន់ឯកសារក្នុង imgfile(TEdit) ប្រសិនបើ PictDialog.Execute បន្ទាប់មក imgfile.Text:= PictDialog.FileName; បញ្ចប់;

ព្រឹត្តិការណ៍នេះនឹងចាប់ផ្តើមប្រអប់ជ្រើសរើសរូបភាព ហើយប្រសិនបើអ្នកប្រើចុច " បើក" បន្ទាប់មកផ្លូវទៅកាន់ឯកសារនេះនឹងត្រូវបានបន្ថែមទៅ imgfile.

ហើយឥឡូវនេះយើងមកដល់ប៊ូតុង "POST" ចុងក្រោយ។ បង្កើតព្រឹត្តិការណ៍ OnClick សម្រាប់ប៊ូតុងនេះ ហើយបន្ថែមកូដខាងក្រោម៖

នីតិវិធី TForm1.PostButClick(អ្នកផ្ញើ៖ TObject); var dataPost:TIdMultiPartFormDataStream; ចាប់ផ្តើម dataPost:=TIdMultiPartFormDataStream.Create; dataPost.AddFormField("title",title.Text,"utf-8").ContentTransfer:= "8bit"; dataPost.AddFormField("content",content.Text,"utf-8").ContentTransfer:= "8bit"; ប្រសិនបើ CheckBox1.Checked និង (trim(imgfile.Text)="") បន្ទាប់មក // ពិនិត្យមើលថាតើឯកសារត្រូវបានជ្រើសរើស ឬមិនចាប់ផ្តើម ShowMessage("អ្នកត្រូវតែជ្រើសរើសឯកសារក្រាហ្វិក!"); ចេញ; បញ្ចប់; ប្រសិនបើ CheckBox1.Checked បន្ទាប់មក dataPost.AddFile("file",imgfile.Text,""); // បន្ថែមវាលជាមួយឯកសារឆ្លើយតប។ អត្ថបទ៖= StringReplace(idHTTP1.Post("http://api..php",dataPost),"
",#13#10,); datapost.Free; end;

ដូច្នេះតាមលំដាប់ (ទោះបីជាមានមតិយោបល់ក៏ដោយ)៖

ឃ្លាំងទិន្នន័យ - វត្ថុនៃប្រភេទ TIdMultiPartFormDataStream. អនុញ្ញាតឱ្យអ្នកបង្កើតរចនាសម្ព័ន្ធសំណើ POST ដែលមានវាលនៃប្រភេទផ្សេងៗគ្នា។

ប្រកាសទិន្នន័យ . AddFormField (" ចំណងជើង ", ចំណងជើង . អត្ថបទ ," utf -8 "). ការផ្ទេរមាតិកា := " 8 ប៊ីត "; - បន្ថែមវាលមួយដែលមានឈ្មោះថា "ចំណងជើង" ទៅ DataPost ដែលជាតម្លៃពី "title.Text" កំណត់ការអ៊ិនកូដទិន្នន័យដែលបានបញ្ជូនទៅជា "utf-8" (ប៉ារ៉ាម៉ែត្រគឺស្រេចចិត្ត ប៉ុន្តែដោយគ្មានការបង្ហាញច្បាស់លាស់របស់វា Cyrillic ត្រូវបានបញ្ជូនជាមួយ សញ្ញាសួរថា "?") និងវិធីសាស្រ្តសំខាន់ "ការផ្ទេរមាតិកា" ។ បើគ្មានវិធីសាស្ត្រនេះទេ ទិន្នន័យត្រូវបានផ្ញើទៅកាន់ម៉ាស៊ីនមេ" abracadabra" សូមចំណាំថាឈ្មោះវាល ("ចំណងជើង") នៅផ្នែកផ្ញើត្រូវតែត្រូវគ្នានឹងឈ្មោះដែលបានបញ្ជាក់នៅក្នុងស្គ្រីប៖ $_POST["title"] ។

ទិន្នន័យត្រូវបានផ្ទេរស្រដៀងគ្នាទៅនឹងវាល "មាតិកា" ។

ប្រកាសទិន្នន័យ . បន្ថែមឯកសារ (" ឯកសារ ", imgfile . អត្ថបទ ,"") - ជាមួយបន្ទាត់នេះ យើងបង្កើតស្ទ្រីមជាមួយទិន្នន័យពីឯកសារ។

នោះហើយជាវា ទិន្នន័យត្រូវបានបង្កើត អ្វីដែលនៅសល់គឺត្រូវផ្ទេរវាទៅស្គ្រីបនៅលើម៉ាស៊ីនមេ ហើយទទួលការឆ្លើយតប៖

response.Text:= StringReplace(idHTTP1.Post("http://api..php",dataPost),"
",#13#10,);

ដោយសារតែ TMemo មិនយល់ពីស្លាកបំបែកបន្ទាត់ "
", យើងនឹងប្រើមុខងារដើម្បីជំនួសវាដោយការបំបែកបន្ទាត់ដែលអាចយល់បាន " # 13 # 10 " ។

នៅពេលដែលអ្វីៗគ្រប់យ៉ាងរួចរាល់ សូមសម្អាតអង្គចងចាំពីវត្ថុ DataPost ដោយប្រើបន្ទាត់៖

datapost.Free;

ទោះបីជានៅក្នុងឧទាហរណ៍របស់យើង វានឹងកើតឡើងដោយស្វ័យប្រវត្តិនៅចុងបញ្ចប់នៃនីតិវិធី ប៉ុន្តែនៅតែ...

លទ្ធផលជាក់ស្តែងនៃកម្មវិធីនៅលើអេក្រង់៖

ដូច្នេះ យើងអាចផ្ញើទិន្នន័យ ឬឯកសារជាច្រើនទៅម៉ាស៊ីនមេតាមដែលយើងចង់បាន ដំណើរការទិន្នន័យនេះនៅលើម៉ាស៊ីនមេ ហើយរាយការណ៍ត្រឡប់ទៅកម្មវិធីវិញនូវលទ្ធផលនៃស្គ្រីប។ វាអាចគ្រាន់តែជា 0 ឬ 1 ដែលនឹងផ្តល់សញ្ញាឱ្យកម្មវិធីមានប្រតិកម្មបន្ថែមទៀត។

ទាំងអស់។ សូមសំណាងល្អទាំងអស់គ្នា។ ខ្ញុំសង្ឃឹមថាព័ត៌មានមានប្រយោជន៍ ហើយអ្នកនឹងរកឃើញការប្រើប្រាស់សម្រាប់វា។

អ្នកអាចទាញយកឧទាហរណ៍ និងស្គ្រីបដែលបានបញ្ចប់។

កូដម៉ូឌុលពេញលេញ៖

អង្គភាព PostUnit; ចំណុចប្រទាក់ប្រើ Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, IdBaseComponent, IdComponent, IdTCPConnection, IdTCPClient, IdHTTP, IdMultipartFormData, Vcl.ExtDlgs; ប្រភេទ TForm1 = class(TForm) IdHTTP1: TIdHTTP; ចំណងជើង៖ TEdit; មាតិកា៖ TMemo; PostBut: TButton; ការឆ្លើយតប៖ TMemo; ស្លាកលេខ ១៖ ស្លាកលេខ; ស្លាកលេខ ២៖ ស្លាកលេខ; ស្លាកលេខ 3: TLabel; imgfile: TEdit; chkfile: TButton; ស្លាកលេខ ៤៖ ស្លាកលេខ; ប្រអប់ធីក១៖ ធីឆេកប្រអប់; PictDialog៖ TOPenDialog; នីតិវិធី PostButClick (អ្នកផ្ញើ៖ TObject); ដំណើរការ chkfileClick(អ្នកផ្ញើ៖ TObject); ដំណើរការ CheckBox1Click (អ្នកផ្ញើ៖ TObject); ឯកជន ( សេចក្តីប្រកាសឯកជន ) សាធារណៈ ( សេចក្តីប្រកាសសាធារណៈ ) បញ្ចប់; var Form1: TForm1; ការអនុវត្ត ($R *.dfm) នីតិវិធី TForm1.CheckBox1Click(អ្នកផ្ញើ៖ TObject); ចាប់ផ្តើម // ធ្វើឱ្យសកម្ម ឬអសកម្មធាតុផ្លូវឯកសារ និងប៊ូតុងប្រអប់ imgfile.Enabled:=CheckBox1.Checked; chkfile.Enabled:=CheckBox1.Checked; បញ្ចប់; នីតិវិធី TForm1.chkfileClick(អ្នកផ្ញើ៖ TObject); ចាប់ផ្តើម // បើកប្រអប់ ហើយបញ្ចូលផ្លូវពេញទៅកាន់ឯកសារក្នុង imgfile(TEdit) ប្រសិនបើ PictDialog.Execute បន្ទាប់មក imgfile.Text:= PictDialog.FileName; បញ្ចប់; នីតិវិធី TForm1.PostButClick(អ្នកផ្ញើ៖ TObject); var dataPost:TIdMultiPartFormDataStream; ចាប់ផ្តើម dataPost:=TIdMultiPartFormDataStream.Create; dataPost.AddFormField("title",title.Text,"utf-8").ContentTransfer:= "8bit"; dataPost.AddFormField("content",content.Text,"utf-8").ContentTransfer:= "8bit"; ប្រសិនបើ CheckBox1.Checked និង (trim(imgfile.Text)="") បន្ទាប់មក // ពិនិត្យមើលថាតើឯកសារត្រូវបានជ្រើសរើស ឬមិនចាប់ផ្តើម ShowMessage("អ្នកត្រូវតែជ្រើសរើសឯកសារក្រាហ្វិក!"); ចេញ; បញ្ចប់; ប្រសិនបើ CheckBox1.Checked បន្ទាប់មក dataPost.AddFile("file",imgfile.Text,""); // បន្ថែមវាលជាមួយឯកសារឆ្លើយតប។ អត្ថបទ៖= StringReplace(idHTTP1.Post("http://api..php",dataPost),"
",#13#10,); datapost.Free; end; end.

Indy គឺជាកញ្ចប់ដ៏មានអានុភាពនៃសមាសធាតុដែលអនុញ្ញាតឱ្យអ្នកបង្កើតកម្មវិធីបណ្តាញផ្សេងៗ។ នៅក្នុងការបង្រៀននេះ ខ្ញុំនឹងប្រាប់អ្នកពីរបៀបដែលអ្នកអាចបង្កើតកម្មវិធី client-server ដោយប្រើសមាសធាតុ TIdTCPClient និង TIdTCPServer ។

ជាដំបូងខ្ញុំចង់កត់សម្គាល់គុណសម្បត្តិសំខាន់ពីរនៃសមាសធាតុទាំងនេះ។ ចំនុចសំខាន់បំផុតគឺ multithreading ដែលមានន័យថា server បង្កើត thread ដាច់ដោយឡែកសម្រាប់ client នីមួយៗ ហើយនេះពិតជាប៉ះពាល់ដល់ដំណើរការនៃ server program នៅលើកុំព្យូទ័រជាមួយនឹង multi-core processor ។ អត្ថប្រយោជន៍ទីពីរគឺភាពងាយស្រួលនៃការប្រើប្រាស់។ 10-20 ជួរនៃកូដគឺគ្រប់គ្រាន់ដើម្បីសរសេរកម្មវិធីម៉ាស៊ីនភ្ញៀវសាមញ្ញ។ កញ្ចប់នៃសមាសភាគនេះមានវត្តមាននៅក្នុងសន្និបាត Delphi ស្តង់ដារ។

ចូរយើងសរសេរកម្មវិធីសាមញ្ញមួយដែលអនុញ្ញាតឱ្យអ្នកបញ្ជូនសារអត្ថបទពីម៉ាស៊ីនភ្ញៀវទៅម៉ាស៊ីនមេ។ ចូរចាប់ផ្តើមបង្កើតម៉ាស៊ីនមេ។
តោះដាក់សមាសភាគ IdTCPServer ពីផ្ទាំង "Indy Servers" នៅលើទម្រង់។ យើងនឹងធ្វើការកំណត់ទាំងអស់សម្រាប់សមាសភាគនេះនៅពេលដំណើរការនៅក្នុងព្រឹត្តិការណ៍ OnCreate នៃទម្រង់៖
IdTCPServer1.DefaultPort:= 12345;
IdTCPServer1.Active:= true;
អ្វីគ្រប់យ៉ាងគឺសាមញ្ញនៅទីនេះ - យើងចង្អុលបង្ហាញច្រកដែលម៉ាស៊ីនមេនឹងដំណើរការ និងធ្វើឱ្យម៉ាស៊ីនមេខ្លួនឯងសកម្ម។

ដើម្បីទទួលបានទិន្នន័យនៅលើម៉ាស៊ីនមេពីអតិថិជន មានព្រឹត្តិការណ៍ពិសេសមួយ “OnExecute”។ ព្រឹត្តិការណ៍នេះមើលទៅដូចនេះ៖

ចាប់ផ្តើម
បញ្ចប់;

តោះកែសម្រួលខ្លឹមសារព្រឹត្តិការណ៍ដូចខាងក្រោម៖
នីតិវិធី TForm3.IdTCPServer1Execute(AContext: TIdContext);
var
l: ខ្សែអក្សរ; // អថេរខ្សែអក្សរដែលយើងនឹងទទួលបាន
ចាប់ផ្តើម
l:= AContext.Connection.IOHandler.ReadLn();
Memo1.Lines.Add(l);
បញ្ចប់;

ឥឡូវនេះ ដរាបណាសារមកដល់ម៉ាស៊ីនមេ យើងនឹងសរសេរវាទៅអថេរខ្សែអក្សរ l ហើយបញ្ចូលវាទៅវាលអត្ថបទពហុជួរ។

នេះមិនគួរឱ្យភ្ញាក់ផ្អើលទេដែលបញ្ចប់ការបង្កើតម៉ាស៊ីនមេ។ Indy នឹងធ្វើអ្វីៗដែលនៅសល់សម្រាប់យើង។ តោះចាប់ផ្តើមជាមួយកម្មវិធីអតិថិជន។ វានឹងភ្ជាប់ទៅម៉ាស៊ីនមេ ផ្ញើសារទៅវា ហើយផ្តាច់ចេញពីម៉ាស៊ីនមេ។

តោះបង្កើតគម្រោងថ្មី ហើយដាក់សមាសភាគ IdTCPClient នៅលើទម្រង់ ដែលអាចត្រូវបានរកឃើញនៅលើផ្ទាំង “Indy Clients”។ យើងក៏នឹងដាក់ការកែសម្រួលសាមញ្ញ និងប៊ូតុងមួយ។ តោះបង្កើតកម្មវិធីដោះស្រាយព្រឹត្តិការណ៍ OnClick សម្រាប់ប៊ូតុង ដែលនៅខាងក្នុងដែលយើងនឹងសរសេរ៖
IdTCPClient1.Port:= 12345;
IdTCPClient1.Host:= '127.0.0.1';
IdTCPCclient1.ភ្ជាប់;
IdTCPClient1.IOHandler.WriteLn(Edit1.Text);
IdTCPCclient1.ផ្ដាច់;

លេខកូដនេះមិនចាំបាច់ដាក់ក្នុងព្រឹត្តិការណ៍ OnCreate ទេ។ អ្នកអាចដាក់លេខកូដនេះនៅកន្លែងណាដែលអ្នកចង់បានតាមការសំរេចចិត្តរបស់អ្នក។
នៅក្នុងជួរទីមួយ យើងកំណត់ច្រកមួយ ហើយវាចាំបាច់ក្នុងការបញ្ជាក់ច្រកដូចគ្នាដែលយើងបានបញ្ជាក់នៅក្នុងកម្មវិធីម៉ាស៊ីនមេ បើមិនដូច្នោះទេ ម៉ាស៊ីនភ្ញៀវនឹងមិនស្វែងរកម៉ាស៊ីនមេទេ។ បន្ទាប់មកយើងចង្អុលបង្ហាញអាសយដ្ឋាន IP របស់ម៉ាស៊ីនមេ។ ម៉ាស៊ីនមេខ្លួនឯងអាចមានទីតាំងនៅលើបណ្តាញមូលដ្ឋាន ឬពីចម្ងាយ។ ក្នុងករណីចុងក្រោយការតភ្ជាប់នឹងត្រូវបានធ្វើឡើងតាមរយៈអ៊ីនធឺណិតហើយអ្នកនឹងត្រូវបញ្ជាក់អាសយដ្ឋាន IP នៅលើអ៊ីនធឺណិត។

ខ្ញុំបានបញ្ជាក់អាសយដ្ឋាន “127.0.0.1” ដែលមានន័យថាម៉ាស៊ីនមេគឺជាកុំព្យូទ័រដែលម៉ាស៊ីនភ្ញៀវកំពុងដំណើរការ។ វិធីសាស្រ្តនេះគឺងាយស្រួលណាស់សម្រាប់ការសាកល្បងកម្មវិធីបណ្តាញ។
បន្ទាប់​មក​យើង​ធ្វើ​ការ​តភ្ជាប់ ផ្ញើ​សារ និង​ផ្ដាច់ ដូច​ជា​សារ​ខ្លួន​ឯង អ្នក​ក៏​អាច​យក​អាសយដ្ឋាន IP ពី​ការ​កែសម្រួល ឬ​ពី​អថេរ​ខ្សែ​អក្សរ​ណា​មួយ​ដែរ។

ការងារលើកម្មវិធីអតិថិជនក៏ត្រូវបានបញ្ចប់ផងដែរ។ ដូចដែលអ្នកអាចឃើញ Indy ធ្វើការងារដ៏អស្ចារ្យមួយសម្រាប់ពួកយើង ដែលធ្វើឱ្យវាអាចទៅរួចសម្រាប់សូម្បីតែអ្នកសរសេរកម្មវិធីដែលគ្មានបទពិសោធន៍ដើម្បីបង្កើតកម្មវិធីបណ្តាញផ្ទាល់ខ្លួនរបស់ពួកគេ។