डेल्फी में InternetPCools FPC लाइब्रेरी का उपयोग करना

वास्तव में, लेख कुछ व्यापक है - यह कई अन्य पुस्तकालयों को पारदर्शी रूप से उपयोग करने का एक तरीका बताता है (और न केवल फ्री पास्कल की दुनिया से), और इंटरनेटटूल को इसकी उल्लेखनीय संपत्ति के कारण चुना गया था - यह मामला है जब (आश्चर्यजनक रूप से) गायब है डेल्फी-संस्करण समान सुविधाओं और प्रयोज्य के साथ।

यह लाइब्रेरी वेब दस्तावेजों (XML और HTML) से जानकारी (पार्सिंग) निकालने के लिए डिज़ाइन की गई है, जिससे आप आवश्यक डेटा का संकेत देने के लिए उच्च स्तरीय क्वेरी भाषाओं जैसे XPath और XQuery का उपयोग कर सकते हैं , और एक विकल्प के रूप में, सीधे पहुंच प्रदान कर सकते हैं। दस्तावेज़ पर निर्मित एक पेड़ के तत्व।

इंटरनेटटूलों का परिचय

आगे की सामग्री को एक सरल कार्य के आधार पर चित्रित किया जाएगा, जिसका तात्पर्य इस लेख के बुलेटेड और गिने हुए सूचियों के उन तत्वों को प्राप्त करना है, जिनमें लिंक होते हैं, जिसके लिए, यदि आप प्रलेखन को देखते हैं , तो ऐसा एक छोटा कोड पर्याप्त है (यह छोटे, अप्रकाशित परिवर्तनों के साथ penultimate उदाहरण के आधार पर बनाया गया है। ):

uses xquery; const ArticleURL = 'https://habr.com/post/415617'; ListXPath = '//div[@class="post__body post__body_full"]//li[a]'; var ListValue: IXQValue; begin for ListValue in xqvalue(ArticleURL).retrieve.map(ListXPath) do Writeln(ListValue.toString); end. 

हालाँकि, अब यह कॉम्पैक्ट और ऑब्जेक्ट-ओरिएंटेड कोड केवल फ्री पास्कल में लिखा जा सकता है, लेकिन हमें उन सभी चीजों का उपयोग करने में सक्षम होना चाहिए जो यह लाइब्रेरी डेल्फी एप्लिकेशन में प्रदान करती है, और अधिमानतः समान शैली में, समान सुविधाओं के साथ; यह भी ध्यान रखना महत्वपूर्ण है कि InternetTools थ्रेड सुरक्षित है (इसे एक ही समय में कई थ्रेड्स से अनुमत है), इसलिए हमारे विकल्प को यह प्रदान करना चाहिए।

कार्यान्वयन के तरीके

यदि आप कार्य को यथासंभव दूर ले जाते हैं, तो किसी अन्य भाषा में लिखी गई चीज़ का उपयोग करने के कई तरीके हैं - वे 3 बड़े समूह बनाएंगे:

1. लाइब्रेरी को एक अलग प्रक्रिया में रखकर, निष्पादन योग्य फ़ाइल, बलों द्वारा बनाई गई है, इस मामले में, एफपीसी । संभव नेटवर्क संचार के लिए इस पद्धति को भी दो श्रेणियों में विभाजित किया जा सकता है:
   
   • इंटरप्रोसेस संचार का क्षेत्र केवल एक कंप्यूटर तक सीमित है। इस तरह के विनिमय के लिए सबसे अधिक उत्पादक साधन (सशर्त रूप से निम्न स्तर), साझा की गई मेमोरी और अनाम चैनल शामिल हैं ।
   • नेटवर्क के माध्यम से प्रक्रियाएं सुलभ हैं - यह नामित पाइप , आरपीसी , डीसीओएम , आदि द्वारा प्रदान किया जाता है।
2. एक DLL में लाइब्रेरी को एनक्रिप्ट करना (इसके बाद कभी-कभी "डायनेमिक लाइब्रेरी" के रूप में जाना जाता है), परिभाषा के अनुसार, उसी प्रक्रिया के भीतर काम करना। यद्यपि COM ऑब्जेक्ट को DLL में रखा जा सकता है , लेख एक सरल और कम समय लेने वाली विधि पर विचार करेगा, जो लाइब्रेरी की कार्यक्षमता को कॉल करते समय यह सब समान आराम के साथ देता है।
3. पोर्टिंग। पिछले मामलों की तरह, इस दृष्टिकोण की उपयुक्तता - दूसरी भाषा में कोड को फिर से लिखना - इसके पेशेवरों और विपक्षों के बीच संतुलन से निर्धारित होता है, लेकिन इंटरनेटटूल के साथ स्थिति में पोर्टिंग के नुकसान बहुत अधिक हैं, अर्थात्: पुस्तकालय कोड की काफी मात्रा के कारण, आपको कुछ बहुत गंभीर काम करने की आवश्यकता होगी (यहां तक ​​कि प्रोग्रामिंग भाषाओं की समानता को ध्यान में रखते हुए), और समय-समय पर, पोर्टेबल एक के विकास के कारण, डेल्फी में सुधार और नई सुविधाओं को स्थानांतरित करने का कार्य दिखाई देगा।

DLL

इसके अलावा, पाठक को अंतर महसूस करने का अवसर प्रदान करने के लिए, 2 विकल्प हैं जो उनके उपयोग की सुविधा से अलग हैं।

"क्लासिक" कार्यान्वयन

आइए एक गतिशील पुस्तकालय की बहुत ही प्रकृति द्वारा निर्देशित प्रक्रियात्मक शैली में इंटरनेटटूल का उपयोग शुरू करने का प्रयास करें जो केवल कार्यों और प्रक्रियाओं का निर्यात कर सकता है; हम WinAPI के समान DLL के साथ संचार करने का तरीका बनाएंगे, जब एक निश्चित संसाधन का हैंडल पहले अनुरोध किया जाता है, जिसके बाद उपयोगी कार्य किया जाता है, और फिर परिणामी हैंडल नष्ट हो जाता है (बंद)। इस विकल्प को हर चीज में एक रोल मॉडल के रूप में विचार करना आवश्यक नहीं है - यह केवल प्रदर्शन के लिए चुना जाता है और दूसरे के साथ तुलना के बाद - एक प्रकार का गरीब रिश्तेदार।

प्रस्तावित समाधान की फ़ाइलों की संरचना और स्वामित्व इस तरह दिखाई देंगे (तीर निर्भरता दर्शाते हैं):

InternetTools.Types मॉड्यूल

चूंकि दोनों भाषाएँ - डेल्फी और फ्री पास्कल - इस मामले में बहुत समान हैं, इसलिए इस तरह के एक सामान्य मॉड्यूल को DLL निर्यात सूची में उपयोग किए गए प्रकारों को आवंटित करना बहुत ही उचित है, ताकि इंटरनेटटूलस एप्लिकेशन में उनकी परिभाषा की नकल न करें। , जिसमें डायनामिक लाइब्रेरी से कार्यक्षमता के प्रोटोटाइप शामिल हैं:

 unit InternetTools.Types; interface type TXQHandle = Integer; implementation end. 

इस कार्यान्वयन में, केवल एक बाशफुल प्रकार को परिभाषित किया गया है, लेकिन भविष्य में, मॉड्यूल "परिपक्व" होगा और इसकी उपयोगिता निर्विवाद हो जाएगी।

InternetTools डायनामिक लाइब्रेरी

डीएलएल की प्रक्रियाओं और कार्यों की संरचना न्यूनतम चयनित है, लेकिन उपरोक्त कार्य के कार्यान्वयन के लिए पर्याप्त है:

 library InternetTools; uses InternetTools.Types; function OpenDocument(const URL: WideString): TXQHandle; stdcall; begin ... end; procedure CloseHandle(const Handle: TXQHandle); stdcall; begin ... end; function Map(const Handle: TXQHandle; const XQuery: WideString): TXQHandle; stdcall; begin ... end; function Count(const Handle: TXQHandle): Integer; stdcall; begin ... end; function ValueByIndex(const Handle: TXQHandle; const Index: Integer): WideString; stdcall; begin ... end; exports OpenDocument, CloseHandle, Map, Count, ValueByIndex; begin end. 

वर्तमान कार्यान्वयन की डेमो प्रकृति के कारण, पूर्ण कोड नहीं दिया गया है - बहुत अधिक महत्वपूर्ण यह है कि इस सरलतम एपीआई को बाद में कैसे उपयोग किया जाएगा। यहां आपको केवल थ्रेड सुरक्षा की आवश्यकता के बारे में भूलने की ज़रूरत नहीं है, जो, हालांकि इसे कुछ प्रयास की आवश्यकता होगी, लेकिन यह कुछ जटिल नहीं होगा।

InternetToolsUsage अनुप्रयोग

पिछली तैयारियों के लिए धन्यवाद, डेल्फी में सूची उदाहरण को फिर से लिखना संभव हो गया:

 program InternetToolsUsage; ... uses InternetTools.Types; const DLLName = 'InternetTools.dll'; function OpenDocument(const URL: WideString): TXQHandle; stdcall; external DLLName; procedure CloseHandle(const Handle: TXQHandle); stdcall; external DLLName; function Map(const Handle: TXQHandle; const XQuery: WideString): TXQHandle; stdcall; external DLLName; function Count(const Handle: TXQHandle): Integer; stdcall; external DLLName; function ValueByIndex(const Handle: TXQHandle; const Index: Integer): WideString; stdcall; external DLLName; const ArticleURL = 'https://habr.com/post/415617'; ListXPath = '//div[@class="post__body post__body_full"]//li[a]'; var RootHandle, ListHandle: TXQHandle; I: Integer; begin RootHandle := OpenDocument(ArticleURL); try ListHandle := Map(RootHandle, ListXPath); try for I := 0 to Count(ListHandle) - 1 do Writeln( ValueByIndex(ListHandle, I) ); finally CloseHandle(ListHandle); end; finally CloseHandle(RootHandle); end; ReadLn; end. 

यदि आप डायनामिक लाइब्रेरी से फ़ंक्शंस और प्रक्रियाओं के प्रोटोटाइप को ध्यान में नहीं रखते हैं, तो आप यह नहीं कह सकते कि कोड नि: शुल्क पास्कल के संस्करण की तुलना में भारी रूप से भारी है, लेकिन अगर हम कार्य को थोड़ा जटिल करते हैं और कुछ तत्वों को फ़िल्टर करने और लिंक पते प्रदर्शित करने का प्रयास करते हैं। शेष:

 uses xquery; const ArticleURL = 'https://habr.com/post/415617'; ListXPath = '//div[@class="post__body post__body_full"]//li[a]'; HrefXPath = './a/@href'; var ListValue, HrefValue: IXQValue; begin for ListValue in xqvalue(ArticleURL).retrieve.map(ListXPath) do if {   } then for HrefValue in ListValue.map(HrefXPath) do Writeln(HrefValue.toString); end. 

वर्तमान एपीआई डीएलएल के साथ ऐसा करना संभव है, लेकिन परिणामी की क्रियाशीलता पहले से ही बहुत अधिक है, जो न केवल कोड की पठनीयता को कम करती है, बल्कि (और कोई कम महत्वपूर्ण) इसे ऊपर से दूर नहीं ले जाती है:

 program InternetToolsUsage; ... const ArticleURL = 'https://habr.com/post/415617'; ListXPath = '//div[@class="post__body post__body_full"]//li[a]'; HrefXPath = './a/@href'; var RootHandle, ListHandle, HrefHandle: TXQHandle; I, J: Integer; begin RootHandle := OpenDocument(ArticleURL); try ListHandle := Map(RootHandle, ListXPath); try for I := 0 to Count(ListHandle) - 1 do if {   } then begin HrefHandle := Map(ListHandle, HrefXPath); try for J := 0 to Count(HrefHandle) - 1 do Writeln( ValueByIndex(HrefHandle, J) ); finally CloseHandle(HrefHandle); end; end; finally CloseHandle(ListHandle); end; finally CloseHandle(RootHandle); end; ReadLn; end. 

जाहिर है - वास्तविक, अधिक जटिल मामलों में, लेखन की मात्रा केवल तेजी से बढ़ेगी, और इसलिए हम ऐसे समाधान पर आगे बढ़ेंगे जो ऐसी समस्याओं से मुक्त है।

इंटरफ़ेस कार्यान्वयन

पुस्तकालय के साथ काम करने की प्रक्रियात्मक शैली, जैसा कि अभी दिखाया गया है, संभव है, लेकिन इसमें बहुत कमियां हैं। इस तथ्य के कारण कि इस तरह के DLL इंटरफेस के उपयोग का समर्थन करता है (जैसा कि प्राप्त और लौटाए गए डेटा प्रकार), आप InternetTools के साथ उसी सुविधाजनक तरीके से काम का आयोजन कर सकते हैं जैसे कि फ्री पास्कल के साथ इसका उपयोग करते समय। इस मामले में, अलग-अलग मॉड्यूल के लिए इंटरफेस की घोषणा और कार्यान्वयन को वितरित करने के लिए फाइलों की संरचना को थोड़ा बदलना वांछनीय है:


पहले की तरह, हम अनुक्रम में प्रत्येक फ़ाइलों की जांच करेंगे।

InternetTools.Types मॉड्यूल

डीएलएल में लागू किए जाने वाले इंटरफेस की घोषणा करता है:

 unit InternetTools.Types; {$IFDEF FPC} {$MODE Delphi} {$ENDIF} interface type IXQValue = interface; IXQValueEnumerator = interface ['{781B23DC-E8E8-4490-97EE-2332B3736466}'] function MoveNext: Boolean; safecall; function GetCurrent: IXQValue; safecall; property Current: IXQValue read GetCurrent; end; IXQValue = interface ['{DCE33144-A75F-4C53-8D25-6D9BD78B91E4}'] function GetEnumerator: IXQValueEnumerator; safecall; function OpenURL(const URL: WideString): IXQValue; safecall; function Map(const XQuery: WideString): IXQValue; safecall; function ToString: WideString; safecall; end; implementation end. }'] unit InternetTools.Types; {$IFDEF FPC} {$MODE Delphi} {$ENDIF} interface type IXQValue = interface; IXQValueEnumerator = interface ['{781B23DC-E8E8-4490-97EE-2332B3736466}'] function MoveNext: Boolean; safecall; function GetCurrent: IXQValue; safecall; property Current: IXQValue read GetCurrent; end; IXQValue = interface ['{DCE33144-A75F-4C53-8D25-6D9BD78B91E4}'] function GetEnumerator: IXQValueEnumerator; safecall; function OpenURL(const URL: WideString): IXQValue; safecall; function Map(const XQuery: WideString): IXQValue; safecall; function ToString: WideString; safecall; end; implementation end. }'] unit InternetTools.Types; {$IFDEF FPC} {$MODE Delphi} {$ENDIF} interface type IXQValue = interface; IXQValueEnumerator = interface ['{781B23DC-E8E8-4490-97EE-2332B3736466}'] function MoveNext: Boolean; safecall; function GetCurrent: IXQValue; safecall; property Current: IXQValue read GetCurrent; end; IXQValue = interface ['{DCE33144-A75F-4C53-8D25-6D9BD78B91E4}'] function GetEnumerator: IXQValueEnumerator; safecall; function OpenURL(const URL: WideString): IXQValue; safecall; function Map(const XQuery: WideString): IXQValue; safecall; function ToString: WideString; safecall; end; implementation end. 

डेल्फी और एफपीसी-परियोजनाओं दोनों में अपरिवर्तित मॉड्यूल के उपयोग के कारण सशर्त संकलन निर्देश आवश्यक हैं।

IXQValueEnumerator इंटरफ़ेस सिद्धांत रूप में वैकल्पिक है, हालांकि, उदाहरण के लिए " for ... in ... " फ़ॉर्म के लूप का उपयोग करने में सक्षम होने के लिए , आप इसके बिना नहीं कर सकते; दूसरा इंटरफ़ेस मुख्य है और InternetTools से IXQValue पर एक एनालॉग रैपर है (इसे विशेष रूप से इसी नाम से बनाया गया था ताकि भविष्य के डेल्फी कोड को फ्री पास्कल पर लाइब्रेरी डॉक्यूमेंटेशन के साथ सहसंबंधित करना आसान हो सके)। यदि हम मॉड्यूल को डिजाइन पैटर्न के संदर्भ में मानते हैं, तो इसमें घोषित इंटरफेस एडेप्टर हैं , हालांकि एक छोटी सी विशेषता के साथ - उनका कार्यान्वयन एक गतिशील पुस्तकालय में स्थित है।

सभी तरीकों के लिए safecall कॉल प्रकार सेट करने की आवश्यकता यहां अच्छी तरह से वर्णित है । "देशी" तारों के बजाय WideString का उपयोग करने की बाध्यता की पुष्टि नहीं की जाएगी, क्योंकि डीएलएल के साथ गतिशील डेटा संरचनाओं के आदान-प्रदान का विषय इस लेख के दायरे से बाहर है।

InternetTools.Realization मॉड्यूल

महत्व और मात्रा के मामले में पहला - यह वह है, जो शीर्षक में परिलक्षित होता है, इसमें पिछले एक से इंटरफेस का कार्यान्वयन शामिल होगा: उन दोनों के लिए एकमात्र TXQValue वर्ग को TXQValue , जिनमें से तरीके इतने सरल हैं कि लगभग सभी में एक पंक्ति का कोड होता है (यह काफी है। उम्मीद है, क्योंकि सभी आवश्यक कार्यक्षमता पहले से ही पुस्तकालय में निहित है - यहां आपको बस इसे एक्सेस करने की आवश्यकता है):

 unit InternetTools.Realization; {$MODE Delphi} interface uses xquery, InternetTools.Types; type IOriginalXQValue = xquery.IXQValue; TXQValue = class(TInterfacedObject, IXQValue, IXQValueEnumerator) private FOriginalXQValue: IOriginalXQValue; FEnumerator: TXQValueEnumerator; function MoveNext: Boolean; safecall; function GetCurrent: IXQValue; safecall; function GetEnumerator: IXQValueEnumerator; safecall; function OpenURL(const URL: WideString): IXQValue; safecall; function Map(const XQuery: WideString): IXQValue; safecall; function ToString: WideString; safecall; reintroduce; public constructor Create(const OriginalXQValue: IOriginalXQValue); overload; function SafeCallException(ExceptObject: TObject; ExceptAddr: CodePointer): HResult; override; end; implementation uses sysutils, comobj, w32internetaccess; function TXQValue.MoveNext: Boolean; begin Result := FEnumerator.MoveNext; end; function TXQValue.GetCurrent: IXQValue; begin Result := TXQValue.Create(FEnumerator.Current); end; function TXQValue.GetEnumerator: IXQValueEnumerator; begin FEnumerator := FOriginalXQValue.GetEnumerator; Result := Self; end; function TXQValue.OpenURL(const URL: WideString): IXQValue; begin FOriginalXQValue := xqvalue(URL).retrieve; Result := Self; end; function TXQValue.Map(const XQuery: WideString): IXQValue; begin Result := TXQValue.Create( FOriginalXQValue.map(XQuery) ); end; function TXQValue.ToString: WideString; begin Result := FOriginalXQValue.toJoinedString(LineEnding); end; constructor TXQValue.Create(const OriginalXQValue: IOriginalXQValue); begin FOriginalXQValue := OriginalXQValue; end; function TXQValue.SafeCallException(ExceptObject: TObject; ExceptAddr: CodePointer): HResult; begin Result := HandleSafeCallException(ExceptObject, ExceptAddr, GUID_NULL, ExceptObject.ClassName, ''); end; end. 

यह SafeCallException पद्धति पर रोक के लायक है - इसकी अवरोधन, द्वारा और बड़ी, महत्वपूर्ण नहीं है ( TXQValue प्रदर्शन TXQValue बिना प्रभावित नहीं होगा), हालांकि, यहां दिया गया कोड डेल्फी पक्ष के अपवाद पाठ को पारित करने की अनुमति देता है जो कि सुरक्षित तरीके (विवरण) में होगा फिर से, एक हालिया लेख में पाया जा सकता है)।

यह समाधान, सब कुछ के अलावा, धागा सुरक्षित है - बशर्ते कि IXQValue प्राप्त हुआ, उदाहरण के लिए, OpenURL माध्यम से, थ्रेड्स के बीच प्रेषित नहीं किया जाता है। यह इस तथ्य के कारण है कि इंटरफ़ेस का कार्यान्वयन केवल पहले से ही सुरक्षित इंटरनेटटल्स को कॉल करता है।

InternetTools डायनामिक लाइब्रेरी

उपरोक्त मॉड्यूल में किए गए कार्य के कारण, यह DLL के लिए एक फ़ंक्शन निर्यात करने के लिए पर्याप्त है (उस विकल्प के साथ तुलना करें जहां प्रक्रियात्मक शैली का उपयोग किया गया था):

 library InternetTools; uses InternetTools.Types, InternetTools.Realization; function GetXQValue: IXQValue; stdcall; begin Result := TXQValue.Create; end; exports GetXQValue; begin SetMultiByteConversionCodePage(CP_UTF8); end. 

SetMultiByteConversionCodePage प्रक्रिया के लिए कॉल को ठीक से यूनिकोड स्ट्रिंग्स के साथ काम करने के लिए डिज़ाइन किया गया है।

InternetToolsUsage अनुप्रयोग

यदि अब हम प्रस्तावित इंटरफेस के आधार पर प्रारंभिक उदाहरण के डेल्फी समाधान को औपचारिक रूप देते हैं, तो यह नि: शुल्क पास्कल पर शायद ही अलग होगा, जिसका अर्थ है कि लेख की शुरुआत में निर्धारित कार्य को पूरा किया जा सकता है:

 program InternetToolsUsage; ... uses System.Win.ComObj, InternetTools.Types; const DLLName = 'InternetTools.dll'; function GetXQValue: IXQValue; stdcall; external DLLName; const ArticleURL = 'https://habr.com/post/415617'; ListXPath = '//div[@class="post__body post__body_full"]//li[a]'; var ListValue: IXQValue; begin for ListValue in GetXQValue.OpenURL(ArticleURL).Map(ListXPath) do Writeln(ListValue.ToString); ReadLn; end. 

System.Win.ComObj मॉड्यूल गलती से जुड़ा नहीं है - इसके बिना, सभी सेफ़कॉल अपवादों का पाठ एक मुखर "सेफ़कॉल विधि में अपवाद" बन जाएगा, और इसके साथ डीएलएल में उत्पन्न मूल मूल्य।

इसी तरह थोड़ा जटिल उदाहरण डेल्फी पर न्यूनतम मतभेद हैं:

 ... const ArticleURL = 'https://habr.com/post/415617'; ListXPath = '//div[@class="post__body post__body_full"]//li[a]'; HrefXPath = './a/@href'; var ListValue, HrefValue: IXQValue; begin for ListValue in GetXQValue.OpenURL(ArticleURL).Map(ListXPath) do if {   } then for HrefValue in ListValue.Map(HrefXPath) do Writeln(HrefValue.ToString); ReadLn; end. 

पुस्तकालय की शेष कार्यक्षमता

यदि आप InternetTools से IXQValue इंटरफ़ेस की पूर्ण क्षमताओं को देखते हैं, तो आप देखेंगे कि InternetTools.Types से संबंधित इंटरफ़ेस संपूर्ण समृद्ध सेट से केवल 2 विधियाँ ( Map और ToString ) को परिभाषित करता है; बाकी को जोड़ना जो पाठक अपने विशेष मामले में आवश्यक समझता है, ठीक उसी तरह से और सरलता से किया जाता है: आवश्यक तरीके इंटरनेटटेल्स में लिखे गए हैं। इसके बाद वे इंटरनेटटैलस में बनाया गया है। कोड के साथ कोडांतरण मॉड्यूल (सबसे अधिक बार एक पंक्ति के रूप में)।

यदि आपको थोड़ी अलग कार्यक्षमता का उपयोग करने की आवश्यकता है, उदाहरण के लिए, कुकी प्रबंधन, चरणों का क्रम बहुत समान है:

1. InternetTools.Types में एक नया इंटरफ़ेस InternetTools.Types गया InternetTools.Types :
   
   

    ... ICookies = interface ['{21D0CC9A-204D-44D2-AF00-98E9E04412CD}'] procedure Add(const URL, Name, Value: WideString); safecall; procedure Clear; safecall; end; ... -AF00-98E9E04412CD}'] ... ICookies = interface ['{21D0CC9A-204D-44D2-AF00-98E9E04412CD}'] procedure Add(const URL, Name, Value: WideString); safecall; procedure Clear; safecall; end; ... 

2. फिर इसे InternetTools.Realization मॉड्यूल में लागू किया जाता है:
   
   

    ... type TCookies = class(TInterfacedObject, ICookies) private procedure Add(const URL, Name, Value: WideString); safecall; procedure Clear; safecall; public function SafeCallException(ExceptObject: TObject; ExceptAddr: CodePointer): HResult; override; end; ... implementation uses ..., internetaccess; ... procedure TCookies.Add(const URL, Name, Value: WideString); begin defaultInternet.cookies.setCookie( decodeURL(URL).host, decodeURL(URL).path, Name, Value, [] ); end; procedure TCookies.Clear; begin defaultInternet.cookies.clear; end; ... 

3. उसके बाद, एक नया निर्यात किया गया फ़ंक्शन DLL में लौटा है जो इस इंटरफ़ेस को लौटाता है:
   
   

    ... function GetCookies: ICookies; stdcall; begin Result := TCookies.Create; end; exports ..., GetCookies; ... 

संसाधनों की रिहाई

यद्यपि इंटरनेटटूल लाइब्रेरी उन इंटरफेस पर आधारित है जो स्वचालित रूप से जीवनकाल को नियंत्रित करते हैं, एक गैर-स्पष्ट अति सूक्ष्म अंतर है जो मेमोरी लीक को जन्म देगा - यदि आप अगला कंसोल एप्लिकेशन चलाते हैं (डेल्फी पर बनाया गया है, तो एफपीसी के मामले में कुछ भी नहीं बदलेगा), फिर हर बार जब आप एंटर कुंजी दबाते हैं, तो प्रक्रिया द्वारा खपत की गई मेमोरी बढ़ेगी:

 ... const ArticleURL = 'https://habr.com/post/415617'; TitleXPath = '//head/title'; var I: Integer; begin for I := 1 to 100 do begin Writeln( GetXQValue.OpenURL(ArticleURL).Map(TitleXPath).ToString ); Readln; end; end. 

यहां इंटरफेस के उपयोग के साथ कोई त्रुटि नहीं है। समस्या यह है कि InternetTools दस्तावेज़ के विश्लेषण के दौरान आवंटित अपने आंतरिक संसाधनों को जारी नहीं करता है ( OpenURL विधि में) - इसे काम पूरा होने के बाद स्पष्ट रूप से किया जाना चाहिए; इन उद्देश्यों के लिए, xquery लाइब्रेरी मॉड्यूल freeThreadVars प्रक्रिया प्रदान करता है, जिसमें डेल्फी एप्लिकेशन से कॉल को DLL निर्यात सूची का विस्तार करके तार्किक रूप से सुनिश्चित किया जा सकता है:

 ... procedure FreeResources; stdcall; begin freeThreadVars; end; exports ..., FreeResources; ... 

इसके उपयोग के बाद, संसाधनों का नुकसान बंद हो जाएगा:

 for I := 1 to 100 do begin Writeln( GetXQValue.OpenURL(ArticleURL).Map(TitleXPath).ToString ); FreeResources; Readln; end; 

निम्नलिखित को समझना महत्वपूर्ण है - FreeResources लिए एक कॉल इस तथ्य की ओर जाता है कि पहले प्राप्त सभी इंटरफेस अर्थहीन हो जाते हैं और उनका उपयोग करने का कोई भी प्रयास अस्वीकार्य है।