ඩෙල්ෆි හි සොකට් සම්බන්ධතා පරීක්ෂා කිරීම. ඩෙල්ෆි. ඩෙල්ෆි හි ක්‍රමලේඛන සොකට්. සංකීර්ණ දත්ත යැවීම සහ ලබා ගැනීම

සොකට් (සොකට් (ඉංග්රීසි) සිට - සම්බන්ධකය, සොකට්) වේ මෘදුකාංග අතුරුමුහුණත, ක්රියාවලි අතර තොරතුරු හුවමාරුව සැපයීම.

ජාලයේ සොකට් තොරතුරු හුවමාරු කිරීමේ ප්රධාන වාසියක් වන්නේ එහි නම්යශීලීභාවයයි. සොකට් සමඟ වැඩ කිරීමේ ප්රධාන මූලධර්මය වන්නේ වෙනත් පරිගණකයකට බයිට් අනුපිළිවෙලක් යැවීමයි, මෙය සරල කෙටි පණිවුඩයක් හෝ ගොනුවක් විය හැකිය.

සොකට් වර්ග දෙකක් අතර වෙනස හඳුනා ගැනීම වැදගත්ය: සේවාදායක සොකට් , සහ සේවාදායක සොකට් .

ඩෙල්ෆි හි "සේවාදායක" වර්ගයේ සොකට් සමඟ වැඩ කිරීමට, සංරචකයක් ඇත TClientSocket, ඔබට සංරචකය භාවිතයෙන් "සේවාදායක" සොකට් සමඟ වැඩ කළ හැකිය TSserverSocket.

සංරචක ස්ථාපනය කිරීම

බොහෝ විට TServerSocket සහ TClientSocket සංරචක සම්මත Delphi ස්ථාපන පැකේජයට ඇතුළත් කර නැත, නමුත් ඒවා අතිරේකව ස්ථාපනය කළ හැකිය.

"අන්තර්ජාල" සංරචක පටිත්ත වෙත ගොස් TServerSocket සහ TClientSocket සංරචක එහි තිබේදැයි පරීක්ෂා කරන්න; එසේ නොවේ නම්, ඒවා ස්ථාපනය කරන්න. "Component/Install Packages" මෙනුව වෙත ගොස් "Add" බොත්තම ක්ලික් කරන්න. විවෘත වන සංවාද කොටුව තුළ, ඔබ "dclsocketsXX.bpl" ගොනුව සොයා ගත යුතුය (එය Delphi ෆෝල්ඩරයේ පිහිටා ඇති බින් ෆෝල්ඩරයේ පිහිටා ඇත), XX යනු ඔබේ Delphi හි සංඛ්‍යාත්මක අනුවාද අංකයයි. ගොනුව සොයා, විවෘත ක්ලික් කරන්න, ඉන්පසු පැකේජ ස්ථාපනය කිරීමේ කවුළුව තුළ, හරි ක්ලික් කරන්න. දැන්, "අන්තර්ජාල" ටැබය තුළ සංරචක දෙකක් දර්ශනය වී ඇත - TServerSocket සහ TClientSocket.

සේවාදායක සොකට් සමඟ වැඩ කිරීම (tClientSocket)

1) වරාය සහ ධාරක ගුණාංග නිර්වචනය කිරීම.සාර්ථක සම්බන්ධතා ගුණාංග සඳහා වරායසහ සත්කාරක TClientSocket සංරචකයට සමහර අගයන් පැවරිය යුතුය. වරාය දේපල තුළ, ඔබට සම්බන්ධතාවය සඳහා වරාය අංකය සඳහන් කළ යුතුය (1 - 65535, නමුත් එය 1001 - 65535 පරාසයෙන් ගැනීම වඩා හොඳය, මන්ද 1000 දක්වා සංඛ්‍යා පද්ධති සේවා විසින් අල්ලා ගත හැකිය).

සත්කාරක- ඔබට සම්බන්ධ වීමට අවශ්‍ය පරිගණකයේ සත්කාරක නාමය හෝ IP ලිපිනය. උදාහරණයක් ලෙස, rus.delphi.com හෝ 192.128.0.0.

2) සොකට් එකක් විවෘත කිරීම.එක් පරිගණකයකින් තවත් පරිගණකයකට සම්ප්රේෂණය වන අක්ෂර පෝලිමක් ලෙස අපි සොකට් එකක් සලකමු. ක්රමය ඇමතීමෙන් ඔබට සොකට් එකක් විවෘත කළ හැකිය විවෘත(TClientSocket සංරචකය) හෝ අගයක් පැවරීමෙන් සැබෑදේපල ක්රියාකාරී. අසාර්ථක සම්බන්ධතාවයකදී ව්‍යතිරේක හසුරුවන්නක් එක් කිරීම මෙහිදී ප්‍රයෝජනවත් වනු ඇත.

3) දත්ත යැවීම / ලැබීම.

4) සොකට් වසා දැමීම.දත්ත හුවමාරුව අවසන් වූ පසු, ඔබට ක්‍රමය ඇමතීමෙන් සොකට් එක වසා දැමිය යුතුය වසන්නසංරචකය TClientSocketනැතහොත් අගයක් පැවරීමෙනි බොරුදේපල ක්රියාකාරී.

මෙම ලිපිය මූලික ගුණාංග සහ කාර්යයන් සාකච්ඡා කරනු ඇත ඩෙල්ෆි සංරචක: TClientSocket සහ TServerSocket - TCP\IP ප්‍රොටෝකෝලය භාවිතයෙන් ජාලය සමඟ වැඩ කිරීමට භාවිතා කරයි.

අවධානය!ඔබ 6.0 ට වඩා වැඩි Delphi අනුවාදයක් භාවිතා කරන්නේ නම්, ඔබ මුලින්ම Sockets Components ස්ථාපනය කළ යුතුය; Delphi හි සියලුම අනුවාද වල මෙය පහත පරිදි සිදු කෙරේ:

• ස්ථාපන පැකේජ වෙත යන්න... සංවාදය: (ප්‍රධාන මෙනුව) සංරචකය -> පැකේජ ස්ථාපනය කරන්න;
• Add... බොත්තම මත ක්ලික් කරන්න, ඉන්පසු අපි ඔබේ Delphi හි Bin ෆෝල්ඩරය සොයා ගනිමු (උදාහරණයක් ලෙස: C:\Program Files\Borland\Delphi 7\bin, හෝ C:\Program Files\Embarcadero\RAD Studio\7.0\Bin) ;
• සොයාගත් බින් ෆෝල්ඩරයේ අපි දැනටමත් ගොනුව සොයමින් සිටිමු dclsockets [මෙන්න ඉලක්කම්].bpl, හරි ක්ලික් කරන්න;
• සංරචක පැනලයේ අන්තර්ජාල පටිත්තෙහි දැන් අපට TServerSocket සහ TClientSocket යන අපූරු සංරචක දෙකක් ඇති බැවින් අපි සතුටු වෙමු.

ඕනෑම ජාල යෙදුම් සංවර්ධනය කිරීමේදී, සාමාන්‍යයෙන් සංවර්ධනය සෑම විටම සේවාදායකයෙන් ආරම්භ වේ (ඇත්ත වශයෙන්ම, ඔබට කණ්ඩායමක් සිටී නම්, අතුරුමුහුණත් නිර්මාණකරුවන්ට සේවාදායකයා මත වැඩ කිරීමට පටන් ගත හැකිය). සේවාදායකයක් ක්රියාත්මක කිරීම සඳහා, පුදුම සහගත ලෙස, ඔබ TServerSocket භාවිතා කළ යුතුය.

මූලික ගුණාංග:

• ක්රියාකාරී- boolean ක්ෂේත්‍රයක්, සත්‍ය ලෙස සකසා ඇති විට - සේවාදායකය ආරම්භ වේ, ඔබට නිශ්චිත අගයන් පැවරීමෙන් හෝ ServerSocket1.Open (... Active:=true;) හෝ ServerSocket1.Close (.. සක්රීය:=අසත්ය).
• වරාය- සේවාදායකය සවන් දෙන වරාය (සේවාදායකයින් ලබා ගනී), පද්ධතියේ අනෙකුත් සේවාදායකයන් විසින් අත්පත් කර නොගත් පරාසය තුළ ඇති ඕනෑම අගයක් පූර්ණ සංඛ්යාව.

ප්රධාන සිදුවීම්:

• සවන් දෙන්න- සේවාදායකය ශ්‍රවණ ප්‍රකාරයට සකසා ඇති විට හඳුන්වනු ලැබේ, අපට සේවාදායකයේ සැබෑ ආරම්භයේ වේලාව තීරණය කිරීමට අවශ්‍ය වූ විට භාවිතා කළ හැක.
• OnClientRead- සේවාදායකයාගෙන් දත්ත ලැබුණු විට කැඳවනු ලැබේ.
• OnClientError
• OnClientConnect- නව සේවාදායකයකු සේවාදායකයට සම්බන්ධ වූ විට කැඳවනු ලැබේ.
• OnClientDisconnect- සිදුවීමෙන් සිදුවීමට ප්‍රතිලෝම, OnClientConnect

සෑම සිද්ධි කාර්යයකටම ගුණාංගයක් ඇත සොකට්: TCustomWinSocket, අප සිටින සොකට් වස්තුව වෙත දර්ශකයක් මේ මොහොතේඅපි වැඩ කරන්නෙමු, අපට ප්‍රතිචාර දැක්වීමට හෝ සිදුවීමට හේතු වූ සේවාදායකයා සමඟ යමක් කිරීමට අවශ්‍ය නම්, අපි මෙම විශේෂිත වස්තුව භාවිතා කළ යුතුය, අපි භාවිතා කරන අනෙකුත් සියලුම අවස්ථා වලදී ServerSocket1.Socket, සේවාදායක සංරචකය සමඟ තත්වය සමාන වේ.

කියවීමට පමණක් ගුණාංග සහ කාර්යයන්:

• - ක්රියාකාරී සම්බන්ධතා සංඛ්යාව ආපසු ලබා දෙයි.
• ServerSocket1.Socket.සම්බන්ධතා- TCustomWinSocket වර්ගයේ වස්තු සමූහයක්, සේවාලාභීන් හා සම්බන්ධ සියලුම වස්තූන්ගේ අරාවක්, දර්ශක ගණන් කිරීම 0 සිට ආරම්භ වේ, අරාවේ දිග වේ ServerSocket1.Socket.ActiveConnections.
• ServerSocket1.Socket.Connections අරාවේ මූලද්‍රව්‍යවලට අදාළ වන කාර්යයන් සහ ගුණාංග සහ සේවාදායක සිදුවීම් ශ්‍රිතයට ලබා දුන් Socket උපලක්ෂණ:
• Socket.LocalHost
• Socket.දේශීය ලිපිනය- සේවාදායකයේ IP නැවත ලබා දෙයි.
• Socket.RemoteHost
• Socket.Remote Address- සේවාදායක IP ආපසු ලබා දෙයි.
• Socket.ReceiveText- සේවාලාභියාගෙන් ලැබුණු කෙටි පණිවිඩයක් ආපසු ලබා දෙයි, එය බෆරය ඉවත් කිරීමෙන් පසුව, පිළිගැනීම් 1 කට 1 වතාවක් පමණක් භාවිතා කළ හැකිය.
• Socket.SendText(පෙළ)- සේවාදායකයාට පෙළ වර්ගයේ කෙටි පණිවිඩයක් යවයි නූල්.

TClientSocket සංරචකය සඳහා, සෑම දෙයක්ම ප්‍රායෝගිකව සමාන වේ, ප්‍රතිලෝමව පමණි + සේවාදායකය සහ සේවාදායකයා අතර ඇති ප්‍රධාන දෘශ්‍ය වෙනස නම් පද්ධතියේ සේවාදායකය 1 න් 1 port අගයක් දියත් කළ හැකි වීමයි, සේවාලාභීන් සංඛ්‍යාව සීමා වන්නේ RAM වලින් පමණි. .

මූලික ගුණාංග:

• ක්රියාකාරී- boolean ක්ෂේත්‍රයක්, සත්‍ය ලෙස සකසා ඇති විට - සේවාදායකයා සේවාදායකයට සම්බන්ධ වීමට උත්සාහ කරයි, නිශ්චිත අගයන් පැවරීමෙන් හෝ ClientSocket1.Open (... Active:=true;) හෝ ClientSocket1 යන කාර්යයන් ඇමතීමෙන් භාවිතා කළ හැක. .Close (... Active:=false) .
• වරාය- සේවාදායකයාට සේවාදායකයට සම්බන්ධ විය හැකි වරාය, පරාසය තුළ ඇති ඕනෑම අගයක් පූර්ණ සංඛ්යාව.
• ලිපිනය- සේවාදායක වර්ගයේ IPv4 ලිපිනය නූල් 255.255.255.255 රටාව අනුව, සේවාදායකයා සම්බන්ධ වනු ඇත.

ප්රධාන සිදුවීම්:

• කියවන්න- උතුරෙන් දත්ත ලැබුණු විට හැඳින්වේ.
• OnError- දත්ත සම්ප්රේෂණයේදී දෝෂයක් ඇති වූ විට හැඳින්වේ.
• සම්බන්ධ වෙමින්- සේවාදායකයෙකු සේවාදායකයට සම්බන්ධ වූ විට කැඳවනු ලැබේ.
• OnDisconnect- සිදුවීමෙන් සිදුවීමට ප්‍රතිලෝම, සම්බන්ධ වෙමින්, සේවාදායකයෙකු සේවාදායකයෙන් විසන්ධි වූ විට ඇමතීම.

කියවීමට පමණක් ගුණාංග සහ කාර්යයන්:

• ClientSocket1.Socket.SendText() නූල්
• Socket.LocalHost- සේවාදායකයාගේ සබැඳි නම ආපසු ලබා දෙයි.
• Socket.දේශීය ලිපිනය- සේවාදායක IP ආපසු ලබා දෙයි.
• Socket.RemoteHost- ජාලයේ සේවාදායකයේ නම ආපසු ලබා දෙයි.
• Socket.Remote Address- සේවාදායකයේ IP නැවත ලබා දෙයි.
• Socket.ReceiveText- සේවාදායකයෙන් ලැබුණු කෙටි පණිවිඩයක් ආපසු ලබා දෙයි, පසුව එය බෆරය ඉවත් කරයි, වරකට 1 වතාවක් පමණක් භාවිතා කළ හැකිය.
• Socket.SendText(පෙළ)- පෙළ වර්ගයේ කෙටි පණිවිඩයක් සේවාදායකයට යවයි නූල්.

සපයා ඇති තොරතුරු තෘප්තිමත් වන කුඩා සේවාදායක කතාබස් ක්‍රියාත්මක කිරීමට ප්‍රමාණවත් වේ තාක්ෂණික පිරිවිතර: internet_sockets.doc (Word Doc 97-2003, 26.5 Kb).

මෙම ලිපිය 2010 ඔක්තෝබර් 10 ඉරිදා පෙ.ව 1:24 ට ලියා ඇත. ලිපියට අදහස් දැක්වීම් පිළිබඳ යාවත්කාලීන කිරීම් සඳහා ඔබට දායක විය හැකිය -. ඔයාට පුළුවන්

හැදින්වීම

මෙම ලිපිය සොකට් ("සොකට්" - Borland Delphi හි සේවාදායක/සේවාදායක ගෘහ නිර්මාණ යෙදුම් නිර්මාණය කිරීම සඳහා කැප කර ඇත. කූඩු) සොකට් මාතෘකාව පිළිබඳ පෙර ලිපිය මෙන් නොව, මෙහිදී අපි සේවාදායක යෙදුම් නිර්මාණය කිරීම දෙස බලමු.

වෙනම සේවාදායක සහ සේවාදායක යෙදුම්වල සහජීවනය සඳහා පරිගණක කිහිපයක් තිබීම අවශ්‍ය නොවන බව වහාම සටහන් කළ යුතුය. ඔබට සේවාදායකය සහ සේවාදායකයා යන දෙකම එකවර ක්‍රියාත්මක කළ හැකි එකක් පමණක් තිබීම ප්‍රමාණවත් වේ. මෙම අවස්ථාවේදී, ඔබට සම්බන්ධ වීමට අවශ්‍ය පරිගණකයේ නම ලෙස සත්කාරක නාමය භාවිතා කළ යුතුය දේශීය සත්කාරකහෝ IP ලිපිනය - 127.0.0.1 .

ඉතින්, අපි න්යාය සමඟ ආරම්භ කරමු. ඔබ ඒත්තු ගැන්වූ වෘත්තිකයෙක් නම් (සහ ඔබේ ඇස්වලින් කිසිදු ඇල්ගොරිතමයක් දැකිය නොහැක), එවිට ඔබ මෙම කොටස මඟ හැරිය යුතුය.

Socket server මෙහෙයුම් ඇල්ගොරිතම

සොකට් සේවාදායකයක් ඔබට කිරීමට ඉඩ දෙන්නේ කුමක්ද?.. එය ක්‍රියා කරන්නේ කුමන මූලධර්මය මතද?.. සොකට් ප්‍රොටෝකෝලය මත පදනම් වූ සේවාදායකයක් ඔබට බොහෝ සේවාදායකයින්ට එකවර සේවය කිරීමට ඉඩ සලසයි. එපමණක් නොව, ඔබට ඔවුන්ගේ අංකයේ සීමාව ඔබ විසින්ම නියම කළ හැකිය (නැතහොත් පෙරනිමියෙන් සිදු කරන පරිදි මෙම සීමාව සම්පූර්ණයෙන්ම ඉවත් කරන්න). සම්බන්ධිත එක් එක් සේවාදායකයා සඳහා, සේවාදායකයා ඔබට සේවාදායකයා සමඟ දත්ත හුවමාරු කර ගත හැකි වෙනම සොකට් එකක් විවෘත කරයි. තවත් විශිෂ්ට විසඳුමක් වන්නේ එක් එක් සම්බන්ධතාවය සඳහා වෙනම ක්රියාවලියක් (නූල්) නිර්මාණය කිරීමයි.

Delphi යෙදුම්වල සොකට් සේවාදායකයක් ක්‍රියා කරන ආකාරය පිළිබඳ උදාහරණ රූප සටහනක් පහත දැක්වේ:

රූප සටහන වඩාත් විස්තරාත්මකව බලමු:

• Port සහ ServerType ගුණාංගවල අර්ථ දැක්වීම - සේවාදායකයින්ට සාමාන්‍යයෙන් සේවාදායකයට සම්බන්ධ වීමට හැකි වීම සඳහා, සේවාදායකය විසින් භාවිතා කරන වරාය සේවාදායකයා භාවිතා කරන වරායට හරියටම ගැලපීම අවශ්‍ය වේ (සහ අනෙක් අතට). ServerType ගුණාංගය සම්බන්ධතා වර්ගය තීරණය කරයි (වැඩි විස්තර සඳහා පහත බලන්න);
• සොකට් එකක් විවෘත කිරීම - සොකට් සහ නිශ්චිත වරාය විවෘත කිරීම. ගනුදෙනුකරුවන් සම්බන්ධ වන තෙක් අපි ස්වයංක්‍රීයව බලා සිටීම ආරම්භ කරන්නේ මෙහිදීය ( සවන් දෙන්න);
• සේවාලාභියෙකු සම්බන්ධ කිරීම සහ එය සමඟ දත්ත හුවමාරු කිරීම - මෙහිදී සේවාදායකයා එය සමඟ දත්ත සම්බන්ධ කර හුවමාරු කරයි. මෙම ලිපියෙන් සහ සොකට් (සේවාදායක කොටස) පිළිබඳ ලිපියෙන් ඔබට මෙම අදියර ගැන වැඩි විස්තර දැනගත හැකිය;
• සේවාලාභියෙකු අක්රිය කිරීම - මෙහිදී සේවාදායකයා විසන්ධි වන අතර සේවාදායකය සමඟ එහි සොකට් සම්බන්ධතාවය වසා ඇත;
• සේවාදායකය සහ සොකට් වසා දැමීම - පරිපාලකගේ විධානය අනුව, සේවාදායකය වසා දමයි, සියලු විවෘත සොකට් නාලිකා වසා දමා සේවාදායක සම්බන්ධතා සඳහා රැඳී සිටීම නතර කරයි.

ලකුණු 3-4 බොහෝ වාරයක් පුනරාවර්තනය වන බව සැලකිල්ලට ගත යුතුය, i.e. මෙම පියවර සෑම නව සේවාදායක සම්බන්ධතාවයක් සඳහාම සිදු කෙරේ.

සටහන : මේ වන විට ඩෙල්ෆි හි සොකට් පිළිබඳ ලියකියවිලි ඉතා අල්පය, එබැවින් ඔබට මෙම මාතෘකාව හැකිතාක් ගැඹුරින් අධ්‍යයනය කිරීමට අවශ්‍ය නම්, යුනික්ස්/ලිනක්ස් පද්ධති පිළිබඳ සාහිත්‍යය සහ විද්‍යුත් ලේඛන දෙස බලන ලෙස මම ඔබට උපදෙස් දෙමි. ඉතාමසොකට් සමඟ වැඩ කිරීමේ න්යාය හොඳින් විස්තර කර ඇත. මීට අමතරව, මෙම OS සඳහා සොකට් යෙදුම් සඳහා බොහෝ උදාහරණ ඇත (බොහෝ විට C/C++ සහ Perl හි වුවද).

TServerSocket සංරචකයේ කෙටි විස්තරය

මෙන්න අපි දැන හඳුනා ගන්නෙමු ප්රධානසංරචකයක ගුණාංග, ක්‍රම සහ සිදුවීම් TSserverSocket.

TServerSocket.Socket(TSServerWinSocket)

ඉතින් සේවාදායකයා සේවාදායකයාට දත්ත යැවිය හැක්කේ කෙසේද? දත්ත ලැබීම ගැන කුමක් කිව හැකිද? ප්රධාන වශයෙන්ම ඔබ සිදුවීම් හරහා වැඩ කරන්නේ නම් OnClientReadසහ OnClientWrite, එවිට ඔබට ClientSocket පරාමිතිය (TCustomWinSocket) හරහා සේවාදායකයා සමඟ සන්නිවේදනය කළ හැකිය. සේවාදායක සොකට් පිළිබඳ ලිපියේ මෙම පන්තිය සමඟ වැඩ කිරීම ගැන ඔබට කියවිය හැකිය, මන්ද මෙම පන්තිය හරහා දත්ත යැවීම/ යැවීම සමාන වේ - ක්‍රම (යවන්න/ලැබීම)(පෙළ, බෆරය, ප්‍රවාහය). TServerSocket.Socket සමඟ වැඩ කරන විටද එය අදාළ වේ. කෙසේ වෙතත්, නිසා මෙන්න අපි සේවාදායකයක් සලකා බලමු, අපි ප්රයෝජනවත් ගුණාංග සහ ක්රම කිහිපයක් ඉස්මතු කළ යුතුය:

• ක්රියාකාරී සම්බන්ධතා (පූර්ණ සංඛ්යාව) - සම්බන්ධිත සේවාදායකයින් සංඛ්යාව;
• ක්රියාකාරී නූල් (පූර්ණ සංඛ්යාව) - ධාවන ක්රියාවලි සංඛ්යාව;
• සම්බන්ධතා (අරාව) - සම්බන්ධිත එක් එක් සේවාදායකයා සඳහා වෙන වෙනම TClientWinSocket පන්ති වලින් සමන්විත අරාවකි. උදාහරණයක් ලෙස, මෙම විධානය:
  ServerSocket1.Socket.Connections.SendText("Hello!");
  පළමු සම්බන්ධිත සේවාදායකයාට "Hello!" පණිවිඩයක් යවයි. මෙම අරාවේ මූලද්‍රව්‍ය සමඟ වැඩ කිරීම සඳහා වන විධාන - ද (යවන්න/ලැබීම)(පෙළ, බෆරය, ප්‍රවාහය);
• IdleThreads (පූර්ණ සංඛ්යාව) - නිදහස් ක්රියාවලි සංඛ්යාව. එවැනි ක්‍රියාවලි සේවාදායකය විසින් හැඹිලිගත කර ඇත (බලන්න ThreadCacheSize);
• දේශීය ලිපිනය, LocalHost, LocalPort- පිළිවෙලින් - දේශීය IP ලිපිනය, සත්කාරක නාමය, වරාය;
• දුරස්ථ ලිපිනය, RemoteHost, දුරස්ථ වරාය- පිළිවෙලින් - දුරස්ථ IP ලිපිනය, සත්කාරක නාමය, වරාය;
• ක්රම අගුළු දමන්නසහ අගුළු හරින්න- පිළිවෙලින්, සොකට් අවහිර කිරීම සහ අවහිර කිරීම.

පුහුණුවීම් සහ උදාහරණ

දැන් අපි ඉහතින් බලමු නිශ්චිත උදාහරණයක්. ක්ලික් කිරීමෙන් ඔබට සූදානම් කළ මූලාශ්‍ර බාගත කළ හැකිය.

එබැවින්, TServerSocket සමඟ වැඩ කිරීමේ ඉතා හොඳ උදාහරණයක් දෙස බලමු (මෙම උදාහරණය මෙම සංරචකය අධ්යයනය කිරීම සඳහා වඩාත්ම දෘශ්ය ආධාරය වේ). පහත මූලාශ්‍ර මගින් සියලුම වැදගත් සේවාදායක සිදුවීම් ලොග් වීම සහ ලැබීමේ සහ යැවීමේ හැකියාව පෙන්නුම් කරයි කෙටි පණිවුඩ:

TServerSocket සමඟ වැඩ කිරීමේ තාක්ෂණය (සහ සරලව සොකට් සමඟ)

එක් එක් සේවාදායකයා සඳහා අද්විතීය දත්ත ගබඩා කිරීම.

නිසැකවම, ඔබේ සේවාදායකය බොහෝ සේවාදායකයින්ට සේවය කරන්නේ නම්, ඔබට එක් එක් සේවාදායකයා (නම, ආදිය) සඳහා යම් තොරතුරු ගබඩා කිරීමට අවශ්‍ය වනු ඇත, සහ මෙම තොරතුරු මෙම සේවාදායකයාගේ සොකට් එකට බැඳ තබන්න. සමහර අවස්ථාවලදී, මේ සියල්ල අතින් සිදු කිරීම (සොකට් හසුරුවකට බැඳීම, සේවාදායක අරා, ආදිය) ඉතා පහසු නොවේ. එබැවින්, එක් එක් සොකට් සඳහා විශේෂ දේපලක් ඇත - දත්ත. ඇත්ත වශයෙන්ම, දත්ත යනු දර්ශකයක් පමණි. එබැවින්, මෙම දේපල වෙත සේවාදායක දත්ත ලිවීමේදී, ප්රවේශම් වන්න සහ පොයින්ටර් සමඟ වැඩ කිරීමේ නීති අනුගමනය කරන්න (මතක වෙන් කිරීම, වර්ග නිර්වචනය, ආදිය)!

සොකට් හරහා ගොනු යැවීම.

මෙහිදී අපි සොකට් එකක් හරහා ලිපිගොනු යැවීම දෙස බලමු (JINX හි ඉල්ලීම පරිදි) :-). ඉතින් කොහොමද ඔබ සොකට් එකකට ගොනුවක් යවන්නේ? හරිම සරලයි! ඔබ කළ යුත්තේ මෙම ගොනුව ගොනු ප්‍රවාහයක් (TFileStream) ලෙස විවෘත කර සොකට් (SendStream) හරහා යැවීමයි! අපි මෙය උදාහරණයකින් බලමු:

ක්රමවේදය බව සඳහන් කළ යුතුය SendStreamසේවාදායකය විසින් පමණක් නොව, සේවාලාභියා විසින්ද භාවිතා කරනු ලැබේ ( ClientSocket1.Socket.SendStream(srcfile))

සම්ප්‍රේෂණයේදී බ්ලොක් කිහිපයක් එකකට ඒකාබද්ධ කළ හැක්කේ ඇයි?

මෙයද JINX ගේ ඉල්ලීම මත ය :-). මේ සඳහා ඔහුට බොහෝ ස්තූතියි! එබැවින්, පළමුව, සොකට් හරහා යවන ලද දත්ත එක් කොටසකට ඒකාබද්ධ කිරීම පමණක් නොව, බ්ලොක් කිහිපයක් හරහා වෙන් කළ හැකි බව සැලකිල්ලට ගත යුතුය. කාරණය නම් සොකට් යනු සාමාන්‍ය ප්‍රවාහයක් වන නමුත්, ගොනු ප්‍රවාහයක් (TFileStream) මෙන් නොව, එය දත්ත වඩාත් සෙමින් මාරු කරයි (ඔබට තේරෙනවා - ජාලය, සීමිත ගමනාගමනය, ආදිය). ඒ නිසා විධාන දෙකක්:
ServerSocket1.Socket.Connections.SendText("Hello,");
ServerSocket1.Socket.Connections.SendText("ලොව!");
එක් විධානයකට සම්පූර්ණයෙන්ම සමාන වේ:
ServerSocket1.Socket.Connections.SendText("Hello, world!");

ඔබ සොකට් එකක් හරහා 100 KB ගොනුවක් යවන්නේ නම්, ඔබ මෙම කොටස එවූ පුද්ගලයාට රථවාහන සහ මාර්ග තදබදය මත රඳා පවතින ප්‍රමාණයේ කුට්ටි කිහිපයක් ලැබෙනු ඇත්තේ එබැවිනි. එපමණක්ද නොව, ප්රමාණ අනිවාර්යයෙන්ම සමාන නොවේ. ගොනුවක් හෝ වෙනත් දත්තයක් පිළිගැනීම සඳහා එය අනුගමනය කරයි විශාල ප්රමාණයඔබ දත්ත කොටස් පිළිගත යුතු අතර පසුව ඒවා එකකට ඒකාබද්ධ කළ යුතුය (උදාහරණයක් ලෙස එය ගොනුවකට සුරකින්න). මෙම ගැටලුවට විශිෂ්ට විසඳුමක් වන්නේ එකම ගොනු ධාරාවයි - TFileStream (හෝ මතකයේ ඇති ධාරාවක් - TMemoryStream). විශ්වීය ක්‍රමය භාවිතයෙන් ඔබට OnRead (OnClientRead) සිදුවීම හරහා සොකට් එකකින් දත්ත කොටස් ලබා ගත හැක. ReceiveBuf. ක්‍රමය භාවිතයෙන් ඔබට ලැබෙන බ්ලොක් ප්‍රමාණය තීරණය කළ හැකිය ලැබෙන දිග. ඔබට සොකට් ප්‍රවාහයක් ද භාවිතා කළ හැකිය (TClientSocket පිළිබඳ ලිපිය බලන්න). මෙන්න කුඩා උදාහරණයක් (ආසන්න):

සොකට් එකක් නිරීක්ෂණය කරන්නේ කෙසේද

මෙම ගැටළුව සංකීර්ණ වන අතර දිගු සලකා බැලීම අවශ්ය වේ. දැනට, ඔබගේ වැඩසටහන මඟින් නිර්මාණය කරන ලද සොකට් එක ඔබට සැමවිටම නිරීක්ෂණය කළ හැකි බව මම සටහන් කරමි :-). Sockets (Windows හි බොහෝ වස්තු වැනි) හැන්ඩ්ල් දේපලෙහි ලියා ඇති තමන්ගේම හසුරුව ඇත. එබැවින්, ඔබ මෙම විස්තරය හඳුනා ගත් පසු, ඔබට ඕනෑම සොකට් එකක් නිදහසේ කළමනාකරණය කිරීමට හැකි වනු ඇත (වෙනත් කෙනෙකුගේ වැඩසටහනක් විසින් නිර්මාණය කරන ලද එකක් පවා)! කෙසේ වෙතත්, බොහෝ දුරට, වෙනත් කෙනෙකුගේ සොකට් නිරීක්ෂණය කිරීම සඳහා, ඔබට WinAPI Sockets කාර්යයන් පමණක් භාවිතා කිරීමට සිදුවනු ඇත.

මෙම ලිපිය Delphi හි TServerSocket සංරචකය සමඟ වැඩ කිරීමේ මූලික ශිල්පීය ක්‍රම සහ සොකට් හරහා දත්ත හුවමාරු කිරීමේ සාමාන්‍ය ශිල්පීය ක්‍රම කිහිපයක් පෙන්වයි. ඔබට ප්‍රශ්න ඇත්නම්, ඒවා මට විද්‍යුත් තැපෑලෙන් එවන්න: [ඊමේල් ආරක්ෂිත], සහ ඊටත් වඩා හොඳයි - මෙම වෙබ් අඩවියේ සම්මන්ත්‍රණයේ ලියන්න (ඩෙල්පි. සාමාන්‍ය ප්‍රශ්න) එවිට අනෙක් පරිශීලකයින්ට ඔබේ ප්‍රශ්නය දැක බලා එයට පිළිතුරු දීමට උත්සාහ කරන්න!

Karik Nikolay ( නයිට්රෝ) මොස්කව් කලාපය, Zhukovsky

මෙම ලිපිය සොකට් ("සොකට්") මත පදනම්ව Borland Delphi හි සේවාදායක/සේවාදායක ගෘහ නිර්මාණ යෙදුම් නිර්මාණය කිරීමට කැප කර ඇත. සොකට් මාතෘකාව පිළිබඳ පෙර ලිපිය මෙන් නොව, මෙහිදී අපි සේවාදායක යෙදුම් නිර්මාණය කිරීම දෙස බලමු.
වෙනම සේවාදායක සහ සේවාදායක යෙදුම්වල සහජීවනය සඳහා පරිගණක කිහිපයක් තිබීම අවශ්‍ය නොවන බව වහාම සටහන් කළ යුතුය. ඔබට සේවාදායකය සහ සේවාදායකයා යන දෙකම එකවර ක්‍රියාත්මක කළ හැකි එකක් පමණක් තිබීම ප්‍රමාණවත් වේ. මෙම අවස්ථාවේදී, ඔබට සම්බන්ධ වීමට අවශ්‍ය පරිගණකයේ නම ලෙස ධාරක නාමය localhost හෝ IP ලිපිනය - 127.0.0.1 භාවිතා කළ යුතුය.
ඉතින්, අපි න්යාය සමඟ ආරම්භ කරමු. ඔබ ඒත්තු ගැන්වූ වෘත්තිකයෙක් නම් (සහ ඔබේ ඇස්වලින් කිසිදු ඇල්ගොරිතමයක් දැකිය නොහැක), එවිට ඔබ මෙම කොටස මඟ හැරිය යුතුය.
සොකට් සර්වර් මෙහෙයුම් ඇල්ගොරිතම
සොකට් සේවාදායකයක් ඔබට කිරීමට ඉඩ දෙන්නේ කුමක්ද?.. එය ක්‍රියා කරන්නේ කුමන මූලධර්මය මතද?.. සොකට් ප්‍රොටෝකෝලය මත පදනම් වූ සේවාදායකයක් ඔබට බොහෝ සේවාදායකයින්ට එකවර සේවය කිරීමට ඉඩ සලසයි. එපමණක් නොව, ඔබට ඔවුන්ගේ අංකයේ සීමාව ඔබ විසින්ම නියම කළ හැකිය (නැතහොත් පෙරනිමියෙන් සිදු කරන පරිදි මෙම සීමාව සම්පූර්ණයෙන්ම ඉවත් කරන්න). සම්බන්ධිත එක් එක් සේවාදායකයා සඳහා, සේවාදායකයා ඔබට සේවාදායකයා සමඟ දත්ත හුවමාරු කර ගත හැකි වෙනම සොකට් එකක් විවෘත කරයි. තවත් විශිෂ්ට විසඳුමක් වන්නේ එක් එක් සම්බන්ධතාවය සඳහා වෙනම ක්රියාවලියක් (නූල්) නිර්මාණය කිරීමයි.
Delphi යෙදුම්වල සොකට් සේවාදායකයක් ක්‍රියා කරන ආකාරය පිළිබඳ උදාහරණ රූප සටහනක් පහත දැක්වේ:

අපි යෝජනා ක්‍රමය වඩාත් විස්තරාත්මකව බලමු: · port සහ ServerType නිර්වචනය - සේවාදායකයන්ට සාමාන්‍යයෙන් සේවාදායකයට සම්බන්ධ වීමට හැකි වීම සඳහා, සේවාදායකය විසින් භාවිතා කරන වරාය සේවාදායකයා භාවිතා කරන වරායට හරියටම ගැලපීම අවශ්‍ය වේ (සහ ප්රතිලෝම වශයෙන්). ServerType ගුණාංගය සම්බන්ධතා වර්ගය තීරණය කරයි (වැඩි විස්තර සඳහා පහත බලන්න); · සොකට් එකක් විවෘත කිරීම - සොකට් එකක් සහ නිශ්චිත වරාය විවෘත කිරීම. මෙහිදී සේවාදායකයින් සම්බන්ධ වීමට බලා සිටීමේ ස්වයංක්‍රීය ආරම්භය (සවන් දෙන්න); · සේවාලාභියෙකු සම්බන්ධ කිරීම සහ එය සමඟ දත්ත හුවමාරු කිරීම - මෙහිදී සේවාදායකයා එය සමඟ සම්බන්ධ වී දත්ත හුවමාරු කර ගනී. මෙම ලිපියෙන් සහ සොකට් (සේවාදායක කොටස) පිළිබඳ ලිපියෙන් ඔබට මෙම අදියර ගැන වැඩි විස්තර දැනගත හැකිය; · සේවාලාභියා විසන්ධි කිරීම - මෙහිදී සේවාදායකයා විසන්ධි වී ඇති අතර සේවාදායකය සමඟ එහි සොකට් සම්බන්ධතාවය වසා ඇත; · සේවාදායකය සහ සොකට් වසා දැමීම - පරිපාලකගේ විධානය මත, සේවාදායකය වසා දමයි, සියලු විවෘත සොකට් නාලිකා වසා දමයි සහ සේවාදායක සම්බන්ධතා සඳහා රැඳී සිටීම නතර කරයි.
ලකුණු 3-4 බොහෝ වාරයක් පුනරාවර්තනය වන බව සැලකිල්ලට ගත යුතුය, i.e. මෙම පියවර සෑම නව සේවාදායක සම්බන්ධතාවයක් සඳහාම සිදු කෙරේ.
සටහන: මේ වන විට ඩෙල්ෆි හි සොකට් පිළිබඳ ලියකියවිලි ඉතා අල්පය, එබැවින් ඔබට මෙම මාතෘකාව හැකි තරම් ගැඹුරින් අධ්‍යයනය කිරීමට අවශ්‍ය නම්, යුනික්ස්/ලිනක්ස් පද්ධති පිළිබඳ සාහිත්‍යය සහ විද්‍යුත් ලියකියවිලි - සමඟ වැඩ කිරීමේ න්‍යාය දෙස බලන ලෙස මම ඔබට උපදෙස් දෙමි. එහි සොකට් ඉතා හොඳින් විස්තර කර ඇත. මීට අමතරව, මෙම OS සඳහා සොකට් යෙදුම් සඳහා බොහෝ උදාහරණ ඇත (බොහෝ විට C/C++ සහ Perl හි වුවද).
TServerSocket සංරචකයේ කෙටි විස්තරය
මෙහිදී අපි සංරචකයේ ප්‍රධාන ගුණාංග, ක්‍රම සහ සිදුවීම් පිළිබඳව දැන හඳුනා ගනිමු
දේපළ
Socket යනු ඔබට විවෘත සොකට් නාලිකා සඳහා ප්‍රවේශය ඇති TServerWinSocket පන්තියයි. ඊළඟට අපි මෙම දේපල වඩාත් විස්තරාත්මකව සලකා බලමු, මන්ද එය ඇත්ත වශයෙන්ම ප්‍රධාන එකකි. වර්ගය: TServerWinSocket;
ServerType - සේවාදායක වර්ගය. අගයන් දෙකෙන් එකක් ගත හැක: stNonBlocking - සේවාදායක සොකට් සමඟ සමමුහුර්ත වැඩ. මෙම වර්ගයේ සේවාදායකයක් සමඟ, ඔබට OnClientRead සහ OnClientWrite සිදුවීම් හරහා සේවාදායකයින් සමඟ වැඩ කළ හැකිය. stThreadBlocking යනු අසමමුහුර්ත වර්ගයකි. එක් එක් සේවාදායක සොකට් නාලිකාව සඳහා වෙනම ක්‍රියාවලියක් (නූල්) සාදනු ලැබේ. වර්ගය: TServerType;
ThreadCacheSize - සේවාදායකය විසින් හැඹිලිගත කරන සේවාදායක ක්‍රියාවලි ගණන (නූල්). මෙහිදී ඔබ ඔබේ සේවාදායකයේ බර අනුව සාමාන්ය අගය තෝරාගත යුතුය. හැඹිලි කිරීම සිදු වන්නේ සෑම අවස්ථාවකදීම වෙනම ක්‍රියාවලියක් නිර්මාණය නොකිරීමට සහ සංවෘත සොකට් එකක් මරා දැමීමට නොව, පසුව භාවිතය සඳහා ඒවා අත්හැරීමට ය. වර්ගය: පූර්ණ සංඛ්යාව;
සක්‍රිය - සේවාදායකය දැනට ක්‍රියාත්මකද නැද්ද යන්න පිළිබඳ දර්ශකයකි. එනම්, ඇත්ත වශයෙන්ම, සත්‍ය අගය මඟින් සේවාදායකය ක්‍රියාත්මක වන අතර සේවාලාභීන් ලබා ගැනීමට සූදානම් බව පෙන්නුම් කරයි, සහ False මඟින් සේවාදායකය ක්‍රියා විරහිත කර ඇති බව පෙන්නුම් කරයි. සේවාදායකය ආරම්භ කිරීමට, ඔබට මෙම දේපල සත්‍ය ලෙස සැකසීමට අවශ්‍ය වේ. වර්ගය: බූලියන්;
වරාය - ගනුදෙනුකරුවන් සමඟ සම්බන්ධතා ඇති කර ගැනීම සඳහා වරාය අංකය. සේවාදායකය සහ සේවාදායක තොට සමාන විය යුතුය. 1025 සිට 65535 දක්වා අගයන් නිර්දේශ කරනු ලැබේ, මන්ද 1 සිට 1024 දක්වා - පද්ධතිය විසින් අල්ලා ගත හැක. වර්ගය: පූර්ණ සංඛ්යාව;
සේවාව - තොට භාවිතා කරන සේවාව (ftp, http, pop, ආදිය) නිර්වචනය කරන තන්තුවකි. මෙය විවිධ සම්මත ප්‍රොටෝකෝලවලට අනුරූප වන වරාය අංකවල නාමාවලියකි. වර්ගය: නූල්;
ක්රම
විවෘත - සේවාදායකය ආරම්භ කරයි. මූලික වශයෙන්, මෙම විධානය සක්‍රීය දේපල සත්‍ය ලෙස සැකසීමට සමාන වේ;
වසන්න - සේවාදායකය නවත්වයි. මූලික වශයෙන්, මෙම විධානය සක්‍රීය දේපල අසත්‍ය ලෙස සැකසීමට සමාන වේ.
සිද්ධීන්
OnClientConnect - සේවාදායකයා සොකට් සම්බන්ධතාවයක් ස්ථාපිත කර සේවාදායකයෙන් ප්‍රතිචාරයක් බලාපොරොත්තුවෙන් සිටින විට සිදු වේ (OnAccept);
OnClientDisconnect - සේවාදායකයා සොකට් නාලිකාවෙන් විසන්ධි වූ විට සිදු වේ;
OnClientError - වත්මන් මෙහෙයුම අසාර්ථක වූ විට සිදු වේ, i.e. දෝෂයක් සිදුවී ඇත;
OnClientRead - සේවාදායකයා සේවාදායකයට යම් දත්තයක් ලබා දුන් විට සිදු වේ. මෙම දත්ත සැපයූ Socket පරාමිතිය හරහා ප්‍රවේශ විය හැක: TCustomWinSocket;
OnClientWrite - සේවාදායකයට සොකට් හරහා සේවාදායකයාට දත්ත යැවිය හැකි විට සිදු වේ;
OnGetSocket - මෙම සිදුවීම හසුරුවන්නෙහි ඔබට ClientSocket පරාමිතිය සංස්කරණය කළ හැකිය;
OnGetThread - මෙම සිදුවීම හසුරුවන්නා තුළ ඔබට SocketThread පරාමිතිය අපේක්ෂිත TServerClientThread උප කාර්යයට පැවරීමෙන් එක් එක් සේවාදායක නාලිකාව සඳහා අනන්‍ය ක්‍රියාවලියක් (නූල්) අර්ථ දැක්විය හැක;
OnThreadStart, OnThreadEnd - පිළිවෙලින් උප කාර්යයක් (ක්‍රියාවලියක්, ත්‍රෙඩ්) ආරම්භ වූ විට හෝ නැවැත්වූ විට සිදු වේ;
OnAccept - සේවාදායකය සේවාදායකයා පිළිගන්නා විට හෝ ඔහුට සම්බන්ධතාවයක් ප්‍රතික්ෂේප කරන විට සිදු වේ;
ඔන්ලිසන් - සේවාදායකයන් සම්බන්ධ වීමට සේවාදායකය පොරොත්තු මාදිලියට ගිය විට සිදු වේ.
TServerSocket.Socket(TSServerWinSocket)
ඉතින් සේවාදායකයා සේවාදායකයාට දත්ත යැවිය හැක්කේ කෙසේද? දත්ත ලැබීම ගැන කුමක් කිව හැකිද? මූලික වශයෙන්, ඔබ OnClientRead සහ OnClientWrite සිදුවීම් හරහා වැඩ කරන්නේ නම්, එවිට ඔබට ClientSocket පරාමිතිය (TCustomWinSocket) හරහා සේවාදායකයා සමඟ සන්නිවේදනය කළ හැකිය. සේවාදායක සොකට් පිළිබඳ ලිපියේ මෙම පන්තිය සමඟ වැඩ කිරීම ගැන ඔබට කියවිය හැකිය, මන්ද මෙම පන්තිය හරහා දත්ත යැවීම/ යැවීම සමාන වේ - ක්‍රම (යවන්න/ලැබීම)(පෙළ, බෆරය, ප්‍රවාහය). TServerSocket.Socket සමඟ වැඩ කරන විටද එය අදාළ වේ. කෙසේ වෙතත්, නිසා මෙන්න අපි සේවාදායකයක් ගැන සලකා බලමු, අපි ප්රයෝජනවත් ගුණාංග සහ ක්රම කිහිපයක් ඉස්මතු කළ යුතුය: · ActiveConnections (Integer) - සම්බන්ධිත සේවාදායකයින් සංඛ්යාව; ·ActiveThreads (Integer) - ධාවන ක්‍රියාවලි ගණන; ·සම්බන්ධතා (අරාව) - සම්බන්ධිත එක් එක් සේවාදායකයා සඳහා වෙන වෙනම TClientWinSocket පන්ති වලින් සමන්විත අරාවකි. උදාහරණයක් ලෙස, මෙම විධානය: · ServerSocket1.Socket.Connections.SendText("Hello!"); · පළමු සම්බන්ධිත සේවාදායකයාට "Hello!" පණිවිඩයක් යවයි. මෙම අරාවේ මූලද්‍රව්‍ය සමඟ වැඩ කිරීම සඳහා වන විධාන - ද (යවන්න/ලැබීම)(පෙළ, බෆරය, ප්‍රවාහය); · IdleThreads (Integer) - නිදහස් ක්‍රියාවලි ගණන. එවැනි ක්රියාවලීන් සේවාදායකය විසින් හැඹිලිගත කර ඇත (TreadCacheSize බලන්න); ·LocalAddress, LocalHost, LocalPort - පිළිවෙලින් - දේශීය IP ලිපිනය, සත්කාරක නාමය, වරාය; ·RemoteAddress, RemoteHost, RemotePort - පිළිවෙලින් - දුරස්ථ IP ලිපිනය, සත්කාරක නාමය, වරාය; · ක්‍රම අගුලු දැමීම සහ අගුළු හැරීම - පිළිවෙලින්, සොකට් අවහිර කිරීම සහ අවහිර කිරීම.
පුහුණුවීම් සහ උදාහරණ
දැන් අපි නිශ්චිත උදාහරණයක් භාවිතා කර ඉහත සඳහන් දේ බලමු. ඔබට මෙහි ක්ලික් කිරීමෙන් සූදානම් කළ මූලාශ්‍ර බාගත කළ හැකිය.
එබැවින්, TServerSocket සමඟ වැඩ කිරීමේ ඉතා හොඳ උදාහරණයක් දෙස බලමු (මෙම උදාහරණය මෙම සංරචකය අධ්යයනය කිරීම සඳහා වඩාත්ම දෘශ්ය ආධාරය වේ). පහත මූලාශ්‍ර මගින් සියලුම වැදගත් සේවාදායක සිදුවීම් ලොග් වීම සහ කෙටි පණිවිඩ ලැබීමේ සහ යැවීමේ හැකියාව පෙන්නුම් කරයි:
උදාහරණ 1. ලොග් කිරීම සහ සේවාදායකයේ ක්‍රියාකාරිත්වය අධ්‍යයනය කිරීම, සොකට් හරහා පණිවිඩ යැවීම/ලැබීම.

(...මෙන්න ගොනු ශීර්ෂය සහ TForm1 පෝරමයේ නිර්වචනය සහ එහි උදාහරණය Form1)

(සම්පූර්ණ මූලාශ්‍රය මෙතැනින් බලන්න)

ක්රියා පටිපාටිය TForm1.Button1Click (යවන්නා: TObject );

ආරම්භය

(වරාය නිර්ණය කර සේවාදායකය ආරම්භ කරන්න)

ServerSocket1.Port := 1025 ;

(ඇතුළු කිරීමේ ක්‍රමය මඟින් නිශ්චිත ස්ථානයේ අරාව තුළට තන්තුවක් ඇතුළත් කරයි)

Memo2.Lines .Insert (0 , "Server starting" );

ServerSocket1.Open ;

අවසානය ;

ක්රියා පටිපාටිය TForm1.Button2Click (යවන්නා: TObject );

ආරම්භය

(සේවාදායකය නවත්වන්න)

ServerSocket1.Active := False ;

Memo2.Lines .ඇතුළු කරන්න (0 , "සේවාදායකය නතර" );

අවසානය ;

ක්රියා පටිපාටිය TForm1.ServerSocket1Listen (යවන්නා: TObject ;

සොකට්: TCustomWinSocket);

ආරම්භය

(මෙහි සේවාදායකය සේවාදායකයන් සඳහා සොකට් මත "සවන් දෙමින්" ඇත)

Memo2.Lines .Insert (0 , "වරායේ සවන්දීම" +IntToStr (ServerSocket1.Port) );

අවසානය ;

ක්රියා පටිපාටිය TForm1.ServerSocket1Accept (යවන්නා: TObject ;

සොකට්: TCustomWinSocket);

ආරම්භය

(මෙහි සේවාදායකය සේවාදායකයා පිළිගනී)

Memo2.Lines .ඇතුළු කරන්න (0 , "සේවාදායක සම්බන්ධතාවය පිළිගෙන ඇත" );

අවසානය ;

ක්රියා පටිපාටිය TForm1.ServerSocket1ClientConnect (යවන්නා: TObject ;

සොකට්: TCustomWinSocket);

ආරම්භය

(මෙහි සේවාදායකයා සම්බන්ධ වේ)

Memo2.Lines .ඇතුළු කරන්න (0 , "සේවාලාභියා සම්බන්ධ" );

අවසානය ;

ක්රියා පටිපාටිය TForm1.ServerSocket1ClientDisconnect (යවන්නා: TObject ;

සොකට්: TCustomWinSocket);

ආරම්භය

(මෙහි සේවාදායකයා විසන්ධි වේ)

Memo2.Lines.Insert(0,"සේවාලාභියා විසන්ධි කර ඇත");

අවසානය ;

ක්රියා පටිපාටිය TForm1.ServerSocket1ClientError (යවන්නා: TObject ;

සොකට්: TCustomWinSocket; ErrorEvent: TERrorEvent;

var ErrorCode: Integer);

ආරම්භය

(දෝෂයක් සිදු විය - එහි කේතය පෙන්වන්න)

Memo2.Lines.Insert (0,"සේවාදායක දෝෂය. කේතය = " +IntToStr (ErrorCode) );

අවසානය ;

ක්රියා පටිපාටිය TForm1.ServerSocket1ClientRead (යවන්නා: TObject ;

සොකට්: TCustomWinSocket);

ආරම්භය

(සේවාදායකයාගෙන් පණිවිඩයක් ලැබී ඇත - එය Memo1 හි ප්‍රදර්ශනය කරන්න)

Memo2.Lines.Insert(0, "සේවාදායකයාගෙන් ලැබුණු පණිවිඩය") ;

Memo1.Lines.Insert(0,">" +Socket.ReceiveText);

අවසානය ;

ක්රියා පටිපාටිය TForm1.ServerSocket1ClientWrite (යවන්නා: TObject ;

සොකට්: TCustomWinSocket);

ආරම්භය

(දැන් ඔබට සොකට් එකට දත්ත යැවිය හැක)

Memo2.Lines .Insert (0 , "දැන් සොකට් එකට ලිවිය හැක" );

අවසානය ;

ක්රියා පටිපාටිය TForm1.ServerSocket1GetSocket (යවන්නා: TObject ; Socket: Integer ;

var ClientSocket: TServerClientWinSocket);

ආරම්භය

Memo2.Lines .Insert (0 , "Get socket" );

අවසානය ;

ක්රියා පටිපාටිය TForm1.ServerSocket1GetThread (යවන්නා: TObject ;

ClientSocket: TServerClientWinSocket;

var SocketThread: TServerClientThread) ;

ආරම්භය

Memo2.Lines.Insert(0,"Get Thread");

අවසානය ;

ක්රියා පටිපාටිය TForm1.ServerSocket1ThreadEnd (යවන්නා: TObject ;

ආරම්භය

Memo2.Lines .ඇතුළු කරන්න (0 , "නූල් අවසානය" );

අවසානය ;

ක්රියා පටිපාටිය TForm1.ServerSocket1ThreadStart (යවන්නා: TObject ;

නූල්: TServerClientThread) ;

ආරම්භය

Memo2.Lines .ඇතුළු කරන්න (0 , "නූල් ආරම්භය" );

අවසානය ;

ක්රියා පටිපාටිය TForm1.Button3Click (යවන්නා: TObject );

var i: නිඛිල ;

ආරම්භය

(සංස්කරණය 1 වෙතින් සියලුම සේවාදායකයින් වෙත පණිවිඩයක් යවන්න)

සඳහා i:= 0 සිට ServerSocket1.Socket .ActiveConnections -1 ආරම්භ වේ

ServerSocket1.Socket.Connections[i].SendText(Edit1.Text);

අවසානය ;

Memo1.Lines.Insert(0,"< " +Edit1.Text ) ;

අවසානය ;

ඊළඟට, අපි උදාහරණ නොව, TServerSocket සමඟ වැඩ කිරීමේ ක්රම සලකා බලමු.
TServerSocket සමඟ වැඩ කිරීමේ තාක්ෂණය (සහ සරලව සොකට් සමඟ)
එක් එක් සේවාදායකයා සඳහා අද්විතීය දත්ත ගබඩා කිරීම.
නිසැකවම, ඔබේ සේවාදායකය බොහෝ සේවාදායකයින්ට සේවය කරන්නේ නම්, ඔබට එක් එක් සේවාදායකයා (නම, ආදිය) සඳහා යම් තොරතුරු ගබඩා කිරීමට අවශ්‍ය වනු ඇත, සහ මෙම තොරතුරු මෙම සේවාදායකයාගේ සොකට් එකට බැඳ තබන්න. සමහර අවස්ථාවලදී, මේ සියල්ල අතින් සිදු කිරීම (සොකට් හසුරුවකට බැඳීම, සේවාදායක අරා, ආදිය) ඉතා පහසු නොවේ. එබැවින්, එක් එක් සොකට් සඳහා විශේෂ දේපලක් ඇත - දත්ත. ඇත්ත වශයෙන්ම, දත්ත යනු දර්ශකයක් පමණි. එබැවින්, මෙම දේපල වෙත සේවාදායක දත්ත ලිවීමේදී, ප්රවේශම් වන්න සහ පොයින්ටර් සමඟ වැඩ කිරීමේ නීති අනුගමනය කරන්න (මතක වෙන් කිරීම, වර්ග නිර්වචනය, ආදිය)!
සොකට් හරහා ගොනු යැවීම.
මෙහිදී අපි සොකට් එකක් හරහා ලිපිගොනු යැවීම දෙස බලමු (JINX හි ඉල්ලීම පරිදි) :-). ඉතින් කොහොමද ඔබ සොකට් එකකට ගොනුවක් යවන්නේ? හරිම සරලයි! ඔබ කළ යුත්තේ මෙම ගොනුව ගොනු ප්‍රවාහයක් (TFileStream) ලෙස විවෘත කර සොකට් (SendStream) හරහා යැවීමයි! අපි මෙය උදාහරණයකින් බලමු:

(සොකට් හරහා ගොනුවක් යැවීම)

ක්රියා පටිපාටිය SendFileBySocket (ගොනු නාමය: string );

var srcfile: TFileStream;

ආරම්භය

(ගොනුවේ නම විවෘත කරන්න)

Srcfile:= TFileStream.Create (ගොනු නාමය,fmOpenRead) ;

(අපි එය පළමු සම්බන්ධිත සේවාදායකයා වෙත යවමු)

ServerSocket1.Socket.Connections[0].SendStream(srcfile);

(ගොනුව වසන්න)

Srcfile.Free ;

අවසානය ;

SendStream ක්‍රමය සේවාදායකය විසින් පමණක් නොව, සේවාලාභියා විසින්ද භාවිතා කරන බව සටහන් කළ යුතුය (ClientSocket1.Socket.SendStream(srcfile))
සම්ප්‍රේෂණයේදී බ්ලොක් කිහිපයක් එකකට ඒකාබද්ධ කළ හැක්කේ ඇයි?
මෙයද JINX ගේ ඉල්ලීම මත ය :-). මේ සඳහා ඔහුට බොහෝ ස්තූතියි! එබැවින්, පළමුව, සොකට් හරහා යවන ලද දත්ත එක් කොටසකට ඒකාබද්ධ කිරීම පමණක් නොව, බ්ලොක් කිහිපයක් හරහා වෙන් කළ හැකි බව සැලකිල්ලට ගත යුතුය. කාරණය නම් සොකට් යනු සාමාන්‍ය ප්‍රවාහයක් වන නමුත්, ගොනු ප්‍රවාහයක් (TFileStream) මෙන් නොව, එය දත්ත වඩාත් සෙමින් මාරු කරයි (ඔබට තේරෙනවා - ජාලය, සීමිත ගමනාගමනය, ආදිය). ඒ නිසා විධාන දෙකක්:
ServerSocket1.Socket.Connections.SendText("Hello,");
ServerSocket1.Socket.Connections.SendText("ලොව!");
එක් විධානයකට සම්පූර්ණයෙන්ම සමාන වේ:
ServerSocket1.Socket.Connections.SendText("Hello, world!");
ඔබ සොකට් එකක් හරහා 100 KB ගොනුවක් යවන්නේ නම්, ඔබ මෙම කොටස එවූ පුද්ගලයාට රථවාහන සහ මාර්ග තදබදය මත රඳා පවතින ප්‍රමාණයේ කුට්ටි කිහිපයක් ලැබෙනු ඇත්තේ එබැවිනි. එපමණක්ද නොව, ප්රමාණ අනිවාර්යයෙන්ම සමාන නොවේ. එය අනුගමනය කරන්නේ ගොනුවක් හෝ වෙනත් විශාල දත්තයක් පිළිගැනීම සඳහා, ඔබ දත්ත කොටස් පිළිගත යුතු අතර පසුව ඒවා එකකට ඒකාබද්ධ කළ යුතුය (සහ, උදාහරණයක් ලෙස, ගොනුවකට සුරකින්න). මෙම ගැටලුවට විශිෂ්ට විසඳුමක් වන්නේ එකම ගොනු ධාරාවයි - TFileStream (හෝ මතකයේ ඇති ධාරාවක් - TMemoryStream). විශ්වීය ReceiveBuf ක්‍රමය භාවිතයෙන් ඔබට OnRead (OnClientRead) ඉසව්ව හරහා සොකට් එකකින් දත්ත කොටස් ලබා ගත හැක. ලැබුණු බ්ලොක් ප්රමාණය ReceiveLength ක්රමය භාවිතයෙන් තීරණය කළ හැකිය. ඔබට සොකට් ප්‍රවාහයක් ද භාවිතා කළ හැකිය (TClientSocket පිළිබඳ ලිපිය බලන්න). මෙන්න කුඩා උදාහරණයක් (ආසන්න):

(සොකට් හරහා ගොනුව ලබා ගන්න)

ක්රියා පටිපාටිය TForm1.ClientSocket1Read (යවන්නා: TObject ;

සොකට්: TCustomWinSocket);

var l: පූර්ණ සංඛ්යාව ;

Buf: PChar ;

Src: TFileStream;

ආරම්භය

(එමෙන්ම ලැබෙන කොටසේ ප්‍රමාණය l වලින් ලියන්න)

L:= Socket.ReceiveLength ;

(බෆරය සඳහා මතකය ඇණවුම් කරන්න)

GetMem (buf,l+1 );

(ප්‍රතිඵල ලැබෙන බ්ලොක් එක බෆරයට ලියන්න)

Socket.ReceiveBuf(buf,l);

(ලිවීම සඳහා තාවකාලික ගොනුවක් විවෘත කරන්න)

Src:= TFileStream.Create("myfile.tmp" ,fmOpenReadWrite) ;

(ගොනුව අවසානයේ පිහිටීම තබන්න)

Src.Seek (0 ,soFromEnd) ;

(බෆරය ගොනුවකට ලියන්න)

Src.WriteBuffer(buf,l);

(ගොනුව වසන්න)

Src.Free;

(මතකය නිදහස් කිරීම)

FreeMem(buf);

අවසානය ;

සොකට් එකක් නිරීක්ෂණය කරන්නේ කෙසේද
මෙම ගැටළුව සංකීර්ණ වන අතර දිගු සලකා බැලීම අවශ්ය වේ. දැනට, ඔබගේ වැඩසටහන මඟින් නිර්මාණය කරන ලද සොකට් එක ඔබට සැමවිටම නිරීක්ෂණය කළ හැකි බව මම සටහන් කරමි :-). Sockets (Windows හි බොහෝ වස්තු වැනි) හැන්ඩ්ල් දේපලෙහි ලියා ඇති තමන්ගේම හසුරුව ඇත. එබැවින්, ඔබ මෙම විස්තරය හඳුනා ගත් පසු, ඔබට ඕනෑම සොකට් එකක් නිදහසේ කළමනාකරණය කිරීමට හැකි වනු ඇත (වෙනත් කෙනෙකුගේ වැඩසටහනක් විසින් නිර්මාණය කරන ලද එකක් පවා)! කෙසේ වෙතත්, බොහෝ දුරට, වෙනත් කෙනෙකුගේ සොකට් නිරීක්ෂණය කිරීම සඳහා, ඔබට WinAPI Sockets කාර්යයන් පමණක් භාවිතා කිරීමට සිදුවනු ඇත.
එපිලොග්
මෙම ලිපිය Delphi හි TServerSocket සංරචකය සමඟ වැඩ කිරීමේ මූලික ශිල්පීය ක්‍රම සහ සොකට් හරහා දත්ත හුවමාරු කිරීමේ සාමාන්‍ය ශිල්පීය ක්‍රම කිහිපයක් පෙන්වයි. ඔබට ප්‍රශ්න ඇත්නම්, ඒවා මට විද්‍යුත් තැපෑලෙන් එවන්න: [ඊමේල් ආරක්ෂිත], සහ ඊටත් වඩා හොඳයි - මෙම වෙබ් අඩවියේ සම්මන්ත්‍රණයේ ලියන්න (ඩෙල්පි. සාමාන්‍ය ප්‍රශ්න) එවිට අනෙක් පරිශීලකයින්ට ඔබේ ප්‍රශ්නය දැක බලා එයට පිළිතුරු දීමට උත්සාහ කරන්න!
Karik Nikolay (Nitro). මොස්කව් කලාපය, Zhukovsky

මම ජාල සහාය එකතු කර ඇත. එනම්, ඔහු වෙනම සේවාදායකයක් සහ වෙනම සේවාදායකයෙකු නිර්මාණය කළේය. අදහස නම් යෙදුම් සේවාදායකය ක්‍රියාත්මක වන අතර, පරිශීලකයා සේවාදායකයා දියත් කර ඉල්ලීම පරිශීලකයාට ඇතුළත් කරයි: මොස්කව් ටවර්ස්කායා 6. එවිට සේවාදායකය ඉල්ලීම ක්‍රියාවට නංවා, Yandex.Maps වෙතින් සෙවුම් ප්‍රතිඵල ලබා ගන්නා අතර එහි ප්‍රතිඵලය වන රූපය සේවාදායකයාට යවයි, එවිට සේවාලාභියා තුළ, TMap සංරචකය පරිශීලකයාගේ ඉල්ලීමට ගැලපෙන දී ඇති කාඩ්පතක කොටසක් පෙන්වයි. ප්රතිඵලයක් වශයෙන්, පරිශීලකයාට එය පරිමාණය කිරීම, එය සුරැකීම සහ යනාදිය හැක.

එමනිසා, මෙම ලිපියෙන් මම සේවාදායකයා සහ සේවාදායකය ක්‍රියාත්මක කළ ආකාරය ඔබට පැවසීමට අවශ්‍යයි. මම මෙය කළේ TClientSocket සහ TServerSocket භාවිතයෙන්, මෙම ලිපියෙන් අපි මගේ ව්‍යාපෘතියේ මා භාවිතා කළ ක්‍රම පිළිබඳව විස්තරාත්මකව බලමු.

පළමුව, ඔබගේ IDE හි මෙම සංරචක ස්ථාපනය කරන්නේ කෙසේදැයි බලමු. ඔබ IDE Delphi 7 භාවිතා කරන්නේ නම්, මෙම සංරචක පෙරනිමියෙන් ඇත, නමුත්, අවාසනාවකට, ඒවා ස්ථාපනය කර නැත, නමුත් මෙය ගැටළුවක් නොවේ. අපට අවශ්‍ය වන්නේ ඩෙල්ෆි විවෘත කර ස්ථාපනය කිරීමයි.

මෙය සිදු කිරීම සඳහා, Component-Install Packages... විධානය ක්‍රියාත්මක කර දිස්වන කවුළුවේ, Add බොත්තම ක්ලික් කරන්න. මෙයින් පසු, ඔබ සාමාන්යයෙන් BIN ෆෝල්ඩරයේ පෙරනිමියෙන් පිහිටා ඇති dclsockets70.bpl ගොනුව වෙත මාර්ගය සඳහන් කළ යුතුය. මෙයින් පසු, ඔබ OK බොත්තම මත ක්ලික් කළ යුතුය. ඔබගේ සියලුම සංරචක අන්තර්ජාල පටිත්තෙහි දිස්විය යුතුය (TClientSocket සහ TServerSocket).

ව්යාපෘතියේ දී, මම අවම සේවාදායක සංවර්ධනය සමඟ සියලු වැඩ ආරම්භ කළෙමි. පළමුව, මම පෝරමයේ TServerSocket සංරචකය ස්ථාපනය කළෙමි. සහ මම සකසන Start server බොත්තම ක්ලික් කිරීමෙන් ආරම්භක සැකසුම්, එය ආරම්භ කිරීමට:

සේවාදායකය. වරාය:=FormServerSetting. SpinEditPort. අගය ; //සේවාදායක වරාය සඳහන් කරන්නසේවාදායකය. ක්රියාකාරී: = සත්ය; // එය සේවාදායකය සක්රිය කරන්න. විවෘත ; සේවාදායකය නම්. සක්රිය පසුව ආරම්භ කරන්න //සේවාදායකය ක්‍රියාත්මක වන බවට පණිවිඩයක් පෙන්වන්නඅවසානය ; …….. //සේවාදායකය ආරම්භ කර නොමැති නම් දෝෂයක් පෙන්වන්න

මගේ යන්ත්‍රයේ සේවාදායකය ආරම්භ කිරීම සඳහා, මම නොමිලේ වරායක් පමණක් නියම කළෙමි (එය වෙනත් යෙදුම් විසින් අල්ලාගෙන නොමැත) සහ එය සක්‍රිය කළෙමි.

ප්‍රතිපත්තිමය වශයෙන්, එපමණයි, මට වැඩ කිරීමට, සේවාදායකය ක්‍රියාත්මක වීමට සහ ඔවුන් යවන සේවාදායක ඉල්ලීම් සැකසීමට මට ප්‍රමාණවත් විය.

සේවාදායකයට සම්බන්ධ වන සේවාලාභීන්ගේ ලැයිස්තුවක් ලබා ගැනීමට සහ ඔවුන් සමඟ තවදුරටත් වැඩ කිරීමට, මම TCcheckListBox සංරචකය පෝරමයේ සහ TServerSocket සංරචකයේ OnclientConnect සිදුවීමේ ස්ථාපනය කළෙමි, පහත කේතය ලිවීය:

ක්රියා පටිපාටිය TFormServer. ServerClientConnect (යවන්නා: TObject; Socket: TCustomWinSocket) ; ආරම්භය // සේවාදායක සම්බන්ධතාවය නිරීක්ෂණය කරන්න RichEditLog. SelAtributes. වර්ණය: = clGreen; RichEditLog. SelAtributes. විලාසය: = [fsBold]; පිරික්සුම් ලැයිස්තු සේවාලාභියා. අයිතම. එකතු කරන්න (Socket.RemoteHost); RichEditLog. රේඛා. එකතු කරන්න ("[" + TimeToStr (කාලය ) + "] සම්බන්ධිත සේවාදායකයා: " + Socket. RemoteHost ) ; // ලැයිස්තුවට සම්බන්ධ වූ සේවාදායකයා එක් කරන්න RichEditLog. ඉටු කරන්න (WM_VSCROLL, SB_BOTTOM, 0) ; අවසානය ;

එනම්, ඔවුන් පිළිබඳ වැඩිදුර තොරතුරු ලබා ගැනීම සඳහා සේවාදායකයට සම්බන්ධ වන සේවාදායකයින්ගේ නම් මම ලැයිස්තුවට එකතු කරමි.

උදාහරණයක් ලෙස, ඔබට ලබා ගත හැකිය විස්තරාත්මක තොරතුරුසේවාදායකයා ගැන:

ක්රියා පටිපාටිය TFormInfoClient. FormShow(යවන්නා: TObject); ආරම්භය // සේවාදායකයා පිළිබඳ තොරතුරු පෙන්වන්නශීර්ෂ පාඨය: = "පාරිභෝගික තොරතුරු: "+FormServer. පිරික්සුම් ලැයිස්තු සේවාලාභියා. අයිතම[FormServer. පිරික්සුම් ලැයිස්තු සේවාලාභියා. අයිතම දර්ශකය ]; දේශීය නම. ශීර්ෂ පාඨය: = FormServer. සේවාදායකය. තව්ව. සම්බන්ධතා[FormServer. පිරික්සුම් ලැයිස්තු සේවාලාභියා. අයිතම දර්ශකය] . LocalHost ; LocalHost. ශීර්ෂ පාඨය: = FormServer. සේවාදායකය. තව්ව. සම්බන්ධතා[FormServer. පිරික්සුම් ලැයිස්තු සේවාලාභියා. අයිතම දර්ශකය] . දේශීය ලිපිනය ; LocalPort. Caption: = IntToStr(FormServer. Server. Socket. Connections[ FormServer. CheckListClient. ItemIndex]. LocalPort); දුරස්ථ නාමය. ශීර්ෂ පාඨය: = FormServer. සේවාදායකය. තව්ව. සම්බන්ධතා[FormServer. පිරික්සුම් ලැයිස්තු සේවාලාභියා. අයිතම දර්ශකය] . RemoteHost ; RemoteHost. ශීර්ෂ පාඨය: = FormServer. සේවාදායකය. තව්ව. සම්බන්ධතා[FormServer. පිරික්සුම් ලැයිස්තු සේවාලාභියා. අයිතම දර්ශකය] . දුරස්ථ ලිපිනය; දුරස්ථ වරාය. Caption: = IntToStr(FormServer. Server. Socket. Connections[ FormServer. CheckListClient. ItemIndex]. RemotePort); අවසානය ;

පහත දත්ත ලබා ගත හැක:

• දේශීය නම
• දේශීය ලිපිනය
• දේශීය වරාය
• නම ඉවත් කළා
• දුරස්ථ ලිපිනය
• දුරස්ථ වරාය

මම TcheckListBox සංරචක ලැයිස්තුවෙන් තෝරාගත් මෙම කේතය භාවිතා කරන සේවාදායකයා පිළිබඳ තොරතුරු මට ලැබේ.

ඔබට පෙනෙන පරිදි, සංකීර්ණ කිසිවක් නොමැත; සේවාදායකයාට පණිවිඩයක් යැවීම සඳහා, ඔබට පහත කේතය භාවිතා කළ හැකිය:

තුල හතරැස් වරහන්, අපි පණිවිඩය යවන්නේ කුමන සේවාදායකයාටද යන්න මම සඳහන් කරමි (මෙය TcheckListBox සංරචකයේ තෝරාගත් සේවාදායකයාට සමාන වේ), මම පණිවිඩයේ #message# සඳහන් කරමි - එයින් අදහස් වන්නේ මෙය සරලව ප්‍රදර්ශනය කළ යුතු සේවාදායකයෙන් ලැබෙන සාමාන්‍ය පණිවිඩයක් බවයි. කවුළුව තුළ.

සේවාදායකයාගෙන් සේවාදායකයට පණිවිඩයක් ලබා ගැනීම සඳහා, අපට TServerSocket සංරචකයේ OnClientRead සිදුවීම සහ සේවාලාභියා යවන ඉල්ලීම පටිගත කරන පෙළ විචල්‍යයක් අවශ්‍ය වේ.

ක්රියා පටිපාටිය TFormServer. ServerClientRead (යවන්නා: TObject; Socket: TCustomWinSocket) ; var විමසුම: String ; ආරම්භය //කාඩ්පත සඳහා සේවාදායකයාගෙන් ඉල්ලීමක් ලබා ගන්නවිමසුම උත්සාහ කරන්න: = Socket. ලැබීම් පෙළ ; pos නම් ("විමසුම" , විමසුම)<>0 පසුව ආරම්භ කරන්න //Yandex වෙතින් ඉල්ලීමක් හෝ ගූගල් ඛණ්ඩාංකසේවාදායකයාගේ ඉල්ලීම අනුව කාඩ්පත්අවසානය ; //එය සේවාදායකයාගේ පණිවිඩයක් නම්, එය පෙන්වන්න pos නම් ("#පණිවිඩ#" , විමසුම)<>0 පසුව ආරම්භය අවසානය; ……

මෙම කේතයෙන් ඔබට සේවාදායකයාට සාමාන්‍ය පණිවිඩයක් සහ සිතියමක් ලබා ගැනීමට ඉල්ලීමක් යැවිය හැකි බව ඔබට පෙනේ: මොස්කව්, ටවර්ස්කායා, 6.

මෙය සිදු කිරීම සඳහා, සාමාන්‍ය පණිවිඩය කොතැනද යන්න සහ කාඩ්පතක් ලැබීමට ඇති ඉල්ලීම හරියටම කොතැනද යන්න තීරණය කිරීමට මට අවශ්‍ය වේ, එවිට සේවාදායකයට පසුව එය සැකසීමට හැකිය. මෙම අවස්ථාවේදී, මම ආරම්භයේදීම සේවාදායකයාගේ පණිවිඩවලට පහත හඳුනාගැනීම් එකතු කරමි:

• #පණිවුඩය#
• #විමසුම#

සේවාදායකයාගේ පණිවිඩයේ ආරම්භයේ #message# හඳුනාගැනීම් තිබේ නම්, සේවාදායකයා එය සේවාලාභියාගෙන් ලැබෙන නිත්‍ය පණිවිඩයක් ලෙස හඳුනා ගනී. #query# හැඳුනුම්කාරකය පණිවිඩයේ ආරම්භයේ තිබේ නම්, මෙයින් අදහස් කරන්නේ සේවාදායකයා කාඩ්පතක් ලබා ගැනීමට ඉල්ලීමක් යවා ඇති බවයි.

එසේම, සේවාලාභියෙකුට ඕනෑම වේලාවක සේවාදායකයෙන් විසන්ධි විය හැක; සේවාදායකයට සම්බන්ධ සේවාලාභීන්ගේ සාමාන්‍ය ලැයිස්තුවෙන් එය ඉවත් කිරීම සඳහා අපට මෙය නිරීක්ෂණය කිරීමටද අවශ්‍ය වේ. මෙය සිදු කිරීම සඳහා, TServerSocket සංරචකය තෝරා පහත කේතය OnClientDisconnect සිදුවීමට ලියන්න:

ක්රියා පටිපාටිය TFormServer. ServerClientDisconnect (යවන්නා: TObject; Socket: TCustomWinSocket) ; var i: පූර්ණ සංඛ්යාව ; උත්සාහ ආරම්භ කරන්න // සේවාදායක විසන්ධි කිරීම නිරීක්ෂණය කරන්න RichEditLog. SelAtributes. වර්ණය:=clRed; RichEditLog. SelAtributes. විලාසය: = [fsBold]; i සඳහා: = 0 සේවාදායකයට. තව්ව. Active Connections - 1 Server නම් ආරම්භ වේ. තව්ව. සම්බන්ධතා[i]. හසුරුව = සේවාදායකය. තව්ව. සම්බන්ධතා[i]. හසුරුවන්න පසුව RichEditLog ආරම්භ කරන්න. රේඛා. එකතු කරන්න ("[" + TimeToStr (කාලය ) + "] සේවාලාභියා විසන්ධි කර ඇත: " + Socket. RemoteHost ) ; පිරික්සුම් ලැයිස්තු සේවාලාභියා. අයිතම. මකන්න (i) ; RichEditLog. ඉටු කරන්න (WM_VSCROLL, SB_BOTTOM, 0) ; අවසානය ; අවසානය ; අවසානයේ //-//-//-//-//-// අවසානය ; අවසානය ;

අපි ලැයිස්තුවේ ඇති සියලුම සේවාදායකයින් හරහා ගොස් අපට එකක් සොයාගත නොහැකි නම්, අපි එය TcheckListBox සංරචකයෙන් ඉවත් කරමු, මෙයින් අදහස් කරන්නේ සේවාදායකයා එහි යෙදුමේ විසන්ධි බොත්තම ක්ලික් කළ බවයි.