डेल्फी / लाजर के लिए tiOPF फ्रेमवर्क कैसे काम करता है। आगंतुक टेम्पलेट

अनुवादक से

दो कारण हैं कि मैंने बहुत लोकप्रिय प्रोग्रामिंग वातावरण के लिए बीस साल पहले विकसित ढांचे पर कई सामग्रियों का अनुवाद करने का उपक्रम किया:

1. कुछ साल पहले, .net प्लेटफॉर्म के लिए एक ORM के रूप में एंटिटी फ्रेमवर्क के साथ काम करने के कई प्रसन्नता के बारे में सीखा है, मैंने लाजर पर्यावरण के लिए एनालॉग्स के लिए व्यर्थ में खोजा और सामान्य तौर पर, फ़्रीस्केल के लिए।
हैरानी की बात है कि उसके लिए अच्छे ओआरएम गायब हैं। तब जो कुछ पाया गया था वह tiOPF नामक एक ओपन-सोर्स प्रोजेक्ट था, जिसे 90 के दशक के अंत में डेल्फी के लिए विकसित किया गया था, जिसे बाद में फ़्रीस्पैकल में लाया गया। हालांकि, यह ढांचा बड़े और मोटे ओआरएम के सामान्य रूप से मौलिक रूप से अलग है।

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

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

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

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

इसके अलावा, अनुवाद के लिए पाठ का बार-बार प्रूफरीडिंग आपको यह देखने की अनुमति देता है कि जब मैंने पहली बार प्रलेखन से मुलाकात की थी तो मुझे क्या याद आया था, मैं इसे पूरी तरह या सही ढंग से नहीं समझ पाया। यही है, यह खुद के लिए अध्ययन के तहत रूपरेखा को बेहतर ढंग से सीखने का अवसर है।

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

मैं पहले "व्हेल" के बारे में पीटर हेनरिक्सन के एक लेख से सामग्रियों का अनुवाद शुरू करना चाहता हूं, जिस पर पूरा ढांचा खड़ा है - विज़िटर टेम्पलेट। मूल पाठ यहाँ पोस्ट किया गया ।

आगंतुक और tiOPF टेम्पलेट

इस लेख का उद्देश्य विज़िटर टेम्पलेट को पेश करना है, जिसका उपयोग tiOPF (TechInsite Object Persistence Framework) फ्रेमवर्क की मुख्य अवधारणाओं में से एक है। हम विज़िटर का उपयोग करने से पहले वैकल्पिक समाधानों के विश्लेषण के बाद समस्या पर विस्तार से विचार करेंगे। अपने स्वयं के आगंतुक अवधारणा को विकसित करने की प्रक्रिया में, हम एक और चुनौती का सामना करेंगे: संग्रह में सभी वस्तुओं के माध्यम से पुनरावृति की आवश्यकता। इस मुद्दे का भी अध्ययन किया जाएगा।

मुख्य कार्य संग्रह में कुछ वस्तुओं पर संबंधित तरीकों का एक सेट करने के लिए एक सामान्यीकृत तरीके से आना है। प्रदर्शन किए गए तरीके वस्तुओं की आंतरिक स्थिति के आधार पर भिन्न हो सकते हैं। हम तरीकों को बिल्कुल भी निष्पादित नहीं कर सकते हैं, लेकिन हम एक ही ऑब्जेक्ट पर कई तरीकों को निष्पादित कर सकते हैं।

प्रशिक्षण का आवश्यक स्तर

पाठक को ऑब्जेक्ट पास्कल से परिचित होना चाहिए और ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के बुनियादी सिद्धांतों में मास्टर करना चाहिए।

इस लेख में उदाहरण के लिए व्यावसायिक कार्य

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

प्रस्तुति स्तर पर, हमारे एप्लिकेशन को एक्सप्लोरर / आउटलुक की तरह दिखना चाहिए, अर्थात, ट्रीव्यू और लिस्ट व्यू जैसे मानक घटकों का उपयोग करना चाहिए। एप्लिकेशन को तेज़ी से काम करना चाहिए और भारी ग्राहक-सर्वर सॉफ़्टवेयर की छाप नहीं देनी चाहिए।

एक आवेदन कुछ इस तरह लग सकता है:



पेड़ के संदर्भ मेनू में, आप किसी व्यक्ति या कंपनी के संपर्क को जोड़ने / हटाने और संपर्क डेटा सूची पर राइट-क्लिक कर सकते हैं ताकि उन्हें संपादित करने, हटाने या डेटा जोड़ने के लिए संवाद खोलें।

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

शुरू करने से पहले

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

एक नया एप्लिकेशन बनाएं और मुख्य मॉड्यूल के इंटरफ़ेस सेक्शन के दो वर्गों को जोड़ें: TPersonList (TobjectList से विरासत में मिला और कॉन्ट्रास मॉड्यूल में प्लग-इन की आवश्यकता होती है) और TPerson (TObject से विरासत में मिला):

TPersonList = class(TObjectList)  public    constructor Create;  end;  TPerson = class(TObject)  private    FEMailAdrs: string;    FName: string;  public    property Name: string read FName write FName;    property EMailAdrs: string read FEMailAdrs write FEMailAdrs;  end; 

टीपर्सनलिस्ट कंस्ट्रक्टर में, हम तीन टीपर्सन ऑब्जेक्ट बनाते हैं और सूची में जोड़ते हैं:

 constructor TPersonList.Create; var lData: TPerson; begin inherited; lData := TPerson.Create; lData.Name := 'Malcolm Groves'; lData.EMailAdrs := 'malcolm@dontspamme.com';  // (ADUG Vice President) Add(lData); lData := TPerson.Create; lData.Name := 'Don MacRae';  // (ADUG President) lData.EMailAdrs := 'don@dontspamme.com'; Add(lData); lData := TPerson.Create; lData.Name := 'Peter Hinrichsen';  // (Yours truly) lData.EMailAdrs := 'peter_hinrichsen@dontspamme.com'; Add(lData); end; 

सबसे पहले, हम सूची के माध्यम से जाएंगे और सूची के प्रत्येक तत्व पर दो ऑपरेशन करेंगे। ऑपरेशन समान हैं, लेकिन समान नहीं हैं: टीपर्सन ऑब्जेक्ट्स के नाम और EmailAdrs गुणों की सामग्री को प्रदर्शित करने के लिए एक सरल शोमेसेज कॉल। फ़ॉर्म में दो बटन जोड़ें और उन्हें कुछ इस तरह नाम दें:



अपने फॉर्म के पसंदीदा दायरे में, आपको एक संपत्ति (या सिर्फ एक फ़ील्ड) टाइपर्स की सूची से जोड़ना चाहिए।

 FPersonList := TPersonList.Create; 

फॉर्म के ऑनक्लास इवेंट हैंडलर में ठीक से मुक्त मेमोरी के लिए, इस ऑब्जेक्ट को नष्ट किया जाना चाहिए:

 FPersonList.Free. 

चरण 1. हार्डकोड Iteration

टीपर्सन ऑब्जेक्ट्स से नाम दिखाने के लिए, पहले बटन के ऑनक्लिक इवेंट हैंडलर में निम्न कोड जोड़ें:

 procedure TForm1.Button1Click(Sender: TObject); var i: integer; begin for i := 0 to FPersonList.Count - 1 do   ShowMessage(TPerson(FPersonList.Items[i]).Name); end; 

दूसरे बटन के लिए, हैंडलर कोड इस प्रकार होगा:

 procedure TForm1.Button2Click(Sender: TObject); var i: integer; begin for i := 0 to FPersonList.Count - 1 do   ShowMessage(TPerson(FPersonList.Items[i]).EMailAdrs); end; 

इस कोड के स्पष्ट विवरण इस प्रकार हैं:

• दो तरीके जो लगभग एक ही काम करते हैं। सभी अंतर केवल उस वस्तु की संपत्ति के नाम पर है जो वे दिखाते हैं;
  
• पुनरावृति थकाऊ होगी, खासकर जब आपको कोड में सौ स्थानों पर एक समान लूप लिखने के लिए मजबूर किया जाता है;
  
• टीपर्सन के लिए एक कठिन कलाकार असाधारण स्थितियों से भरा है। क्या होगा यदि एक पते की संपत्ति के बिना सूची में TAnimal का उदाहरण है? इस कोड में त्रुटि को रोकने और इसके खिलाफ बचाव के लिए कोई तंत्र नहीं है।
  

आइए जानें कि एक अमूर्तता का परिचय देकर कोड को कैसे बेहतर बनाया जाए: हम पेरेंट क्लास को पुनरावृति कोड पास करते हैं।

चरण 2. पुनरावृत्त को सार

इसलिए, हम पुनरावृति तर्क को आधार वर्ग में ले जाना चाहते हैं। सूची पुनरावृति स्वयं बहुत सरल है:

 for i := 0 to FList.Count - 1 do // -    … 

ऐसा लगता है कि हम एक Iterator टेम्पलेट का उपयोग करने की योजना बना रहे हैं। गैंग-ऑफ-फोर डिज़ाइन पैटर्न की किताब से , यह ज्ञात है कि Iterator बाहरी और आंतरिक हो सकता है। बाहरी पुनरावृत्ति का उपयोग करते समय, क्लाइंट नेक्स्ट मेथड (उदाहरण के लिए, TCollection तत्वों की गणना को फर्स्ट, नेक्स्ट, लास्ट मेथड्स) द्वारा नियंत्रित करके स्पष्ट रूप से ट्रैवर्सल को नियंत्रित करता है। हम यहां आंतरिक सूचना विज्ञान का उपयोग करेंगे, क्योंकि इसकी मदद से ट्री ट्रैवर्सल लागू करना आसान है, जो हमारा लक्ष्य है। हम अपनी सूची वर्ग में Iterate विधि जोड़ देंगे और इसके लिए एक कॉलबैक विधि पारित करेंगे, जिसे सूची के प्रत्येक तत्व पर किया जाना चाहिए। ऑब्जेक्ट पास्कल में कॉलबैक एक प्रक्रियात्मक प्रकार के रूप में घोषित किया गया है, हमारे पास, उदाहरण के लिए, TDoSomethingToAPerson होगा।

तो, हम एक प्रक्रियात्मक प्रकार की घोषणा करते हैं TDoSomethingToAPerson, जो कि टाइपर्सन के एक पैरामीटर को लेता है। प्रक्रियात्मक प्रकार आपको किसी अन्य विधि के पैरामीटर के रूप में विधि का उपयोग करने की अनुमति देता है, अर्थात् कॉलबैक को लागू करता है। इस तरह, हम दो तरीके बनाएंगे, जिनमें से एक ऑब्जेक्ट का नाम गुण दिखाएगा, और दूसरा - ईमेल एड्रैस संपत्ति, और वे स्वयं सामान्य पुनरावृत्ति के पैरामीटर के रूप में पारित हो जाएंगे। अंत में, प्रकार घोषणा अनुभाग इस तरह दिखना चाहिए:

 { TPerson } TPerson = class(TObject) private   FEMailAdrs: string;   FName: string; public   property Name: string read FName write FName;   property EMailAdrs: string read FEMailAdrs write FEMailAdrs; end; TDoSomethingToAPerson = procedure(const pData: TPerson) of object; { TPersonList } TPersonList = class(TObjectList) public   constructor Create;   procedure   DoSomething(pMethod: TDoSomethingToAPerson); end;   DoSomething: procedure TPersonList.DoSomething(pMethod: TDoSomethingToAPerson); var i: integer; begin for i := 0 to Count - 1 do   pMethod(TPerson(Items[i])); end; 

अब, सूची मदों पर आवश्यक कार्रवाई करने के लिए, हमें दो चीजें करने की आवश्यकता है। सबसे पहले, उन तरीकों का उपयोग करके आवश्यक संचालन का निर्धारण करने के लिए जो कि TDoSomethingToAPerson द्वारा निर्दिष्ट हस्ताक्षर का उपयोग करते हैं, और दूसरा, पैरामीटर के रूप में इन विधियों को पॉइंटर्स के हस्तांतरण के साथ DoSomething कॉल लिखने के लिए। प्रपत्र विवरण अनुभाग में, दो घोषणाएँ जोड़ें:

 private   FPersonList: TPersonList;   procedure DoShowName(const pData: TPerson);   procedure DoShowEmail(const pData: TPerson); 

इन विधियों के कार्यान्वयन में, हम संकेत देते हैं:

 procedure TForm1.DoShowName(const pData: TPerson); begin ShowMessage(pData.Name); end; procedure TForm1.DoShowEmail(const pData: TPerson); begin ShowMessage(pData.EMailAdrs); end; 

बटन संचालकों के लिए कोड निम्नानुसार बदला गया है:

 procedure TForm1.Button1Click(Sender: TObject); begin FPersonList.DoSomething(@DoShowName); end; procedure TForm1.Button2Click(Sender: TObject); begin FPersonList.DoSomething(@DoShowEmail); end; 

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

यह कल्पना करना आसान है कि ShowMessage को कॉल कोड के साथ कैसे बदला जा सकता है जो कि टीपीआई ऑब्जेक्ट के एसक्यूएल क्वेरी का उपयोग करके एक रिलेशनल डेटाबेस में टीपर्सन से हमारे डेटा को बचाता है। उदाहरण के लिए, इस तरह:

 procedure TForm1.SavePerson(const pData: TPerson); var lQuery: TQuery; begin lQuery := TQuery.Create(nil); try   lQuery.SQL.Text := 'insert into people values (:Name, :EMailAdrs)';   lQuery.ParamByName('Name').AsString := pData.Name;   lQuery.ParamByName('EMailAdrs').AsString := pData.EMailAdrs;   lQuery.Datababase := gAppDatabase;   lQuery.ExecSQL; finally   lQuery.Free; end; end; 

वैसे, यह डेटाबेस से कनेक्शन बनाए रखने की एक नई समस्या का परिचय देता है। हमारे अनुरोध में, डेटाबेस का कनेक्शन कुछ वैश्विक gAppDatabase ऑब्जेक्ट के माध्यम से किया जाता है। लेकिन यह कहाँ स्थित होगा और कैसे काम करना है? इसके अलावा, हमें TQuery ऑब्जेक्ट बनाने, कनेक्शन को कॉन्फ़िगर करने, क्वेरी को निष्पादित करने और मेमोरी को खाली करने के लिए मत भूलना, इट्रेटर के प्रत्येक चरण पर पीड़ा दी जाती है। इस कोड को एक वर्ग में लपेटना बेहतर होगा जो SQL प्रश्नों को बनाने और निष्पादित करने के तर्क को कूटबद्ध करता है, साथ ही डेटाबेस से कनेक्शन स्थापित करने और बनाए रखने के लिए।

चरण 3. एक कॉलबैक के लिए पॉइंटर को पास करने के बजाय एक ऑब्जेक्ट पास करना

ऑब्जेक्ट को बेस क्लास के इट्रेटर विधि में पास करने से राज्य रखरखाव की समस्या हल हो जाएगी। हम एक एकल निष्पादित विधि के साथ एक अमूर्त आगंतुक वर्ग TPersonVisitor बनायेंगे और इस विधि को एक पैरामीटर के रूप में पास करेंगे। सार विज़िटर इंटरफ़ेस नीचे प्रस्तुत किया गया है:

   TPersonVisitor = class(TObject) public   procedure Execute(pPerson: TPerson); virtual; abstract; end; 

इसके बाद, हमारे TPersonList वर्ग में Iterate विधि जोड़ें:

 TPersonList = class(TObjectList) public   constructor Create;   procedure Iterate(pVisitor: TPersonVisitor); end; 

इस विधि का कार्यान्वयन निम्नानुसार होगा:

 procedure TPersonList.Iterate(pVisitor: TPersonVisitor); var i: integer; begin for i := 0 to Count - 1 do   pVisitor.Execute(TPerson(Items[i])); end; 

TPersonVisitor वर्ग के कार्यान्वित विज़िटर का एक ऑब्जेक्ट Iterate पद्धति से पास किया जाता है, और जब उनमें से प्रत्येक के लिए सूची आइटम के माध्यम से पुनरावृत्ति होती है, तो निर्दिष्ट Visitor (इसकी निष्पादित विधि) को एक पैरामीटर के रूप में TPerson उदाहरण के साथ कहा जाता है।

आइए आगंतुक - TShowNameVisitor और TShowEmailVistor के दो कार्यान्वयन बनाएं, जो आवश्यक कार्य करेंगे। मॉड्यूल इंटरफ़ेस अनुभाग को फिर से भरने का तरीका यहां दिया गया है:

 { TShowNameVisitor } TShowNameVisitor = class(TPersonVisitor) public   procedure Execute(pPerson: TPerson); override; end; { TShowEmailVisitor } TShowEmailVisitor = class(TPersonVisitor) public   procedure Execute(pPerson: TPerson); override; end; 

सादगी के लिए, उन पर निष्पादन विधियों का कार्यान्वयन अभी भी एक ही पंक्ति होगी - ShowMessage (pPerson.Name) और ShowMessage (pPerson.EMailAdrs)।

और बटन क्लिक हैंडलर के लिए कोड बदलें:

 procedure TForm1.Button1Click(Sender: TObject); var lVis: TPersonVisitor; begin lVis := TShowNameVisitor.Create; try   FPersonList.Iterate(lVis); finally   lVis.Free; end; end; procedure TForm1.Button2Click(Sender: TObject); var lVis: TPersonVisitor; begin lVis := TShowEmailVisitor.Create; try   FPersonList.Iterate(lVis); finally   lVis.Free; end; end; 

अब, एक समस्या को हल करने के बाद, हमने अपने लिए एक और निर्माण किया। इटरेटर तर्क एक अलग वर्ग में समझाया गया है; पुनरावृत्ति के दौरान किए गए संचालन को ऑब्जेक्ट्स में लपेटा जाता है, जो हमें राज्य के बारे में कुछ जानकारी सहेजने की अनुमति देता है, लेकिन कोड का आकार एक पंक्ति (FPersonList.DoSomething (@DoShowName) से बढ़ा है; प्रत्येक बटन हैंडलर के लिए नौ लाइनें हैं। अब यह हमारी मदद करेगा - यह आगंतुकों का प्रबंधक है, जो अपनी प्रतियों को बनाने और मुक्त करने का ध्यान रखेगा। इसके अलावा, हम पुनरावृत्ति के दौरान वस्तुओं के साथ कई कार्यों के लिए प्रदान कर सकते हैं, इसके लिए आगंतुक प्रबंधक अपनी सूची को संग्रहीत करेगा और हर कदम पर इसे पार करेगा, आप । Olnyaya केवल चयनित संचालन अगला स्पष्ट रूप से इस दृष्टिकोण के लाभ का प्रदर्शन करेंगे, हम के रूप में एक सरल ऑपरेशन बचत डेटा तीन अलग-अलग ऑपरेटरों एसक्यूएल द्वारा किया जा सकता है एक संबंधपरक डेटाबेस में डेटा को बचाने के लिए आगंतुकों का उपयोग करेगा: बनाएं, हटाने और अपडेट।

चरण 4. आगंतुक का और अधिक एनकैप्सुलेशन

आगे बढ़ने से पहले, हमें विज़िटर के काम के तर्क को अलग करना चाहिए, इसे एप्लिकेशन के व्यावसायिक तर्क से अलग करना चाहिए ताकि यह उस पर वापस न आए। ऐसा करने के लिए हमें तीन कदम उठाने होंगे: बेस क्लासेस TVisited और TVisitor, फिर बेस क्लास बिज़नेस ऑब्जेक्ट और बिज़नेस ऑब्जेक्ट्स के कलेक्शन के लिए बनाएं, फिर हमारी विशिष्ट क्लासेस TPerson और TPersonList (या TP People) को थोड़ा एडजस्ट करें, ताकि वे बनाए गए बेस के वारिस बनें। कक्षाएं। सामान्य शब्दों में, वर्गों की संरचना ऐसे आरेख के अनुरूप होगी:



TVisitor ऑब्जेक्ट दो विधियों को लागू करता है: AcceptVisitor फ़ंक्शन और निष्पादित प्रक्रिया, जिसमें TVisited प्रकार ऑब्जेक्ट पास किया गया है। TVisited ऑब्जेक्ट, बदले में, टाइप TVisitor के एक पैरामीटर के साथ Iterate विधि को लागू करता है। यही है, TVisited.Iterate स्थानांतरित TVisitor ऑब्जेक्ट पर निष्पादित विधि को कॉल करना चाहिए, एक पैरामीटर के रूप में अपने स्वयं के उदाहरण के लिए एक लिंक भेज रहा है, और यदि उदाहरण एक संग्रह है, तो Execute विधि को संग्रह में प्रत्येक तत्व के लिए कहा जाता है। जब हम एक सामान्यीकृत प्रणाली विकसित कर रहे हैं तब AcceptVisitor फ़ंक्शन आवश्यक है। विज़िटर को पास करना संभव होगा, जो केवल उदाहरण के लिए, टोडोग वर्ग के उदाहरण, टीपर्सन प्रकारों के साथ संचालित होता है, और अपवादों को रोकने और टाइप बेमेल के कारण त्रुटियों तक पहुंचने के लिए एक तंत्र होना चाहिए। TVisited Class, TPersistent Class का वंशज है, थोड़ी देर बाद हमें RTTI के उपयोग से संबंधित कार्यों को लागू करने की आवश्यकता होगी।

मॉड्यूल का इंटरफ़ेस भाग अब इस तरह होगा:

 TVisited = class; { TVisitor } TVisitor = class(TObject) protected   function AcceptVisitor(pVisited: TVisited): boolean; virtual; abstract; public   procedure Execute(pVisited: TVisited); virtual; abstract; end; { TVisited } TVisited = class(TPersistent) public   procedure Iterate(pVisitor: TVisitor); virtual; end; 

TVisitor सार वर्ग के तरीके वारिस द्वारा लागू किए जाएंगे, और TVisited के लिए Iterate पद्धति का सामान्य कार्यान्वयन नीचे दिया गया है:

 procedure TVisited.Iterate(pVisitor: TVisitor); begin pVisitor.Execute(self); end; 

इसी समय, वारिस में इसके ओवरराइड की संभावना के लिए विधि को आभासी घोषित किया जाता है।

चरण 5. एक साझा व्यावसायिक वस्तु और संग्रह बनाएं

हमारे ढांचे को दो और आधार वर्गों की आवश्यकता है: एक व्यावसायिक वस्तु और ऐसी वस्तुओं के संग्रह को परिभाषित करने के लिए। उन्हें TtiObject और TtiObjectList कहें। उनमें से पहले का इंटरफ़ेस:

 TtiObject = class(TVisited) public   constructor Create; virtual; end; 

बाद में विकास की प्रक्रिया में, हम इस वर्ग को जटिल करेंगे, लेकिन वर्तमान कार्य के लिए, वारिस में इसे ओवरराइड करने की संभावना के साथ केवल एक आभासी निर्माता पर्याप्त है।

हमारे पास पूर्वजों द्वारा लागू किए गए तरीकों में व्यवहार का उपयोग करने के लिए TVisited से TtiObjectList वर्ग उत्पन्न करने की योजना है (इसके स्थान पर चर्चा की जाने वाली इस विरासत के अन्य कारण भी हैं)। इसके अलावा, कुछ भी अमूर्त वर्गों के बजाय इंटरफेस (इंटरफेस) के उपयोग को प्रतिबंधित नहीं करता है।

TtiObjectList वर्ग का इंटरफ़ेस भाग निम्नानुसार होगा:

 TtiObjectList = class(TtiObject) private   FList: TObjectList; public   constructor Create; override;   destructor Destroy; override;   procedure Clear;   procedure Iterate(pVisitor: TVisitor); override;   procedure Add(pData: TObject); end; 

जैसा कि आप देख सकते हैं, ऑब्जेक्ट तत्वों के साथ कंटेनर स्वयं संरक्षित अनुभाग में स्थित है और इस वर्ग के ग्राहकों के लिए उपलब्ध नहीं होगा। कक्षा का सबसे महत्वपूर्ण हिस्सा ओवररेटेड Iterate पद्धति का कार्यान्वयन है। यदि आधार वर्ग में विधि को बस pVisitor.Execute (स्व) कहा जाता है, तो यहां कार्यान्वयन सूची को मानने के साथ जुड़ा हुआ है:

 procedure TtiObjectList.Iterate(pVisitor: TVisitor); var i: integer; begin inherited Iterate(pVisitor); for i := 0 to FList.Count - 1 do   (FList.Items[i] as TVisited).Iterate(pVisitor); end; 

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

 Create: FList := TObjectList.Create; Destroy: FList.Free; Clear: if Assigned(FList) then FList.Clear; Add: if Assigned(FList) then FList.Add(pData); 

यह पूरी प्रणाली का एक महत्वपूर्ण हिस्सा है। हमारे पास व्यापार तर्क के दो मूल वर्ग हैं: TtiObject और TtiObjectList। दोनों के पास एक इरेटेट विधि है जिसके लिए TVisited क्लास का एक उदाहरण पारित किया गया है। पुनरावृत्तिकर्ता TVisitor वर्ग की Execute विधि को कॉल करता है और ऑब्जेक्ट के लिए एक संदर्भ देता है। यह कॉल विरासत के शीर्ष स्तर पर वर्ग व्यवहार में पूर्वनिर्धारित है। एक कंटेनर वर्ग के लिए, सूची में संग्रहीत प्रत्येक ऑब्जेक्ट की अपनी Iterate विधि भी होती है, जिसे टाइप टीवीसिटर के एक पैरामीटर के साथ कहा जाता है, अर्थात यह गारंटी है कि प्रत्येक विशिष्ट विज़िटर सूची में संग्रहीत सभी वस्तुओं को बायपास करेगा, साथ ही सूची को कंटेनर ऑब्जेक्ट के रूप में भी।

चरण 6. एक आगंतुक प्रबंधक बनाना

इसलिए, उस समस्या पर वापस जाएं जिसे हम खुद तीसरे चरण पर आकर्षित करते हैं। चूंकि हम हर बार विज़िटर की प्रतियाँ बनाना और उन्हें नष्ट नहीं करना चाहते हैं, इसलिए प्रबंधक का विकास इसका समाधान होगा। इसे दो मुख्य कार्य करने चाहिए: विज़िटर की सूची (जो कि व्यक्तिगत मॉड्यूल के आरंभीकरण अनुभाग में पंजीकृत हैं) को प्रबंधित करें और क्लाइंट से उपयुक्त कमांड प्राप्त होने पर उन्हें चलाएं।
प्रबंधक को लागू करने के लिए, हम अपने मॉड्यूल को तीन अतिरिक्त कक्षाओं के साथ पूरक करेंगे: TVisClassRef, TVisMapping और TtiVisitorManager।

 TVisClassRef = class of TVisitor; 

TVisClassRef एक संदर्भ प्रकार है और एक विशेष वर्ग के नाम को इंगित करता है - TVisitor का वंशज। एक संदर्भ प्रकार का उपयोग करने का अर्थ इस प्रकार है: जब हस्ताक्षर के साथ आधार निष्पादन विधि कहा जाता है

 procedure Execute(const pData: TVisited; const pVisClass: TVisClassRef), 

आंतरिक रूप से, यह विधि किसी विशिष्ट विज़िटर का उदाहरण बनाने के लिए lVisitor: = pVisClass.Create जैसी अभिव्यक्ति का उपयोग कर सकती है, पहले इसके प्रकार के बारे में जाने बिना। यही है, किसी भी वर्ग - टीवीसिटर का वंशज गतिशील रूप से एक ही निष्पादन विधि के अंदर बनाया जा सकता है जब एक पैरामीटर के रूप में अपनी कक्षा का नाम गुजरता है।

दूसरी श्रेणी, TVisMapping, दो गुणों के साथ एक सरल डेटा संरचना है: प्रकार TVisClassRef और एक स्ट्रिंग प्रॉपर्टी कमांड का संदर्भ। उनके नाम (एक कमांड, उदाहरण के लिए, "सहेजें") और विज़िटर वर्ग द्वारा किए गए संचालन की तुलना करने के लिए एक वर्ग की आवश्यकता होती है, जिसे ये कमांड निष्पादित करते हैं। प्रोजेक्ट में इसका कोड जोड़ें:

 TVisMapping = class(TObject) private   FCommand: string;   FVisitorClass: TVisClassRef; public   property VisitorClass: TVisClassRef read FVisitorClass write FVisitorClass;   property Command: string read FCommand write FCommand; end; 

और अंतिम वर्ग TtiVisitorManager है। जब हम प्रबंधक का उपयोग करके आगंतुक को पंजीकृत करते हैं, तो TVisMapping वर्ग का एक उदाहरण बनाया जाता है, जिसे प्रबंधक सूची में दर्ज किया जाता है।
इस प्रकार, प्रबंधक में, आगंतुकों की एक सूची एक स्ट्रिंग कमांड मिलान के साथ बनाई जाती है, जिसके प्राप्त होने पर उन्हें निष्पादित किया जाएगा। वर्ग इंटरफ़ेस मॉड्यूल में जोड़ा जाता है:

 TtiVisitorManager = class(TObject) private   FList: TObjectList; public   constructor Create;   destructor Destroy; override;   procedure RegisterVisitor(const pCommand: string; pVisitorClass: TVisClassRef);   procedure Execute(const pCommand: string; pData: TVisited); end; 

इसकी प्रमुख विधियाँ हैं- RegisterVisitor और Execute। पहले एक को आमतौर पर मॉड्यूल के आरंभीकरण अनुभाग में कहा जाता है, जो आगंतुक वर्ग का वर्णन करता है, और कुछ इस तरह दिखता है:

 initialization  gTIOPFManager.VisitorManager.RegisterVisitor('show', TShowNameVisitor);  gTIOPFManager.VisitorManager.RegisterVisitor('show', TShowEMailAdrsVisitor); 

विधि का कोड स्वयं इस प्रकार होगा:

 procedure TtiVisitorManager.RegisterVisitor(const pCommand: string; pVisitorClass: TVisClassRef); var lData: TVisMapping; begin lData := TVisMapping.Create; lData.Command := pCommand; lData.VisitorClass := pVisitorClass; FList.Add(lData); end; 

यह नोटिस करना मुश्किल नहीं है कि यह कोड फ़ैक्टरी टेम्पलेट के पास्कल कार्यान्वयन के समान है।

एक अन्य महत्वपूर्ण एक्सक्यूट विधि दो मापदंडों को लेती है: वह कमांड जिसके द्वारा विजिटर या समूह की पहचान की जानी है, साथ ही डेटा ऑब्जेक्ट जिसकी Iterate विधि वांछित विज़िटर के उदाहरण के लिंक के साथ कहा जाएगा। Execute पद्धति का पूरा कोड नीचे दिया गया है:

 procedure TtiVisitorManager.Execute(const pCommand: string; pData: TVisited); var i: integer; lVisitor: TVisitor; begin for i := 0 to FList.Count - 1 do   if SameText(pCommand, TVisMapping(FList.Items[i]).Command) then   begin     lVisitor := TVisMapping(FList.Items[i]).VisitorClass.Create;     try       pData.Iterate(lVisitor);     finally       lVisitor.Free;     end;   end; end; 

इस प्रकार, एक टीम के साथ पहले से पंजीकृत दो आगंतुकों को चलाने के लिए, हमें कोड की केवल एक पंक्ति की आवश्यकता है:

 gTIOPFManager.VisitorManager.Execute('show', FPeople); 

अगला, हम अपनी परियोजना को पूरक करेंगे ताकि आप समान आदेशों को कॉल कर सकें:

 //      gTIOPFManager.VisitorManager.Execute('read', FPeople); //      gTIOPFManager.VisitorManager.Execute('save', FPeople). 

चरण 7. व्यापार तर्क कक्षाएं समायोजित करना

हमारे टीपर्सन और टीपी लोगों की व्यावसायिक वस्तुओं के लिए TtiObject और TtiObjectList वर्गों के पूर्वजों को जोड़ने से हम बेस क्लास में इटेरिक लॉजिक को इनकैप्सुलेट कर पाएंगे और इसे स्पर्श नहीं करेंगे, इसके अलावा, विज़िटर मैनेजर को डेटा के साथ ऑब्जेक्ट ट्रांसफर करना संभव हो जाता है।

नए कंटेनर वर्ग की घोषणा इस तरह दिखाई देगी:

 TPeople = class(TtiObjectList); 

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

 Result := pVisited is TPeople. 

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

 TPerson = class(TtiObject) private   FEMailAdrs: string;   FName: string; published   property Name: string read FName write FName;   property EMailAdrs: string read FEMailAdrs write FEMailAdrs; end; 

चरण 8. एक प्रोटोटाइप दृश्य बनाएं

रिमार्क । मूल लेख में, जीयूआई उन घटकों पर आधारित था जो tiOPF लेखक ने अपने डेल्फी ढांचे के साथ काम करने की सुविधा के लिए बनाया था। ये डीबी अवेयर घटकों के एनालॉग थे, जो मानक नियंत्रण जैसे लेबल, इनपुट फ़ील्ड, चेकबॉक्स, सूची इत्यादि थे, लेकिन साथ ही साथ tiObject ऑब्जेक्ट्स के कुछ गुणों के साथ-साथ डेटाबेस तालिकाओं के क्षेत्रों से जुड़े डेटा डिस्प्ले घटकों के साथ जुड़े थे। समय के साथ, फ्रेमवर्क के लेखक ने इन दृश्य घटकों के साथ पैकेजों को अप्रचलित और अवांछनीय के रूप में चिह्नित किया।बदले में, वह मध्यस्थ घटक पैटर्न का उपयोग करके दृश्य घटकों और वर्ग गुणों के बीच एक लिंक बनाने का सुझाव देता है। यह खाका फ्रेमवर्क की पूरी वास्तुकला में दूसरा सबसे महत्वपूर्ण है। मध्यस्थ के लेखक का विवरण एक अलग लेख द्वारा कवर किया गया है, इस मैनुअल की मात्रा के बराबर है, इसलिए मैं अपने सरलीकृत संस्करण को यहां जीयूआई के रूप में पेश करता हूं।

"कमांड दिखाएँ" के लिए प्रोजेक्ट फॉर्म पर बटन 1 का नाम बदलें, और बटन 2 या तो इसे अब हैंडलर के बिना छोड़ दें, या तुरंत इसे "सेव कमांड" नाम दें। प्रपत्र पर एक ज्ञापन घटक फेंक दें और अपने स्वाद के लिए सभी तत्वों को रखें।

एक विज़िटर वर्ग जोड़ें जो शो कमांड को लागू करेगा:

इंटरफ़ेस -

 TShowVisitor = class(TVisitor) protected   function AcceptVisitor(pVisited: TVisited): boolean; override; public   procedure Execute(pVisited: TVisited); override; end; 

और कार्यान्वयन है -

 function TShowVisitor.AcceptVisitor(pVisited: TVisited): boolean; begin Result := (pVisited is TPerson); end; procedure TShowVisitor.Execute(pVisited: TVisited); begin if not AcceptVisitor(pVisited) then   exit; Form1.Memo1.Lines.Add(TPerson(pVisited).Name + ': ' + TPerson(pVisited).EMailAdrs); end; 

AcceptVisitor पुष्टि करता है कि स्थानांतरित की जा रही वस्तु TPerson का एक उदाहरण है, क्योंकि आगंतुक को केवल ऐसी वस्तुओं के साथ कमांड निष्पादित करना चाहिए। यदि प्रकार मेल खाता है, तो कमांड को निष्पादित किया जाता है और टेक्स्ट फ़ील्ड में ऑब्जेक्ट गुण वाली एक पंक्ति जोड़ी जाती है।

कोड के स्वास्थ्य के लिए सहायक क्रियाएं इस प्रकार होंगी। निजी अनुभाग में फॉर्म के विवरण के लिए दो गुणों को जोड़ें: टाइप टीपीआई और वीपी के प्रकार TtiVisitorManager के एफपीआई। फॉर्म क्रिएशन इवेंट हैंडलर में, हमें इन गुणों को शुरू करने की आवश्यकता है, साथ ही आगंतुक को "शो" कमांड के साथ रजिस्टर करना होगा:

 FPeople := TPeople.Create; FillPeople; VM := TtiVisitorManager.Create; VM.RegisterVisitor('show',TShowVisitor); 

FilPeople भी तीन वस्तुओं के साथ एक सूची भरने वाली एक सहायक प्रक्रिया है, इसका कोड पिछली सूची के निर्माणकर्ता से लिया गया है। सभी बनाई गई वस्तुओं को नष्ट करने के लिए मत भूलना। इस मामले में, हम एफपीसी लोगों को लिखते हैं। नि: शुल्क और हैंडलर के रूप में VM.Free।

और अब - बैम! - पहले बटन का हैंडलर:

 Memo1.Clear; VM.Execute('show',FPeople); 

सहमत हूँ, इतना अधिक मज़ा। और एक मॉड्यूल में सभी वर्गों के हैश की कसम मत खाओ। मैनुअल के बहुत अंत में, हम इन मलबे को रेक करेंगे।

चरण 9. पाठ फ़ाइलों के साथ काम करने वाले आगंतुक का आधार वर्ग

इस स्तर पर, हम विज़िटर के आधार वर्ग का निर्माण करेंगे जो पाठ फ़ाइलों के साथ काम करना जानता है। ऑब्जेक्ट पास्कल में फ़ाइलों के साथ काम करने के तीन तरीके हैं: पहली पास्कल (जैसे एसिग्नफाइल और रीडलेन) के समय से पुरानी प्रक्रियाएं, धाराओं (TStringStream या TFileStream), और TStringList ऑब्जेक्ट का उपयोग करके काम करते हैं।

यदि पहला तरीका बहुत पुराना है, तो दूसरा और तीसरा OOP पर आधारित एक अच्छा विकल्प है। एक ही समय में, धाराओं के साथ काम करने से डेटा को संपीड़ित करने और एन्क्रिप्ट करने की क्षमता के रूप में ऐसे लाभ मिलते हैं, लेकिन एक स्ट्रीम में लाइन-बाय-लाइन पढ़ना और लिखना हमारे उदाहरण में एक प्रकार की अतिरेक है। सादगी के लिए, हम एक TStringList चुनेंगे, जिसमें दो सरल विधियाँ हैं - LoadFromFile और SaveToFile। लेकिन याद रखें कि बड़ी फ़ाइलों के साथ, ये विधियां काफी धीमी हो जाएंगी, इसलिए धारा उनके लिए सबसे इष्टतम विकल्प होगी।

TVisFile बेस क्लास इंटरफ़ेस:

 TVisFile = class(TVisitor) protected   FList: TStringList;   FFileName: TFileName; public   constructor Create; virtual;   destructor Destroy; override; end; 

और निर्माणकर्ता और विध्वंसक कार्यान्वयन:

 constructor TVisFile.Create; begin inherited Create; FList := TStringList.Create; if FileExists(FFileName) then   FList.LoadFromFile(FFileName); end; destructor TVisFile.Destroy; begin FList.SaveToFile(FFileName); FList.Free; inherited; end; 

FFileName संपत्ति का मान इस बेस क्लास के वंशजों के कंस्ट्रक्टरों में सौंपा जाएगा (बस हार्डकोडिंग का उपयोग न करें, जिसे हम यहां व्यवस्थित करेंगे, मुख्य प्रोग्रामिंग शैली के रूप में!)। फ़ाइलों के साथ काम करने वाले विज़िटर वर्गों का आरेख इस प्रकार है:



नीचे दिए गए आरेख के अनुसार, हम TVisFile बेस क्लास के दो वंशज बनाते हैं: TVisTXTFile और TVisCSVFile। एक * .csv फ़ाइलों के साथ काम करेगा जिसमें डेटा फ़ील्ड एक प्रतीक (अल्पविराम) द्वारा अलग किए जाते हैं, दूसरा - पाठ फ़ाइलों के साथ जिसमें व्यक्तिगत डेटा फ़ील्ड प्रति पंक्ति एक निश्चित लंबाई का होगा। इन वर्गों के लिए, हम केवल निम्नानुसार निर्माणकर्ताओं को फिर से परिभाषित करते हैं:

 constructor TVisCSVFile.Create; begin FFileName := 'contacts.csv'; inherited Create; end; constructor TVisTXTFile.Create; begin FFileName := 'contacts.txt'; inherited Create; end. 

चरण 10. पाठ फ़ाइलों के विज़िटर-हैंडलर जोड़ें

यहां हम दो विशिष्ट विज़िटर जोड़ेंगे, एक पाठ फ़ाइल को पढ़ेगा, दूसरा उसे लिखेगा। रीडिंग विज़िटर को AcceptVisitor और Execute बेस क्लास विधियों को ओवरराइड करना चाहिए। AcceptVisitor पुष्टि करता है कि विज़िटर को TP People वर्ग ऑब्जेक्ट दिया गया है:

 Result := pVisited is TPeople; 

निष्पादन कार्यान्वयन निम्नानुसार है:

 procedure TVisTXtRead.Execute(pVisited: TVisited); var i: integer; lData: TPerson; begin if not AcceptVisitor(pVisited) then   Exit; //==> TPeople(pVisited).Clear; for i := 0 to FList.Count - 1 do begin   lData := TPerson.Create;   lData.Name := Trim(Copy(FList.Strings[i], 1, 20));   lData.EMailAdrs := Trim(Copy(FList.Strings[i], 21, 80));   TPeople(pVisited).Add(lData); end; end; 

आगंतुक पहले पैरामीटर द्वारा उसके पास दी गई टीपीज़ ऑब्जेक्ट की सूची को साफ़ करता है, फिर उसकी TStringList ऑब्जेक्ट की पंक्तियों को पढ़ता है, जिसमें फ़ाइल की सामग्री लोड की जाती है, प्रत्येक लाइन पर एक टीपर्सन ऑब्जेक्ट बनाता है और इसे टीपीज़ेन कंटेनर सूची में जोड़ता है। सरलता के लिए, पाठ फ़ाइल में नाम और ईमेलडर्स गुण रिक्त स्थान से अलग किए जाते हैं।

रिकॉर्ड आगंतुक उलटा ऑपरेशन लागू करता है। इसका कंस्ट्रक्टर (ओवरराइड) आंतरिक TStringList को साफ करता है (अर्थात, FList .Clear ऑपरेशन करता है; विरासत के बाद यह अनिवार्य है), AcceptVisitor जाँच करता है कि TPerson वर्ग ऑब्जेक्ट पास हो गया है, जो एक त्रुटि नहीं है, लेकिन एक ही विज़िटर रीडिंग विधि से एक महत्वपूर्ण अंतर है। रिकॉर्डिंग को एक ही तरीके से लागू करना आसान होगा - सभी कंटेनर ऑब्जेक्ट्स को स्कैन करें, उन्हें एक स्ट्रिंगलिस्ट में जोड़ें और फिर इसे एक फ़ाइल में सहेजें। यह सब कुछ ऐसा था अगर हम वास्तव में किसी फाइल में डेटा के अंतिम लेखन के बारे में बात कर रहे थे, हालांकि हम डेटा को संबंधपरक डेटाबेस में मैप करने की योजना बना रहे हैं, यह याद रखना चाहिए। और इस मामले में, हमें केवल उन वस्तुओं के लिए SQL कोड निष्पादित करना चाहिए जिन्हें बदल दिया गया है (बनाया, हटाया या संपादित)। यही कारण है कि आगंतुक वस्तु पर एक ऑपरेशन करने से पहले,उसे अपने प्रकार के पत्राचार की जाँच करनी चाहिए:

 Result := pVisited is Tperson; 

निष्पादित विधि केवल आंतरिक स्ट्रिंग में जोड़ता है एक स्ट्रिंग निर्दिष्ट नियम के साथ स्वरूपित होती है: पहले, पास की गई वस्तु की नाम संपत्ति की सामग्री, 20 अक्षरों तक के रिक्त स्थान के साथ गद्देदार, फिर इमदाद संपत्ति की सामग्री:

 procedure TVisTXTSave.Execute(pVisited: TVisited); begin if not AcceptVisitor(pVisited) then   exit; FList.Add(PadRight(TPerson(pVisited).Name,20)+PadRight(TPerson(pVisited).EMailAdrs,60)); end; 

चरण 11. CSV फ़ाइलों का विज़िटर-हैंडलर जोड़ें

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

 procedure TVisCSVRead.Execute(pVisited: TVisited); var i: integer; lData: TPerson; begin if not AcceptVisitor(pVisited) then   exit; TPeople(pVisited).Clear; for i := 0 to FList.Count - 1 do begin   lData := TPerson.Create;   lData.Name := ExtractDelimited(1, FList.Strings[i], [',']);   lData.EMailAdrs := ExtractDelimited(2, FList.Strings[i], [',']);   TPeople(pVisited).Add(lData); end; end; procedure TVisCSVSave.Execute(pVisited: TVisited); begin if not AcceptVisitor(pVisited) then   exit; FList.Add(TPerson(pVisited).Name + ',' + TPerson(pVisited).EMailAdrs); end; 

हमारे लिए जो कुछ भी है वह प्रबंधक में नए आगंतुकों को पंजीकृत करने और आवेदन के संचालन की जांच करने के लिए है। प्रपत्र निर्माण हैंडलर में, निम्न कोड जोड़ें:

 VM.RegisterVisitor('readTXT', TVisTXTRead); VM.RegisterVisitor('saveTXT',TVisTXTSave); VM.RegisterVisitor('readCSV',TVisCSVRead); VM.RegisterVisitor('saveCSV',TVisCSVSave); 

प्रपत्र पर आवश्यक बटन डॉक करें और उन्हें उपयुक्त हैंडलर असाइन करें:

 procedure TForm1.ReadCSVbtnClick(Sender: TObject); begin VM.Execute('readCSV', FPeople); end; procedure TForm1.ReadTXTbtnClick(Sender: TObject); begin VM.Execute('readTXT', FPeople); end; procedure TForm1.SaveCSVbtnClick(Sender: TObject); begin VM.Execute('saveCSV', FPeople); end; procedure TForm1.SaveTXTbtnClick(Sender: TObject); begin VM.Execute('saveTXT', FPeople); end; 

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

चरण 12. अंतिम कोड सफाई

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

मॉड्यूल	समारोह	कक्षाएं
tivisitor.pas	आगंतुक और प्रबंधक टेम्पलेट के आधार कक्षाएं	TVisitor TVisited TVisMapping TtiVisitorManager
tiobject.pas	बेस बिजनेस लॉजिक क्लासेस	TtiObject TtiObjectList
people_BOM.pas	विशिष्ट व्यावसायिक तर्क कक्षाएं	टीपरसन टीपी लोग
people_SRV.pas	बातचीत के लिए जिम्मेदार ठोस वर्ग	TVisFile TVisTXTFile TVisCSVFile TVisCSVSave TVisCSVRead TVisTXTSave TVisTXTRead

निष्कर्ष

इस लेख में, हमने वस्तुओं के संग्रह या सूची पर पुनरावृति की समस्या की जांच की, जिनके विभिन्न प्रकार हो सकते हैं। हमने GoF द्वारा प्रस्तावित विज़िटर टेम्प्लेट का उपयोग ऑब्जेक्ट्स से डेटा के मानचित्रण के दो अलग-अलग तरीकों को अलग-अलग प्रारूपों की फ़ाइलों को बेहतर ढंग से लागू करने के लिए किया है। एक ही समय में, अलग-अलग तरीकों का प्रदर्शन विजिटर मैनेजर के निर्माण के कारण एक टीम द्वारा किया जा सकता है। अंत में, लेख में चर्चा की गई सरल और चित्रण उदाहरण हमें एक रिलेशनल डेटाबेस में वस्तुओं को मैप करने के लिए इसी तरह की प्रणाली विकसित करने में मदद करेंगे।

उदाहरणों के स्रोत कोड के साथ पुरालेख - यहाँ