नवीनतम अपडेट: 31.10.2015

प्रोजेक्ट में एक और फॉर्म जोड़ने के लिए, सॉल्यूशन एक्सप्लोरर विंडो में प्रोजेक्ट नाम पर राइट-क्लिक करें और ऐड->विंडोज फॉर्म... चुनें।

आइए देते हैं नए रूप मेकुछ नाम, उदाहरण के लिए, फॉर्म2.सी.एस:

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

निजी शून्य बटन 1_क्लिक करें (ऑब्जेक्ट प्रेषक, इवेंटआर्ग ई) ( )

अब इसमें दूसरे फॉर्म को कॉल करने के लिए कोड जोड़ें। हमारे दूसरे फॉर्म को फॉर्म 2 कहा जाता है, इसलिए पहले हम इस क्लास का एक ऑब्जेक्ट बनाते हैं, और फिर इसे स्क्रीन पर प्रदर्शित करने के लिए हम शो विधि कहते हैं:

निजी शून्य बटन1_क्लिक(ऑब्जेक्ट प्रेषक, इवेंटआर्ग्स ई) (फॉर्म2 न्यूफॉर्म = नया फॉर्म2(); न्यूफॉर्म.शो(); )

अब चलो इसके विपरीत करें - ताकि दूसरा रूप पहले को प्रभावित करे। जबकि दूसरे रूप को पहले के अस्तित्व के बारे में पता ही नहीं चलता. इसे ठीक करने के लिए, आपको किसी तरह पहले फॉर्म के बारे में जानकारी दूसरे फॉर्म में स्थानांतरित करनी होगी। ऐसा करने के लिए, हम कंस्ट्रक्टर में फॉर्म के लिंक को पास करने का उपयोग करेंगे।

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

सिस्टम का उपयोग करना; System.Collections.Generic का उपयोग करना; System.ComponentModel का उपयोग करना; System.Data का उपयोग करना; System.Drawing का उपयोग करना; System.Linq का उपयोग करना; System.Text का उपयोग करना; System.Threading.Tasks का उपयोग करना; System.Windows.Forms का उपयोग करना; नेमस्पेस हेलोऐप (सार्वजनिक आंशिक वर्ग फॉर्म2: फॉर्म (सार्वजनिक फॉर्म2() ( इनिशियलाइज़कंपोनेंट(); ) सार्वजनिक फॉर्म2(फॉर्म1 एफ) ( इनिशियलाइज़कंपोनेंट(); एफ.बैककलर = कलर.येलो; ) ) )

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

निजी शून्य बटन1_क्लिक(ऑब्जेक्ट प्रेषक, इवेंटआर्ग्स ई) (फॉर्म2 न्यूफॉर्म = नया फॉर्म2(यह); न्यूफॉर्म.शो(); )

के बाद से इस मामले मेंयह कीवर्ड वर्तमान ऑब्जेक्ट - फॉर्म 1 ऑब्जेक्ट के संदर्भ का प्रतिनिधित्व करता है, फिर दूसरा फॉर्म बनाते समय यह इसे (लिंक) प्राप्त करेगा और इसके माध्यम से पहले फॉर्म को नियंत्रित करेगा।

अब बटन पर क्लिक करते ही दूसरा फॉर्म बन जाएगा, जो पहले फॉर्म का रंग तुरंत बदल देगा।

हम वर्तमान स्वरूप की वस्तुएँ भी बना सकते हैं:

निजी शून्य बटन1_क्लिक(ऑब्जेक्ट प्रेषक, इवेंटआर्ग्स ई) (फॉर्म1 न्यूफॉर्म1 = नया फॉर्म1(); न्यूफॉर्म1.शो(); फॉर्म2 न्यूफॉर्म2 = नया फॉर्म2(न्यूफॉर्म1); न्यूफॉर्म2.शो(); )

कई रूपों के साथ काम करते समय, आपको यह ध्यान रखना चाहिए कि उनमें से एक मुख्य है - जो सबसे पहले प्रोग्राम.सीएस फ़ाइल में लॉन्च किया गया है। यदि हमारे पास एक ही समय में बहुत सारे फॉर्म खुले हैं, तो जब हम मुख्य फॉर्म को बंद करते हैं, तो पूरा एप्लिकेशन बंद हो जाता है और इसके साथ ही अन्य सभी फॉर्म भी बंद हो जाते हैं।

कभी-कभी प्रोग्राम निष्पादन के दौरान एक फॉर्म के तत्वों को दूसरे से एक्सेस करना आवश्यक होता है। उदाहरण के लिए, एक फॉर्म फॉर्म 1 है, इसमें से हम एक और फॉर्म 2 खोलते हैं और अब, फॉर्म 2 में काम करते हुए, हमें मूल फॉर्म फॉर्म 1 के तत्वों तक पहुंचने और पहुंचने की आवश्यकता है। मुझे ऐसा करने के कई तरीके मिले।

पहली विधि. सार्वजनिक चर का संदर्भ पास करना।

नेमस्पेस विंडोज़एप्लिकेशन1 (सार्वजनिक आंशिक वर्ग फॉर्म1: फॉर्म (सार्वजनिक फॉर्म1() ( इनिशियलाइज़कंपोनेंट(); ) निजी शून्य बटन1_क्लिक(ऑब्जेक्ट प्रेषक, इवेंटआर्ग्स ई) (फॉर्म2 एफआरएम = नया फॉर्म2(); एफआरएम.लेकिन1 = यह.बटन1; // भेजें फॉर्म2 frm.ShowDialog() ) ) में बटन से लिंक करें

फॉर्म 2 में, जिस वेरिएबल को लिंक पास किया गया था वह अब फॉर्म 1 से बटन 1 के अनुरूप होगा

नेमस्पेस विंडोज़एप्लिकेशन1 (सार्वजनिक आंशिक वर्ग फॉर्म2: फॉर्म (सार्वजनिक बटन लेकिन1; // इस वेरिएबल में फॉर्म1 से बटन1 का लिंक होगा सार्वजनिक फॉर्म2() (इनिशियलाइज़कंपोनेंट(); ) निजी शून्य बटन1_क्लिक(ऑब्जेक्ट प्रेषक, इवेंटआर्ग्स ई) (लेकिन1. टेक्स्ट = "परीक्षण"; // फॉर्म1 के बटन बटन1 पर टेक्स्ट बदलें ) ) )

दूसरी विधि. चाइल्ड फॉर्म का लिंक पास किया जा रहा है।

पहली विधि में सार लगभग समान है। फॉर्म2 खोलते समय, हम उसमें उस तत्व का एक लिंक भेजते हैं जिसे हम बाद में बदलने की योजना बनाते हैं।

नेमस्पेस विंडोज़एप्लिकेशन1 (सार्वजनिक आंशिक वर्ग फॉर्म1: फॉर्म (सार्वजनिक फॉर्म1() ( इनिशियलाइज़कंपोनेंट(); ) निजी शून्य बटन1_क्लिक(ऑब्जेक्ट प्रेषक, इवेंटआर्ग्स ई) (फॉर्म2 एफआरएम = नया फॉर्म2(यह.बटन1); // बटन के लिए एक लिंक पास करें फॉर्म फॉर्म2 frm.ShowDialog() ) )

अब फॉर्म 2 में हमें एक वेरिएबल बनाने की जरूरत है जिसमें इस बटन का लिंक होगा और इसके माध्यम से हम फॉर्म 1 (पंक्तियां 5,7,9 और 15) पर बटन तक पहुंच पाएंगे।

नेमस्पेस विंडोजएप्लिकेशन1 ( सार्वजनिक आंशिक वर्ग फॉर्म2: फॉर्म ( निजी बटन लेकिन1; // इस वेरिएबल में फॉर्म फॉर्म1 से बटन बटन1 का लिंक होगा सार्वजनिक फॉर्म2(बटन लेकिन) // वेरिएबल में बटन का लिंक प्राप्त करें लेकिन ( लेकिन1 = परंतु; // अब बट1 बटन बटन1 इनिशियलाइज़कंपोनेंट() का लिंक होगा; ) निजी शून्य बटन1_क्लिक(ऑब्जेक्ट प्रेषक, इवेंटआर्ग्स ई) (ब्यूट1.टेक्स्ट = "टेस्ट"; // फॉर्म1 के बटन बटन1 पर टेक्स्ट बदलें) )

तीसरी विधि. संपूर्ण मूल प्रपत्र तक पहुंच.

ऐसा करने के लिए, आपको कई फ़ाइलों में परिवर्तन करने की आवश्यकता है, लेकिन साथ ही हमारे पास मूल प्रपत्र के सभी तत्वों तक पहुंच होगी और प्रत्येक तत्व के लिए एक लिंक पास करने की आवश्यकता नहीं होगी, जैसा कि विधि 1 में है।

स्टेप 1।फाइल मैं प्रोग्राम.सी.एसएक सार्वजनिक चर f1 (पंक्ति 5) बनाएँ।

नेमस्पेस विंडोज़एप्लिकेशन1 (स्टेटिक क्लास प्रोग्राम (पब्लिक स्टैटिक फॉर्म1 एफ1; // वेरिएबल जिसमें फॉर्म1 स्टेटिक वॉयड मेन() (एप्लीकेशन.एनेबलविजुअलस्टाइल्स(); एप्लीकेशन.सेटकंपैटिबलटेक्स्टरेंडरिंगडिफॉल्ट(गलत); एप्लीकेशन.रन(नया फॉर्म1()) का लिंक होगा। ) ) ) )

चरण दो।प्रारंभिक फॉर्म1.डिजाइनर.सीएसऔर इसमें, उन तत्वों के लिए जिन्हें दूसरे रूप से एक्सेस करने की आवश्यकता होगी, हम बदलते हैं निजीपर जनता. उदाहरण के लिए, आइए फॉर्म1 पर बटन1 को बदलावों के लिए उपलब्ध कराएं।

सार्वजनिक सिस्टम.विंडोज़.फ़ॉर्म.बटन बटन1; // निजी को सार्वजनिक से बदल दिया गया

चरण 3. फॉर्म1 बनाते समय, हम वेरिएबल एफ1 को इस फॉर्म के लिए एक लिंक निर्दिष्ट करते हैं (पंक्ति 7)

नेमस्पेस विंडोज़एप्लिकेशन1 (सार्वजनिक आंशिक वर्ग फॉर्म1: फॉर्म (सार्वजनिक फॉर्म1() (प्रोग्राम.एफ1 = यह; // अब एफ1 फॉर्म फॉर्म1 इनिशियलाइज़कंपोनेंट() का लिंक होगा;) निजी शून्य बटन1_क्लिक(ऑब्जेक्ट प्रेषक, इवेंटआर्ग्स ई) (फॉर्म2) frm = नया फॉर्म2(); frm.ShowDialog();

चरण 4।अब बिल्कुल किसी भी फॉर्म से या किसी भी क्लास से आप फॉर्म1 पर स्थित बटन1 तत्व तक इस तरह पहुंच सकते हैं: प्रोग्राम.एफ1.बटन1। उदाहरण के लिए, फॉर्म 2 पर बटन को फॉर्म 1 पर बटन टेक्स्ट बदलने दें:

नेमस्पेस विंडोज़एप्लिकेशन1 (सार्वजनिक आंशिक वर्ग फॉर्म2: फॉर्म (सार्वजनिक फॉर्म2() ( इनिशियलाइज़कंपोनेंट(); ) निजी शून्य बटन1_क्लिक(ऑब्जेक्ट प्रेषक, इवेंटआर्ग्स ई) ( प्रोग्राम.एफ1.बटन1.टेक्स्ट = "टेस्ट"; // पर टेक्स्ट बदलें फॉर्म बटन फॉर्म1 ) ) )

इस तथ्य के बावजूद कि माइक्रोसॉफ्ट के विज़ुअल स्टूडियो के बारे में मेरी राय वही है, कभी-कभी आपको इस पर कुछ करना पड़ता है। यदि हम इस तथ्य को स्वीकार करते हैं कि हम वास्तव में, C++ में नहीं, बल्कि तथाकथित C++/CLI में लिखते हैं, तो परिचित दृश्य घटकों के साथ काम करना समान बोरलैंड वातावरण से इतना भिन्न नहीं होगा। लेकिन यह बिल्डर की तुलना में समस्याएं पैदा कर सकता है। आइए एक से अधिक फॉर्म वाले एप्लिकेशन के साथ काम करने की 3 विशिष्ट स्थितियों पर विचार करें। उदाहरण वातावरण मुफ़्त विज़ुअल सी++ 2010 एक्सप्रेस है, यह माना जाता है कि मुख्य फॉर्म का डिफ़ॉल्ट नाम फॉर्म1 है।

किसी प्रपत्र के निर्माण और प्रोग्रामेटिक रूप से कॉल करने का एक उदाहरण

इस कोड को निष्पादित किया जा सकता है, उदाहरण के लिए, मुख्य फॉर्म फॉर्म 1 में एक बटन पर क्लिक करके।

फॉर्म^फॉर्म2 = जीसीन्यू फॉर्म(); बटन^ बटन2 = जीसीन्यू बटन(); बटन2->टेक्स्ट = एल"ओके"; बटन2->स्थान = बिंदु(10,10); फॉर्म2->टेक्स्ट = एल"मेरी विंडो"; फॉर्म2->हेल्पबटन = सत्य; form2->FormBorderStyle = System::Windows::Forms::FormBorderStyle::FixedDialog; फॉर्म2->स्टार्टपोजीशन = फॉर्मस्टार्टपोजीशन::सेंटरस्क्रीन; फॉर्म2->नियंत्रण->जोड़ें(बटन2); form2->ShowDialog();

प्रोग्रामेटिक रूप से जेनरेट किए गए बटन बटन2 के लिए एक क्लिक हैंडलर जोड़ने के लिए, बस कोड की अंतिम पंक्ति से पहले लिखें:

बटन2->क्लिक करें += जीसीन्यू सिस्टम::इवेंटहैंडलर(यह, &फॉर्म1::बटन2_क्लिक);

form2->ShowDialog() या form2->Show() विधि को कॉल करने से पहले;

इस मामले में, हैंडलर कोड वर्तमान मॉड्यूल फॉर्म1.एच में स्थित है:

निजी: सिस्टम::शून्य बटन2_क्लिक(सिस्टम::ऑब्जेक्ट^ प्रेषक, सिस्टम::इवेंटआर्ग्स^ ई) (संदेशबॉक्स::दिखाएं("यहां"); )

मुख्य प्रपत्र से दूसरे प्रपत्र को कॉल करें

मेनू में, प्रोजेक्ट चुनें - एक नया तत्व जोड़ें - फॉर्म - नाम फॉर्म2

आइए एक ऑपरेटर जोड़ें

#शामिल करें "फॉर्म2.एच"

फॉर्म1.एच में पहले नेमस्पेस से पहले (अर्थात, फ़ाइल की शुरुआत में)।

आइए फॉर्म 1 क्लास के सार्वजनिक अनुभाग में क्लास इंस्टेंस के लिए एक पॉइंटर शामिल करें:

फॉर्म2^एफ2;

आइए वह कोड जोड़ें जहां हमें दूसरा फॉर्म बनाने और कॉल करने की आवश्यकता है:

F2=gcnewForm2(); F2->दिखाएँ();

दूसरे फॉर्म को प्रोग्रामेटिक रूप से हटाने के लिए, निम्नलिखित कोड उपयुक्त है:

F2 हटाएं;

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

आइए फॉर्म क्लास फॉर्म 1 में आवश्यक डेटा का वर्णन करें (यहां टेबुलेटर प्रोजेक्ट का नाम और नेमस्पेस, यदि आवश्यक हो, तो अपने स्वयं के साथ बदलें):

स्थैतिक स्थिरांक int MAX_FORMS = 100; // फॉर्म की अधिकतम संख्या int फॉर्मकाउंट; //फॉर्म काउंटर ऐरे ^F2; // प्रपत्रों की एक श्रृंखला की ओर सूचक

फिर हम मुख्य फॉर्म के लोड इवेंट का उपयोग करके डेटा प्रारंभ करते हैं:

फॉर्मकाउंट=0; F2 = gcnew सारणी (MAX_FORMS);

फिर हम अगला फॉर्म बनाने के लिए कोड लागू करेंगे

यदि(फॉर्मगणना दिखाओ(); ) अन्यथा MessageBox::Show("बहुत सारे फॉर्म!");

और इसका निष्कासन:

यदि (फॉर्मकाउंट) (F2 हटाएं; फॉर्मकाउंट--;)

यदि हम चाइल्ड फॉर्म अलग से नहीं, बल्कि पैरेंट फॉर्म के अंदर बनाना चाहते हैं, तो फॉर्म 1 के गुणों में हमें यह इंगित करना होगा कि यह एक "पूर्वज" है (IsMdiParent संपत्ति = सत्य सेट करें), और चाइल्ड फॉर्म को दिखाने से पहले F2->Show() ऑपरेटर, इसे चाइल्ड फॉर्म1 के रूप में चिह्नित करें:

F2->MdiParent = यह;

चाइल्ड फॉर्म से पेरेंट फॉर्म विधि को कॉल करें

हम .cpp फ़ाइलों का उपयोग किए बिना शायद ही काम कर सकते हैं, जो बुरा नहीं है - .h फ़ाइलों में कोड लिखना आम तौर पर सही C सिस्टम को तोड़ देता है :)

आइए चरण दर चरण प्रक्रिया का वर्णन करें।

1) 2 फॉर्म हैं - फॉर्म1 और फॉर्म2, फॉर्म1 पर एक बटन है (बटन1, दूसरा फॉर्म खोलेगा) और लेबल (लेबल1, यहां हम टेक्स्ट बदल देंगे)। फॉर्म 2 - बटन 1 पर, क्लिक करने पर, लेबल 1 में टेक्स्ट बदल जाएगा।

2) चूँकि हमें पहले फॉर्म से दूसरे फॉर्म तक और दूसरे से पहले तक पहुंच की आवश्यकता है, क्रॉस-रेफरेंस की समस्या उत्पन्न होगी (जब फॉर्म1.एच फॉर्म2.एच को संदर्भित करता है, जो बदले में, फिर से संदर्भित करता है) फॉर्म1.h) के लिए। इससे बचने के लिए, हम पहले फॉर्म (फॉर्म 1) के कोड को .h फ़ाइल से .cpp फ़ाइल में स्थानांतरित कर देंगे, जिसकी दूसरे फॉर्म (फॉर्म 2) तक पहुंच होगी। इस प्रकार, आपको एक फ़ाइल form1.cpp बनाने की आवश्यकता है।

3) घोषणा करें सार्वजनिक विधिफॉर्म1.एच में सेट करें ताकि आप लेबल1 का टेक्स्ट बदल सकें (कोड फ़ाइल के अंत में #pragma enregion के बाद लिखा जा सकता है):

सार्वजनिक: शून्य सेट(स्ट्रिंग^ टेक्स्ट) (लेबल1->टेक्स्ट = टेक्स्ट;)

4) फॉर्म2.एच फ़ाइल में हम फॉर्म1.एच (शुरुआत में) शामिल करते हैं:

#शामिल करें "फॉर्म1.एच"

और एक कंस्ट्रक्टर बनाएं जो आगे के उपयोग के लिए पहले फॉर्म के लिंक को स्वीकार करेगा और सहेजेगा:

फॉर्म2(फॉर्म1^ पैरेंट) ( इनिशियलाइज़कंपोनेंट(); पेरेंटफॉर्म = पेरेंट; ) //आप तुरंत नीचे एक लिंक लिख सकते हैं: प्राइवेट: फॉर्म1^ पेरेंटफॉर्म;

5) फॉर्म 2 में बटन पर क्लिक करने पर, हम मूल फॉर्म की सेट विधि को कॉल करेंगे:

निजी: सिस्टम::शून्य बटन1_क्लिक(सिस्टम::ऑब्जेक्ट^ प्रेषक, सिस्टम::इवेंटआर्ग्स^ ई) ( पेरेंटफॉर्म->सेट("फॉर्म2 से हैलो"); पेरेंटफॉर्म->शो(); यह->छिपाएं(); )

6) पहले फॉर्म में दूसरा फॉर्म खोलना बाकी है। ऐसा करने के लिए, हम बटन क्लिक हैंडलर को फॉर्म1.h से फॉर्म1.cpp पर ले जाते हैं, और .h फ़ाइल में हम केवल इसकी घोषणा छोड़ते हैं।

व्यवस्थापक द्वारा.

C# सीखना धीमा है. लेकिन यह ईमानदारी से जारी है. अभी हाल ही में मैं
विज़ुअल सी# में एक फॉर्म से दूसरे फॉर्म को कैसे खोलें इसका एक उदाहरण दिया। सिद्धांत रूप में, सब कुछ सरल है.

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

आरंभ करने के लिए, आइए आरंभिक (प्रारंभिक) डेटा सेट करें।

इसलिए। हमारे पास मुख्य आवेदन पत्र है:

इस फॉर्म में TBDialog नाम से एक टेक्स्टबॉक्स और एक बटन बटन भी शामिल है जिस पर हमें क्लिक करना चाहिए:

1. TBDialog से TBMain तक टेक्स्ट प्रॉपर्टी का मान पास करें;
2. fDialog बंद करें;

आइए अब पूरी प्रक्रिया को क्रम से देखें।

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

अब TBMmain अन्य ऑब्जेक्ट में दिखाई देगा। पर चलते हैं। फॉर्म को मोडल मोड में खोलने के लिए, हमें शोडायलॉग() विधि के लिए दो विकल्पों में से एक का उपयोग करने की आवश्यकता है:

सार्वजनिक डायलॉगपरिणाम शोडायलॉग(IWin32Window स्वामी);

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

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

- जो माता-पिता की ओर इशारा करता है:

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

स्वाभाविक रूप से, ऐसा करने से पहले, आपको दूसरे फॉर्म के कंस्ट्रक्टर के लिए ओवरलोड बनाने का ध्यान रखना चाहिए।

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

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

पहले वाले के समान, इसमें समान नियंत्रण हैं। हमें और कुछ नहीं चाहिए. एप्लिकेशन प्रविष्टि बिंदु मुख्य प्रपत्र लॉन्च करता है:

सिस्टम का उपयोग करना; System.Collections.Generic का उपयोग करना; System.Linq का उपयोग करना; System.Windows.Forms का उपयोग करना; नेमस्पेस फ्रॉम1फॉर्मटू2 (स्टैटिक क्लास प्रोग्राम (//एप्लिकेशन के लिए मुख्य प्रविष्टि बिंदु। स्टेटिक शून्य मेन() (एप्लिकेशन.इनेबलविजुअलस्टाइल्स(); एप्लीकेशन.सेटकंपैटिबलटेक्स्टरेंडरिंगडिफॉल्ट(गलत); एप्लीकेशन.रन(नया मेनफॉर्म()); ) ) )

मुख्य प्रपत्र कोड इस तरह दिखता है:

सिस्टम का उपयोग करना; System.Collections.Generic का उपयोग करना; System.ComponentModel का उपयोग करना; System.Data का उपयोग करना; System.Drawing का उपयोग करना; System.Linq का उपयोग करना; System.Text का उपयोग करना; System.Windows.Forms का उपयोग करना; नेमस्पेस फ्रॉम1फॉर्मटू2 (सार्वजनिक आंशिक वर्ग मेनफॉर्म: फॉर्म (//दूसरा फॉर्म सेकेंडफॉर्म सेकेंडफॉर्म; //कंस्ट्रक्टर पब्लिक मेनफॉर्म() (इनिशियलाइज़कंपोनेंट();) //डेटा ट्रांसफर इवेंट हैंडलर //मुख्य फॉर्म से दूसरे निजी शून्य तक btn_mainForm_Click(ऑब्जेक्ट प्रेषक, इवेंटआर्ग्स ई) ( सेकंडफॉर्म = नया सेकंडफॉर्म(tb_mainForm.Text.Trim()); सेकंडफॉर्म.शोडायलॉग(); यदि (सेकंडफॉर्म.डायलॉगResult == DialogResult.OK) tb_mainForm.Text = सेकंडफॉर्म.ReturnData(); ) ) )

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

अब सबसे दिलचस्प हिस्सा दूसरे फॉर्म का कोड है:

सिस्टम का उपयोग करना; System.Collections.Generic का उपयोग करना; System.ComponentModel का उपयोग करना; System.Data का उपयोग करना; System.Drawing का उपयोग करना; System.Linq का उपयोग करना; System.Text का उपयोग करना; System.Windows.Forms का उपयोग करना; नेमस्पेस फ्रॉम1फॉर्मटू2 (सार्वजनिक आंशिक वर्ग सेकेंडफॉर्म: फॉर्म (//ओवरलोडेड कंस्ट्रक्टर सार्वजनिक सेकेंडफॉर्म(स्ट्रिंग डेटा) (इनिशियलाइज़कंपोनेंट(); tb_सेकेंडफॉर्म.टेक्स्ट = डेटा;) //डेटा ट्रांसफर इवेंट हैंडलर //दूसरे फॉर्म से मुख्य निजी शून्य तक बीटीएन_सेकेंडफॉर्म_क्लिक (ऑब्जेक्ट प्रेषक, इवेंटआर्ग्स ई) (यह.डायलॉगResult = DialogResult.OK;) //इस फॉर्म के टेक्स्ट फ़ील्ड तक पहुंचने के लिए सार्वजनिक विधि सार्वजनिक स्ट्रिंग ReturnData() (रिटर्न (tb_thirdForm.Text.Trim()); ) ) )

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

(दूसरा फॉर्म .DialogResult == DialogResult .OK)

पहला रूप, इसलिए, विधि को कॉल करके दूसराफॉर्म.रिटर्नडेटा(), हम पहले फॉर्म के टेक्स्ट फ़ील्ड को दूसरे फॉर्म के टेक्स्ट फ़ील्ड के मान पर सेट करते हैं।

मुझे लगता है कि इस पद्धति के संचालन के लिए अब स्पष्टीकरण की आवश्यकता नहीं है। यह टेक्स्ट को निजी रखते हुए उसे केवल एक टेक्स्ट फ़ील्ड से लौटाता है।

परिणामस्वरूप, हमने एनकैप्सुलेशन के सिद्धांतों का उल्लंघन किए बिना डेटा को पहले से दूसरे फॉर्म में और दूसरे से पहले में स्थानांतरित कर दिया।

पहले फॉर्म के टेक्स्ट फ़ील्ड में "आआ" टेक्स्ट दर्ज करने और बटन पर क्लिक करने का प्रयास करें। आप इस टेक्स्ट को खुलने वाले दूसरे फॉर्म में टेक्स्ट फ़ील्ड में देखेंगे। टेक्स्ट को "आआ पप्प" में बदलने का प्रयास करें और बटन पर क्लिक करें। आप देखेंगे कि कैसे, दूसरे फॉर्म को बंद करने के बाद, यह टेक्स्ट मुख्य फॉर्म के टेक्स्ट फ़ील्ड में दिखाई देगा।

अब, मुझे लगता है कि आप प्रपत्रों के बीच डेटा को अधिक सही ढंग से स्थानांतरित करने में सक्षम होंगे। अगले लेख में हम ASP.NET अनुप्रयोगों में इसे कैसे करें इसके बारे में बात करेंगे।