स्विचेस, नियमित अर्ज, व्यवस्थापित फॉर्म. स्विचेस, नियमित अनुप्रयोग, व्यवस्थापित फॉर्म 1c व्यवस्थापित फॉर्मसह समस्या

1C:एंटरप्राइज प्लॅटफॉर्म तुम्हाला प्रोग्रामॅटिकरित्या व्यवस्थापित फॉर्मचे घटक जोडण्याची आणि बदलण्याची परवानगी देतो. याची गरज का असू शकते ते शोधूया.

फॉर्मचे सॉफ्टवेअर सुधारणे अनेक प्रकरणांमध्ये आवश्यक असू शकते:

• त्यानंतरच्या अद्यतन प्रक्रियेच्या सोयीसाठी मानक कॉन्फिगरेशनला अंतिम रूप देताना. या प्रकरणात, फक्त फॉर्म मॉड्यूल बदलला जाईल. फॉर्म्सपेक्षा मॉड्यूल्स अपडेट करणे खूप सोपे आहे.
• काही सामान्य अल्गोरिदम लागू करताना. उदाहरणार्थ, "ऑब्जेक्ट तपशील संपादित करण्यास मनाई" उपप्रणालीमध्ये, तपशील संपादित करण्याची क्षमता सक्षम करण्यासाठी सबसिस्टमशी कनेक्ट केलेल्या सर्व ऑब्जेक्टसाठी प्रोग्रामॅटिकरित्या एक बटण तयार केले जाऊ शकते.
• काही विशिष्ट अल्गोरिदम लागू करताना. उदाहरणार्थ, नामांकन निर्देशिकेत, अतिरिक्त तपशील संपादित करण्यासाठी फील्ड तयार केली जातात.

व्यवस्थापित फॉर्ममध्ये, तुम्ही प्रोग्रामॅटिकरित्या जोडू शकता, बदलू शकता आणि हटवू शकता:

• आवश्यक
• स्थानिक संघ;
• घटक.

या सर्व ऑपरेशन्स फक्त सर्व्हरवर शक्य आहेत.

प्रोग्रामेटिक रीशेपिंगला मर्यादा आहेत:

• तुम्ही फक्त प्रोग्रॅमॅटिकरित्या जोडलेले तपशील/आदेश/घटक हटवू शकता. तुम्ही कॉन्फिग्युरेटरमध्ये तयार केलेल्या वस्तू प्रोग्रॅमॅटिकली हटवू शकत नाही.
• तुम्ही मुख्य म्हणून विशेषता नियुक्त करू शकत नाही.

फॉर्म कमांड बदलणे

ऑब्जेक्टसाठी कमांडची रचना व्यवस्थापित करण्यासाठी व्यवस्थापित फॉर्मएक संग्रह आहे संघ

ॲड (< ИмяКоманды >)

प्रमाण ()

शोधणे (< ИмяКоманды >)

हटवा (< Команда >)

टीम कलेक्शन क्लायंट आणि सर्व्हर दोन्हीवर उपलब्ध आहे. तुम्ही संग्रह (Add() आणि Delete() पद्धती) फक्त सर्व्हरवर बदलू शकता. तुम्ही क्लायंट आणि सर्व्हरवर घटकांची संख्या (शोधा () आणि मोजणी () पद्धती) शोधू शकता आणि मिळवू शकता.

फॉर्म कमांड्ससह कार्य करण्याचे उदाहरण म्हणून, “ChangeHistory...” हेडिंग असलेली एक नवीन ChangeHistory कमांड तयार करू, जी हँडलरला कॉल करेल. डिस्प्लेइतिहास(). फॉर्म उघडल्यावर निर्मिती होते.

&सर्व्हरवर
कार्यपद्धती WhenCreatingOnServer(अयशस्वी, मानक प्रक्रिया)
संघ = संघ. जोडा( "बदलांचा इतिहास");
संघ . क्रिया = ;
संघ . शीर्षक = "बदलांचा इतिहास...";
प्रक्रिया समाप्त
&ऑनक्लायंट
कार्यपद्धती Connectable_DisplayHistory(कमांड)
// आदेश क्रिया
प्रक्रिया समाप्त

कमांड हँडलर फॉर्मवर स्थित असणे आवश्यक आहे आणि त्याच्याकडे &OnClient संकलन निर्देश असणे आवश्यक आहे.

फॉर्म तपशील बदलत आहे

फॉर्म तपशीलांची रचना वाचणे फंक्शनद्वारे केले जाते तपशील मिळवा(< Путь >) FormAttributes प्रकाराचा ॲरे परत करत आहे. फंक्शन पॅरामीटर मूळ विशेषता (स्ट्रिंग म्हणून) साठी मार्ग निर्दिष्ट करते. पॅरामीटर वगळल्यास किंवा रिक्त स्ट्रिंग निर्दिष्ट केल्यास, उच्च-स्तरीय तपशील परत केले जातात.

तपशील बदलणे पद्धत वापरून केले जाते तपशील बदला(<तपशील जोडले>, <काढता येण्याजोगा तपशील>) वस्तू व्यवस्थापित फॉर्म. मापदंडांना तपशील जोडलेआणि काढता येण्याजोगा तपशीलफॉर्म विशेषता प्रकारातील घटकांसह ॲरे प्रसारित केले जातात.

लक्ष द्या!

तपशीलांची रचना बदलण्याची प्रक्रिया खूप संसाधन-केंद्रित आहे. फॉर्म प्रत्यक्षात पुन्हा तयार केला जात आहे. या संदर्भात, फॉर्म तपशीलांसह कार्य बॅच मोडमध्ये केले जाते.

खरेदीदार नावाने एक नवीन फॉर्म विशेषता तयार करूया:

जोडलेले तपशील = नवीन ॲरे;
तपशील जोडले. जोडा(नवीन फॉर्म विशेषता(“खरेदीदार”, नवीन प्रकार वर्णन (“निर्देशिका लिंक. काउंटरपार्टीज”), “क्लायंट”));

// तपशीलांच्या रचनेत बदल
);

फॉर्म घटक बदलणे

ऑब्जेक्टच्या घटकांची रचना नियंत्रित करण्यासाठी व्यवस्थापित फॉर्मएक संग्रह आहे घटक. संकलनात अनेक पद्धती आहेत:

घाला (< Имя>, < ТипЭлемента>, < Родитель>, < Элемент >)

ॲड (< Имя>, < ТипЭлемента>, < Родитель >)

प्रमाण ()

शोधणे (< Имя >)

हलवा(< Элемент>, < Родитель>, < МестоРасположения >)

हटवा (< Элемент >)

आयटम संग्रह क्लायंट आणि सर्व्हर दोन्हीवर उपलब्ध आहे. संग्रह सुधारित करा (पद्धती घाला () , जोडा () , हलवा () आणि हटवा () ) फक्त सर्व्हरवर उपलब्ध आहेत. तुम्ही क्लायंट आणि सर्व्हरवर घटकांची संख्या (शोधा () आणि मोजा () पद्धती) शोधू शकता आणि मिळवू शकता. संग्रह घटक असू शकतात:

• फॉर्मग्रुप;
• फॉर्मटेबल;
• फॉर्मफील्ड;
• फॉर्म बटण.

घटक तयार करण्यासाठी तुम्ही प्रोग्रामेटिकरित्या इव्हेंट हँडलर नियुक्त करू शकता. पद्धत या हेतूंसाठी आहे SetAction(< ИмяСобытия>, < Действие >) .

आज्ञा, तपशील आणि फॉर्म घटकांसह कार्य करण्याची काही सामान्य उदाहरणे पाहू या.

कमांड आणि त्याच्याशी संबंधित बटण जोडणे:

// कमांड तयार करा
संघ = संघ. जोडा( "बदलांचा इतिहास");
संघ . क्रिया = "प्लग-इन_डिस्प्लेइतिहास"; // फॉर्ममध्ये निर्दिष्ट नावासह प्रक्रिया असणे आवश्यक आहे
संघ . शीर्षक = "बदलांचा इतिहास...";
// एक बटण तयार करा आणि त्यास कमांडसह संबद्ध करा
घटक = वस्तू. जोडा( "बदलांचा इतिहास", प्रकार("फॉर्मबटन"));
Element.CommandName = "बदलांचा इतिहास";

विशेषता आणि संबंधित इनपुट फील्ड जोडणे:

// जोडलेल्या तपशीलांचे वर्णन
जोडलेले तपशील = नवीन ॲरे;
तपशील जोडले. ॲड(नवीन फॉर्म प्रॉप्स ("खरेदीदार", नवीन प्रकार वर्णन ( "DirectoryLink. Counterparties"), "क्लायंट" ));
// तपशीलांची रचना बदलणे
तपशील बदला (जोडलेले तपशील);
// इनपुट फील्ड तयार करणे आणि विशेषता सह कनेक्ट करणे
घटक = वस्तू. जोडा("खरेदीदार" , प्रकार("फॉर्मफील्ड"));
घटक . दृश्य = FormFieldView. प्रवेश क्षेत्र;
घटक . PathToData= "खरेदीदार" ;

फॉर्म घटकाला इव्हेंट हँडलर नियुक्त करणे:

आयटम ग्राहक. SetAction("जेव्हा ते बदलते", "कनेक्टेड_खरेदीदार बदला");

&ऑनक्लायंट
कार्यपद्धती Connected_BuyerOnChange(घटक)
// कार्यक्रम क्रिया
प्रक्रिया समाप्त

लक्ष द्या!

पद्धत वापरून कोडमधून इव्हेंट हँडलर म्हणून सेट केलेल्या प्रक्रिया SetAction(), Connectable_ उपसर्ग सेट करण्याची शिफारस केली जाते.

लक्ष द्या!

तुम्ही प्रोग्रॅमॅटिक शोध आणि बदललेले तपशील, आदेश आणि व्यवस्थापित फॉर्मचे घटक उदाहरणांसह प्रक्रिया डाउनलोड करू शकता.

आणि कोड स्ट्रक्चरिंगमध्ये डेटा ट्रान्सफर ऑब्जेक्ट, 1C 8.2 वातावरणात नियंत्रित फॉर्म.

परिचय

चला "व्यवस्थापित फॉर्म" ची संकल्पना आणि 1C प्लॅटफॉर्मच्या संबंधित संकल्पनांच्या संक्षिप्त वर्णनासह प्रारंभ करूया. प्लॅटफॉर्म तज्ञांना हा विभाग वगळण्याची इच्छा असू शकते.

2008 मध्ये, 1C प्लॅटफॉर्मची नवीन आवृत्ती: एंटरप्राइझ 8.2 (यापुढे मॅनेज्ड ऍप्लिकेशन म्हणून संदर्भित) उपलब्ध झाली, जी इंटरफेससह संपूर्ण कार्याचा स्तर पूर्णपणे बदलते. यामध्ये कमांड इंटरफेस, फॉर्म आणि विंडो सिस्टम समाविष्ट आहे. त्याच वेळी, कॉन्फिगरेशनमध्ये वापरकर्ता इंटरफेस विकसित करण्यासाठी केवळ मॉडेलच बदलत नाही, तर क्लायंट ऍप्लिकेशन आणि सर्व्हरमधील कार्यक्षमता विभक्त करण्यासाठी एक नवीन आर्किटेक्चर देखील प्रस्तावित आहे.
व्यवस्थापित अनुप्रयोग खालील प्रकारच्या क्लायंटना समर्थन देतो:

• जाड क्लायंट (सामान्य आणि व्यवस्थापित लॉन्च मोड)
• छोटा ग्राहक
• वेब क्लायंट

व्यवस्थापित अनुप्रयोग नवीन तंत्रज्ञानावर तयार केलेले फॉर्म वापरतो. त्यांना बोलावले आहे व्यवस्थापित फॉर्म. संक्रमण सुलभ करण्यासाठी, मागील फॉर्म (तथाकथित नियमित फॉर्म) देखील समर्थित आहेत, परंतु त्यांची कार्यक्षमता विकसित केलेली नाही आणि ते फक्त जाड क्लायंट लॉन्च मोडमध्ये उपलब्ध आहेत.
विकसकासाठी व्यवस्थापित फॉर्मचे मुख्य फरक:

• घोषणात्मक, "पिक्सेल बाय पिक्सेल" संरचनेचे वर्णन नाही. जेव्हा फॉर्म प्रदर्शित होतो तेव्हा घटकांची विशिष्ट प्लेसमेंट सिस्टमद्वारे स्वयंचलितपणे केली जाते.
• फॉर्मच्या सर्व कार्यक्षमतेचे वर्णन केले आहे तपशीलआणि संघ. तपशील हा डेटा आहे ज्यासह फॉर्म कार्य करतो आणि आज्ञा म्हणजे केल्या जाणाऱ्या क्रिया.
• फॉर्म सर्व्हर आणि क्लायंट दोन्हीवर चालतो.
• क्लायंट संदर्भात, जवळजवळ सर्व अनुप्रयोग प्रकार अनुपलब्ध आहेत, आणि त्यानुसार इन्फोबेसमधील डेटा बदलणे अशक्य आहे.
• प्रत्येक पद्धत किंवा फॉर्म व्हेरिएबलसाठी, ते निर्दिष्ट करणे आवश्यक आहे संकलन निर्देश, अंमलबजावणी स्थान (क्लायंट किंवा सर्व्हर) परिभाषित करणे आणि फॉर्म संदर्भामध्ये प्रवेश.

फॉर्म पद्धती संकलित करण्यासाठी निर्देशांची यादी करूया:

• &ऑनक्लायंट
• &सर्व्हरवर
• संदर्भाशिवाय &ऑनसर्व्हर
• संदर्भाशिवाय &OnClientOnServer

वरील उदाहरण देऊ. स्क्रीनशॉट व्यवस्थापित फॉर्मचे उदाहरण आणि विकास मोडमधील त्याचे मॉड्यूल दाखवते. घोषणात्मक वर्णन, प्रॉप्स, संकलन निर्देश इ. शोधा.

पुढील सर्व चर्चा चित्राच्या उजव्या बाजूबद्दल, मॉड्यूल कोडची रचना कशी करावी आणि कोणती तत्त्वे तुम्हाला प्रभावी क्लायंट-सर्व्हर परस्परसंवादाची अंमलबजावणी करण्यास अनुमती देतील याबद्दल असतील.

चला समस्या परिभाषित करूया

1C प्लॅटफॉर्मची नवीन आवृत्ती सक्रियपणे वापरल्यापासून अनेक वर्षे उलटून गेली आहेत आणि 1C आणि त्याच्या अनेक भागीदारांद्वारे अनेक निराकरणे (कॉन्फिगरेशन) जारी केली गेली आहेत.
या काळात, विकसकांनी फॉर्म तयार करताना क्लायंट-सर्व्हर परस्परसंवादाच्या तत्त्वांची सामान्य समज विकसित केली आहे आणि नवीन वास्तुशास्त्रीय वास्तविकतेमध्ये सॉफ्टवेअर मॉड्यूल लागू करण्याचा दृष्टिकोन बदलला आहे का?

चला समान मानक कॉन्फिगरेशनच्या अनेक फॉर्ममध्ये कोड स्ट्रक्चर (फॉर्म मॉड्यूल) पाहू आणि नमुने शोधण्याचा प्रयत्न करू.
संरचनेनुसार आमचा अर्थ आहे कोडचे विभाग (बहुतेकदा हे टिप्पणी ब्लॉक्स असतात) विकासकाने गट पद्धती आणि या पद्धतींसाठी संकलित निर्देशांसाठी वाटप केले.
उदाहरण १:
इव्हेंट हँडलर्सचा विभाग पद्धत - क्लायंट पद्धतीवर - सर्व्हर पद्धतीवर - क्लायंटवर सेवा प्रक्रियेचा विभाग आणि कार्ये सहायक इनपुट नियंत्रण कार्ये
उदाहरण २:
सेवा प्रक्रिया आणि कार्ये पेमेंट दस्तऐवज मूल्ये इव्हेंट हँडलर
उदाहरण ३:
सर्व्हरवरील सेवा प्रक्रिया क्लायंटवरील सेवा प्रक्रिया संदर्भाशिवाय सर्व्हरवरील सेवा प्रक्रिया शीर्षलेख इव्हेंट हँडलर कमांड इव्हेंट हँडलर
उदाहरण ४:
सामान्य हेतू प्रक्रिया फॉर्म इव्हेंट हँडलर "संपर्क माहिती" उपप्रणालीची प्रक्रिया
मूलत:, कोड रचना गहाळ आहे, किंवा सौम्यपणे सांगायचे तर, ते फॉर्म 8.1 प्रमाणेच आहे:

• गैर-माहितीपूर्ण शब्द "सामान्य, सेवा, सहायक".
• क्लायंट आणि सर्व्हर पद्धती वेगळे करण्याचा डरपोक प्रयत्न.
• पद्धती सहसा इंटरफेस घटकांनुसार गटबद्ध केल्या जातात "टेब्युलर भाग उत्पादनांसह कार्य करणे, संपर्क माहिती".
• पद्धती आणि कोड गटांची अनियंत्रित व्यवस्था. उदाहरणार्थ, इव्हेंट हँडलर एका फॉर्ममध्ये शीर्षस्थानी असू शकतात, दुसऱ्यामध्ये तळाशी असू शकतात, तिसऱ्यामध्ये अजिबात हायलाइट केलेले नाहीत, इ.
• आणि हे सर्व एकाच कॉन्फिगरेशनमध्ये आहे हे विसरू नका.
• होय, अशी कॉन्फिगरेशन आहेत ज्यात "सामान्य, सेवा, सहायक" शब्द नेहमी त्याच ठिकाणी असतात परंतु...

तुम्हाला कोड स्ट्रक्चरची गरज का आहे?

• देखभालीचे सरलीकरण.
• शिकणे सोपे करा.
• रेकॉर्डिंग सामान्य/महत्त्वाचे/यशस्वी तत्त्वे.
• ...तुमचा पर्याय

1C मधील विद्यमान विकास मानक मदत का करत नाही?

व्यवस्थापित फॉर्म लिहिताना शिफारस केलेल्या ITS डिस्क आणि विविध “डेव्हलपर मार्गदर्शक...” मध्ये प्रकाशित तत्त्वे पाहू.

• सर्व्हर कॉल्सची संख्या कमी करा.
• सर्व्हरवर जास्तीत जास्त संगणन.
• संदर्भित नसलेल्या सर्व्हर कॉल्स संदर्भापेक्षा वेगवान असतात.
• क्लायंट-सर्व्हर संप्रेषण लक्षात घेऊन कार्यक्रम.
• आणि असेच.

या घोषणा आहेत ज्या अगदी खऱ्या आहेत, पण त्यांची अंमलबजावणी कशी करायची? कॉल्सची संख्या कशी कमी करायची, क्लायंट-सर्व्हर मोडमध्ये प्रोग्राम करण्याचा अर्थ काय आहे?

डिझाइन नमुने किंवा पिढीचे शहाणपण

क्लायंट-सर्व्हर परस्परसंवाद अनेक दशकांपासून विविध सॉफ्टवेअर तंत्रज्ञानामध्ये वापरला जात आहे. मागील विभागात दिलेल्या प्रश्नांची उत्तरे फार पूर्वीपासून ज्ञात आहेत आणि ती दोन मूलभूत तत्त्वांमध्ये सारांशित केली आहेत.

• दूरस्थ दर्शनी भाग(यापुढे रिमोट ऍक्सेस इंटरफेस म्हणून संदर्भित)
• डेटा ट्रान्सफर ऑब्जेक्ट(यापुढे डेटा ट्रान्सफर ऑब्जेक्ट म्हणून संदर्भित)

मार्टिन फॉलरचा एक शब्द, त्याचे या तत्त्वांचे वर्णन:

• … रिमोट ऍक्सेससाठी संभाव्य हेतू असलेली प्रत्येक ऑब्जेक्ट असणे आवश्यक आहे कमी ग्रॅन्युलॅरिटी इंटरफेस, जे विशिष्ट प्रक्रिया करण्यासाठी आवश्यक कॉलची संख्या कमी करेल. ... इन्व्हॉइस आणि त्यातील सर्व आयटमची स्वतंत्रपणे विनंती करण्याऐवजी, तुम्हाला एकाच विनंतीमध्ये सर्व बीजक आयटम वाचणे आणि अपडेट करणे आवश्यक आहे. हे ऑब्जेक्टच्या संपूर्ण संरचनेवर परिणाम करते...लक्षात ठेवा: रिमोट ऍक्सेस इंटरफेस डोमेन लॉजिक समाविष्ट नाही.
• ...जर मी काळजी घेणारी आई असते, तर मी माझ्या मुलाला नक्कीच सांगेन: "डेटा ट्रान्सफर वस्तू कधीही लिहू नका!" बर्याच बाबतीत, डेटा ट्रान्सफर ऑब्जेक्ट्स पेक्षा जास्त काही नसतात फुगलेला फील्ड सेट... या घृणास्पद राक्षसाचे मूल्य केवळ संभाव्यतेमध्ये आहे एका कॉलमध्ये नेटवर्कवर माहितीचे अनेक तुकडे प्रसारित करा- एक तंत्र जे वितरित प्रणालींसाठी खूप महत्वाचे आहे.

1C प्लॅटफॉर्ममधील टेम्पलेट्सची उदाहरणे

व्यवस्थापित फॉर्म विकसित करताना विकसकासाठी उपलब्ध असलेल्या ऍप्लिकेशन प्रोग्रामिंग इंटरफेसमध्ये या तत्त्वांची अनेक उदाहरणे आहेत.
उदाहरणार्थ, OpenForm() पद्धत, एक सामान्य “रफ” इंटरफेस.
ओपनिंग पॅरामीटर्स = नवीन संरचना("पॅरामीटर1, पॅरामीटर2, पॅरामीटर3", मूल्य1, मूल्य2, मूल्य3); फॉर्म = OpenForm(FormName, Opening Parameters);
v8.1 मध्ये स्वीकारलेल्या शैलीशी तुलना करा.
फॉर्म = GetForm(FormName); Form.Parameter1 = Value1; Form.Parameter2 = Value2; फॉर्म.ओपन();

व्यवस्थापित फॉर्मच्या संदर्भात, अनेक "डेटा ट्रान्सफर ऑब्जेक्ट्स" आहेत. तुम्ही निवडू शकता पद्धतशीरआणि विकसक-परिभाषित.
सिस्टम एक किंवा अधिक डेटा घटकांच्या स्वरूपात क्लायंटवर अनुप्रयोग ऑब्जेक्टचे मॉडेल करतात. फॉर्म तपशीलांच्या संदर्भाशिवाय ते तयार करणे अशक्य आहे.

• डेटा फॉर्म्स स्ट्रक्चर
• डेटा फॉर्म्स कलेक्शन
• डेटा फॉर्मस्ट्रक्चर विथ कलेक्शन
• DataShapesTree

सिस्टम डेटा ट्रान्सफर ऑब्जेक्ट्सचे ऍप्लिकेशन प्रकारांमध्ये रूपांतरण आणि त्याउलट खालील पद्धती वापरून केले जाते:

• ValueInFormData()
• FormDataValue()
• कॉपीफॉर्मडेटा()
• ValueInFormAttributes()
• FormAttributesValue()

विद्यमान सोल्यूशनचे रुपांतर करताना अनेकदा स्पष्ट रूपांतरण वापरले जाते. पद्धती इनपुट पॅरामीटर्सची अपेक्षा करू शकतात (वैशिष्ट्यांचा वापर करा) जसे की FormDataCollection ऐवजी ValueTable, किंवा पद्धत ॲप्लिकेशन ऑब्जेक्टच्या संदर्भात परिभाषित केली गेली आहे आणि फॉर्मवरून थेट कॉलसाठी अनुपलब्ध झाली आहे.
उदाहरण 1C v8.1:
// FillUserCache(DepartmentLink) फॉर्मच्या संदर्भात क्लायंटवर
उदाहरण 1C v8.2:
// फॉर्म ProcessingObject = Form AttributesValue("Object") च्या संदर्भात सर्व्हरवर; ProcessingObject.FillUserCache(DepartmentRef); ValueВFormAttributes(ProcessingObject, "Object");

डेटा ट्रान्सफर ऑब्जेक्ट्स, ज्याची रचना डेव्हलपरद्वारे निर्धारित केली जाते, क्लायंट आणि सर्व्हरवर उपलब्ध असलेल्या प्रकारांचा एक छोटा उपसंच आहे. बऱ्याचदा, खालील बाबींचा वापर पॅरामीटर्स म्हणून केला जातो आणि "खडबडीत" इंटरफेसच्या पद्धतींचा परिणाम होतो:

• आदिम प्रकार (स्ट्रिंग, संख्या, बुलियन)
• रचना
• पत्रव्यवहार
• रचना
• ऍप्लिकेशन ऑब्जेक्ट्सचे दुवे (युनिक आयडेंटिफायर आणि मजकूर प्रतिनिधित्व)

उदाहरण: पद्धत स्थिती बदलण्यासाठी ऑर्डरची सूची स्वीकारते आणि क्लायंटला त्रुटींचे वर्णन परत करते.
&OnServerWithoutContext फंक्शन ServerChangeOrderStatus(Orders, NewStatus) Errors = New Match(); // [ऑर्डर][त्रुटी वर्णन] ऑर्डर सायकल स्टार्ट ट्रान्झॅक्शन(); DocOb = Order.GetObject(); …. इतर क्रिया, केवळ ऑर्डरनेच शक्य नाही... अपवाद Cancel Transaction(); Errors.Insert(ऑर्डर, ErrorDescription()); EndAttempt; एंडसायकल; रिटर्न एरर; EndFunction // ServerChangeOrderStatus()

कोडची रचना

व्यवस्थापित फॉर्म मॉड्यूलने परावर्तित केलेली मुख्य उद्दिष्टे आणि समाधानाकडे जाणे आवश्यक आहे.

• क्लायंट आणि सर्व्हर कोडचे पृथक्करण साफ करा.चला हे विसरू नका की अंमलबजावणीच्या वेळी या दोन परस्परसंवादी प्रक्रिया आहेत, ज्यापैकी प्रत्येकाची उपलब्ध कार्यक्षमता लक्षणीय भिन्न आहे.
• रिमोट ऍक्सेस इंटरफेसची स्पष्ट ओळख, क्लायंटकडून कोणत्या सर्व्हर पद्धती कॉल केल्या जाऊ शकतात आणि कोणत्या करू शकत नाहीत? रिमोट इंटरफेस पद्धतींची नावे "सर्व्हर" उपसर्गाने सुरू होतात. हे आपल्याला कोड वाचताना सर्व्हरवर नियंत्रणाचे हस्तांतरण त्वरित पाहण्याची अनुमती देते आणि संदर्भित मदतीचा वापर सुलभ करते. लक्षात घ्या की अधिकृत शिफारस (ITS) पोस्टफिक्ससह नामकरण पद्धती सुचवते, उदाहरणार्थ, ChangeOrderStatusOnServer(). तथापि, आम्ही पुनरावृत्ती करतो की क्लायंटकडून सर्व सर्व्हर पद्धती कॉल केल्या जाऊ शकत नाहीत, आणि म्हणून संकलन स्थानापेक्षा तार्किक सुलभता अधिक महत्त्वाची आहे. म्हणून, उपसर्ग "सर्व्हर" सह आम्ही क्लायंटसाठी उपलब्ध असलेल्या पद्धतींवरच चिन्हांकित करतो; चला उदाहरण पद्धतीला कॉल करूया ServerChangeOrderStatus().
• वाचनियता.चवीची बाब, जेव्हा मॉड्यूल सर्व्हरवर फॉर्म तयार करण्याच्या प्रक्रियेसह आणि रिमोट ऍक्सेस पद्धतींसह सुरू होते तेव्हा आम्ही ऑर्डर स्वीकारतो.
• देखभालक्षमता.नवीन कोड जोडण्यासाठी एक स्पष्ट स्थान असणे आवश्यक आहे. एक महत्त्वाचा मुद्दा म्हणजे कॉन्फिगरेटरद्वारे स्वयंचलितपणे तयार केलेली पद्धत टेम्पलेट्स मॉड्यूलच्या शेवटी जोडली जातात. फॉर्म घटकांसाठी इव्हेंट हँडलर बहुतेकदा आपोआप तयार केले जात असल्याने, संबंधित ब्लॉक सर्वात शेवटी स्थित असतो, जेणेकरून प्रत्येक हँडलरला मॉड्यूलमधील दुसऱ्या ठिकाणी ड्रॅग करू नये.

खाली मॉड्यूलची मूलभूत रचना आहे जी सूचीबद्ध उद्दिष्टे लागू करते.

• ग्राफिकल पर्याय - अंमलबजावणीचा मुख्य प्रवाह स्पष्टपणे दर्शवतो.
• मजकूर पर्याय नवीन फॉर्म मॉड्यूलमध्ये रचना द्रुतपणे समाविष्ट करण्यासाठी टेम्पलेट डिझाइनचे उदाहरण आहे.

//////////////////////////////////////////////////////////////////////////////// // <(c) Автор=""तारीख=""/> // <Описание> // // //////////////////////////////////////// ////////////////////// मॉड्यूल व्हेरिएबल्स ///////////////// //////////////////////////////////////// ///////// // सर्व्हरवर //******* सर्व्हरवरील घटना ******* आणि सर्व्हरवर तयार केल्यावर सर्व्हर प्रक्रियेवर (अयशस्वी, मानक प्रक्रिया) / /हँडलरची सामग्री घाला प्रक्रिया समाप्त //******* रिमोट ऍक्सेस इंटरफेस ******* //******* सर्व्हरवर व्यवसाय तर्क ******* ///////////////////////////////////////// //////////////////////// ग्राहक आणि सर्व्हरच्या सामान्य पद्धती ////////////// ///////////////////////////////////////// ///// /////// // क्लायंटवर //******* क्लायंटवर व्यवसाय तर्क ******* //******* टीम * ****** //******** क्लायंट इव्हेंट्स ******* //////////////////////// ///////////////////////////////////////// // // मुख्य कार्यक्रम ऑपरेटर

संबंधित प्रश्न

शेवटी, आम्ही क्लायंट-सर्व्हर परस्परसंवाद प्रोग्रामिंग करताना विचार करण्यासाठी उपयुक्त असलेल्या अनेक क्षेत्रांची रूपरेषा देऊ.

• रिमोट ऍक्सेस इंटरफेस अंमलबजावणी पर्याय. असिंक्रोनी, तपशीलाची पातळी...
• कॅशिंग. 1C ने एक अयशस्वी आर्किटेक्चरल निर्णय घेतला, फक्त सामान्य मॉड्यूल्सच्या कॉलिंग पद्धतींच्या स्तरावर कॅशिंगची ओळख करून दिली आणि नियंत्रण क्षमता प्रदान केली नाही (संबंधित वेळ, मागणीनुसार रीसेट).
• निहित सर्व्हर कॉल. तांत्रिक वैशिष्ट्यांबद्दल विसरू नका; क्लायंटवरील अनेक "निरुपद्रवी" ऑपरेशन्स प्लॅटफॉर्मला सर्व्हरशी संपर्क साधण्यास प्रवृत्त करतात.

फॉर्म 1C मध्ये: एंटरप्राइज डेटाबेसमध्ये असलेली माहिती प्रदर्शित आणि संपादित करण्यासाठी आहे. फॉर्म विशिष्ट कॉन्फिगरेशन ऑब्जेक्ट्सचे असू शकतात किंवा त्यांच्यापासून वेगळे अस्तित्वात असू शकतात आणि संपूर्ण ऍप्लिकेशन सोल्यूशनद्वारे वापरले जातात.

उदाहरणार्थ, निर्देशिका नामकरणविशिष्ट हेतूंसाठी वापरले जाणारे अनेक फॉर्म असू शकतात - निर्देशिका घटक संपादित करणे, सूची प्रदर्शित करणे इ.

यासह, विशिष्ट कॉन्फिगरेशन ऑब्जेक्ट्सशी संबंधित नसलेले सामान्य फॉर्म असू शकतात - सामान्य फॉर्म.

मूलभूत फॉर्म

प्रत्येक कॉन्फिगरेशन ऑब्जेक्ट काही मानक क्रिया करण्यासाठी वापरले जाऊ शकते. उदाहरणार्थ, कोणत्याही डिरेक्टरीसाठी तुम्हाला त्यातील घटकांची सूची प्रदर्शित करावी लागेल, निर्देशिकेचे वैयक्तिक घटक प्रदर्शित करावे लागतील, निर्देशिकेचा एक गट प्रदर्शित करा, निर्देशिकेतून घटक आणि घटकांचे गट निवडा. कोणत्याही दस्तऐवजासाठी, अशा क्रियांची सूची खूपच लहान असेल: दस्तऐवजांची सूची पाहणे, दस्तऐवजांच्या सूचीमधून निवडणे आणि स्वतंत्र दस्तऐवज पाहणे.

ॲप्लिकेशन सोल्यूशन ऑब्जेक्ट्सच्या डेटासह अशा मानक क्रिया केल्या जातात याची खात्री करण्यासाठी, त्या प्रत्येकासाठी मूलभूत फॉर्मचा एक संच आहे जो संबंधित क्रिया करताना वापरला जाईल. या ऑब्जेक्टच्या अधीन असलेले कोणतेही फॉर्म मुख्य म्हणून नियुक्त केले जाऊ शकतात. उदाहरणार्थ, निर्देशिकेत नामकरणखालील मूलभूत फॉर्म अस्तित्वात असू शकतात:

आणि दस्तऐवज वस्तू आणि सेवांची पावतीमुख्य फॉर्मची रचना वेगळी असेल:

अशा प्रकारे, जर वापरकर्त्यास निर्देशिका सूची पहायची असेल नामकरणकिंवा कागदपत्रांची यादी वस्तू आणि सेवांची पावती, सिस्टम या ऑब्जेक्ट्ससाठी सूची फॉर्म म्हणून नियुक्त केलेला संबंधित फॉर्म उघडेल.

स्वयं-व्युत्पन्न फॉर्म

1C:Enterprise 8 प्रणालीचे महत्त्वाचे वैशिष्ट्य म्हणजे स्वयं-व्युत्पन्न फॉर्मची यंत्रणा. ही यंत्रणा विकासकाला प्रत्येक कॉन्फिगरेशन ऑब्जेक्टसाठी सर्व संभाव्य फॉर्म तयार करण्यापासून मुक्त करते. विकसकाला फक्त एक नवीन कॉन्फिगरेशन ऑब्जेक्ट जोडण्याची आवश्यकता आहे आणि सिस्टम स्वतःच, वापरकर्त्याच्या कामाच्या योग्य क्षणी, या ऑब्जेक्टमध्ये असलेली माहिती प्रदर्शित करण्यासाठी आवश्यक फॉर्म तयार करेल.

अशाप्रकारे, विकासकाने स्वतःचे ऍप्लिकेशन सोल्यूशन ऑब्जेक्ट्सचे फॉर्म तयार करणे आवश्यक आहे जर त्यांच्यामध्ये सिस्टमद्वारे स्वयंचलितपणे व्युत्पन्न केलेल्या फॉर्ममध्ये फरक (भिन्न डिझाइन किंवा विशिष्ट वर्तन) असणे आवश्यक आहे.

डेटाशी फॉर्म लिंक करणे

फॉर्म विशिष्ट कॉन्फिगरेशन ऑब्जेक्टचा आहे की नाही हे फॉर्ममध्ये प्रदर्शित केलेल्या डेटाची रचना निर्धारित करत नाही. फॉर्म संबंधित आहे हे तथ्य, उदाहरणार्थ, निर्देशिकेशी नामकरण, तुम्हाला या निर्देशिकेसाठी मुख्य फॉर्मपैकी एक म्हणून नियुक्त करण्याची परवानगी देते, परंतु हा फॉर्म कोणता डेटा प्रदर्शित करेल आणि त्याचे वर्तन काय असेल हे कोणत्याही प्रकारे निर्धारित करत नाही.

डेटासह फॉर्म संबद्ध करण्यासाठी, फॉर्म तपशील वापरले जातात, जे फॉर्मद्वारे प्रदर्शित केलेल्या डेटाची सूची दर्शवतात. ते कोणता डेटा प्रदर्शित करतात याची पर्वा न करता सर्व फॉर्म, स्वतःचे वर्तन समान आहे. तथापि, फॉर्म विशेषतांपैकी एक मुख्य विशेषता म्हणून नियुक्त केली जाऊ शकते (ते ठळकपणे हायलाइट केले आहे), अशा परिस्थितीत फॉर्मचे मानक वर्तन आणि त्याच्या गुणधर्मांना मुख्य फॉर्म विशेषता कोणत्या प्रकारावर आहे त्यानुसार पूरक केले जाईल:

उदाहरणार्थ, जर एखादा दस्तऐवज मुख्य फॉर्म विशेषता म्हणून नियुक्त केला असेल वस्तू आणि सेवांची पावती, नंतर फॉर्म बंद करताना, सिस्टम हे दस्तऐवज रेकॉर्डिंग आणि पोस्ट करण्याच्या पुष्टीकरणाची विनंती करेल. तुम्ही फॉर्मची मुख्य विशेषता म्हणून निर्देशिका नियुक्त केल्यास, म्हणा नामकरण, नंतर फॉर्म बंद करताना अशी पुष्टीकरण विनंती दिसणार नाही.

फॉर्मची रचना

फॉर्मचे मुख्य वैशिष्ट्य हे आहे की ते विकसकाने "पिक्सेल बाय पिक्सेल" तपशीलवार रेखाटलेले नाहीत. कॉन्फिगरेशनमधील फॉर्म हे फॉर्मच्या रचनेचे तार्किक वर्णन आहे. आणि जेव्हा फॉर्म प्रदर्शित होतो तेव्हा घटकांची विशिष्ट प्लेसमेंट सिस्टमद्वारे स्वयंचलितपणे केली जाते.

फॉर्मचा प्रदर्शित केलेला भाग (वापरकर्त्यास दृश्यमान) फॉर्म घटक असलेले झाड म्हणून वर्णन केले आहे.

घटक इनपुट फील्ड, चेक बॉक्स, रेडिओ बटणे, बटणे, इत्यादी असू शकतात. याव्यतिरिक्त, घटक हा एक गट असू शकतो ज्यामध्ये इतर घटक समाविष्ट आहेत. एका गटाला फ्रेमसह पॅनेल, पृष्ठे (बुकमार्क), पृष्ठ स्वतः किंवा कमांड पॅनेलसह एक पॅनेल म्हणून प्रस्तुत केले जाऊ शकते. याव्यतिरिक्त, घटक एक सारणी असू शकते, ज्यामध्ये घटक (स्तंभ) देखील समाविष्ट आहेत. घटक रचना फॉर्म कसा दिसेल याचे वर्णन करते.

फॉर्मची सर्व कार्यक्षमता तपशील आणि आदेशांच्या स्वरूपात वर्णन केली आहे. तपशील हा डेटा आहे ज्यासह फॉर्म कार्य करतो आणि आज्ञा म्हणजे केल्या जाणाऱ्या क्रिया. अशा प्रकारे, फॉर्म एडिटरमधील विकसकाने फॉर्ममध्ये आवश्यक तपशील आणि आदेश समाविष्ट करणे आवश्यक आहे, ते प्रदर्शित करणारे फॉर्म घटक तयार करा आणि आवश्यक असल्यास, घटकांची गटांमध्ये व्यवस्था करा.

या तार्किक वर्णनाच्या आधारे, सिस्टम स्वयंचलितपणे वापरकर्त्याला प्रदर्शित करण्यासाठी फॉर्मचे स्वरूप तयार करते. या प्रकरणात, वापरकर्त्यासाठी शक्य तितक्या सोयीस्करपणे फॉर्म घटकांची व्यवस्था करण्यासाठी सिस्टम प्रदर्शित डेटाचे विविध गुणधर्म (उदाहरणार्थ, प्रकार) विचारात घेते.

विकसक विविध सेटिंग्जसह घटकांच्या व्यवस्थेवर प्रभाव टाकू शकतो. हे घटकांचा क्रम निर्धारित करू शकते, इच्छित रुंदी आणि उंची निर्दिष्ट करू शकते. तथापि, सिस्टमला फॉर्म प्रदर्शित करण्यात मदत करण्यासाठी ही काही अतिरिक्त माहिती आहे.

फॉर्ममध्ये, डेव्हलपर केवळ फॉर्मच्या कमांडचाच वापर करू शकत नाही, तर संपूर्ण कॉन्फिगरेशनच्या कमांड इंटरफेसमध्ये वापरल्या जाणाऱ्या जागतिक कमांड देखील वापरू शकतो. याव्यतिरिक्त, पॅरामीटराइझ करण्यायोग्य कमांड तयार करणे शक्य आहे जे वर्तमान फॉर्मचा विशिष्ट डेटा विचारात घेऊन इतर फॉर्म उघडतील. उदाहरणार्थ, हे सध्या इनव्हॉइस फॉर्ममध्ये निवडलेल्या वेअरहाऊसमधील शिल्लक रकमेवर अहवाल कॉल करू शकते.

आपल्या सर्वांना माहित आहे की 1C कंपनीकडे 1C प्लॅटफॉर्मच्या बऱ्याच भिन्न आवृत्त्या होत्या; आम्हाला आता हा लेख लिहिण्याच्या वेळी नवीनतम आवृत्त्यांपैकी एकामध्ये रस असेल, या आवृत्त्या 1C 8.2 आणि 1C 8.3 आहेत. जर तुम्हाला या दोन्ही आवृत्त्यांमध्ये काम करावे लागले असेल तर तुम्ही बहुधा या आवृत्त्यांच्या इंटरफेसमध्ये फरक लक्षात आला, वापरकर्त्यांसाठी ते फक्त देखावा मध्ये भिन्न आहेत. मूलत: एक निवड नियमित किंवा व्यवस्थापित अर्जचालविण्यासाठी कोणते फॉर्म प्रदर्शित करायचे ते सिस्टमला सांगते, नियमित किंवा नियंत्रित, तसेच कोणता अनुप्रयोग क्लायंट डीफॉल्टनुसार वापरला जाईल, जाड किंवा पातळ. क्लायंटबद्दल अधिक तपशीलवार माहितीसाठी, "1C मध्ये जाड आणि पातळ क्लायंट काय आहेत, तसेच त्यांच्यातील फरक" हा लेख वाचा.

नियमित 1C अनुप्रयोग (नियमित फॉर्म, नियमित इंटरफेस, आवृत्ती 1C 8.2)

1C 8.2 मध्ये केवळ कार्य करणे शक्य आहे नियमित फॉर्मसह, नियमित अनुप्रयोग मोडमध्ये. खालील प्रतिमा "नियमित 1C ऍप्लिकेशन" ऑपरेटिंग मोड (नियमित फॉर्म) मध्ये डेटाबेस दर्शवते.

व्यवस्थापित 1C अनुप्रयोग (व्यवस्थापित फॉर्म, व्यवस्थापित इंटरफेस, आवृत्ती 1C 8.3)

1C 8.3 प्लॅटफॉर्मवर आम्ही नियमित फॉर्म (सुसंगतता मोडमध्ये) आणि व्यवस्थापित दोन्हीसह कार्य करू शकतो. शिवाय व्यवस्थापित फॉर्ममध्ये दोन प्रकारचे प्रदर्शन आहेत, हे मानक आणि टॅक्सी आहे. मानक व्यवस्थापित फॉर्मसह 1C 8.3 कॉन्फिगरेशनचे उदाहरण खाली दर्शविले आहे आणि त्यानंतर "टॅक्सी" इंटरफेस दर्शविला आहे.

नियमित आणि व्यवस्थापित 1C अनुप्रयोगामध्ये काय फरक आहे?

आम्ही आधीच शोधले आहे म्हणून नियमित ऍप्लिकेशन आणि व्यवस्थापित ऍप्लिकेशन हे 1C प्रोग्राम लाँच करण्याचे प्रकार आहेत. शिवाय, 1C लाँच प्रकाराच्या मूल्यावर अवलंबून ( नियमित किंवा व्यवस्थापित अर्ज), एक विशिष्ट इंटरफेस डीफॉल्टनुसार लोड केला जाईल ( नियमित किंवा व्यवस्थापित फॉर्म), म्हणून या संकल्पनेसाठी बरेच समानार्थी शब्द आहेत. आम्ही हे लक्षात घेऊ इच्छितो की इंटरफेसमधील फरक खूपच लक्षणीय आहेत; व्यवस्थापित इंटरफेस पूर्णपणे पुन्हा डिझाइन केला गेला आहे. तत्वतः, हे सर्व फरक आहेत जे 1C प्रोग्रामचे सामान्य वापरकर्ते पाहतात. प्रोग्रामरसाठी, व्यवस्थापित इंटरफेसला सुधारित कोड लिहिणे आवश्यक आहे, कारण विकास आधीच 1C 8.3 मध्ये केला गेला आहे, आणि 1C 8.2 मध्ये नाही, त्यामुळे पुढील सर्व परिणाम. कोड क्लायंट आणि सर्व्हरमध्ये देखील विभागलेला असणे आवश्यक आहे; हे कॉन्फिगरेटरमधील योग्य निर्देशांचा वापर करून सूचित केले आहे.

क्ल्युएव्ह व्ही.व्ही.

http://prof1c.kklab.ru

स्विचेससह काम करणे

कृपया साइट सेवेचे सर्व वापरकर्ते विचारात घ्या - मी नवशिक्या विभागात सामग्री पोस्ट करतो!!!

8.2 व्यवस्थापित फॉर्म

व्यवस्थापित फॉर्मच्या वर्तनाचा अभ्यास करताना, प्रोग्रामर किंवा इंटरफेस विकसकांना व्यवस्थापित फॉर्ममध्ये स्विच कुठे आहेत आणि ते फॉर्ममध्ये कसे जोडायचे या प्रश्नाचा सामना करावा लागतो. ही एक छोटी गोष्ट आहे, परंतु हे अप्रिय आहे की अशा क्षुल्लक गोष्टींवर बराच वेळ घालवला जातो, जरी हा वेळ फॉर्म डिझाइन करण्याऐवजी अल्गोरिदम विकसित आणि ऑप्टिमाइझ करण्यासाठी खर्च केला जाऊ शकतो.

तर, प्रश्न समजून घेण्यासाठी एक रिक्त कॉन्फिगरेशन तयार करूया, किंवा कोणतेही वैशिष्ट्यपूर्ण निवडा.
निर्देशिका असलेल्या गटावर जा आणि प्रयोगासाठी नवीन निर्देशिका जोडा. मी हे लक्षात घेऊ इच्छितो की कॉन्फिगरेशनमध्ये मुख्य लाँच मोड असणे आवश्यक आहे - व्यवस्थापित अनुप्रयोग.

तर, एक नवीन डिरेक्टरी तयार करू आणि "Boolian" टाइपसह "Property1" विशेषता जोडू.

आता फॉर्म्स टॅबवर जाऊन नवीन फॉर्म जोडू.

तर, नियंत्रित फॉर्म तयार झाला आहे, आता फॉर्मसह कार्य करू आणि स्विच कुठे आहे ते शोधू.
हा आपला फॉर्म आहे आणि त्यावर आपल्याला आपले प्रॉप्स दिसतात, परंतु ध्वजाच्या रूपात

मग आम्ही काय चूक केली?
नियंत्रणाच्या प्रकारावर स्विच आहे की नाही हे पाहण्यासाठी प्रॉप्सचे गुणधर्म पाहू.
आणि आम्ही पाहतो की स्विच फील्ड येथे नाही! (आम्ही कुठे चुकलो?

वरवर पाहता, फॉर्मवरील नियंत्रणाचा प्रकार डेटा प्रकारावर अवलंबून असतो, चला फॉर्म गुणधर्मांवर, म्हणजे तपशील टॅबवर परत जाऊ आणि आमच्या विशेषताचे गुणधर्म बदलू - म्हणजे त्याचा प्रकार "बूलियन", "नंबर" प्रकारात.

आता कंट्रोलच्या गुणधर्मांकडे परत जाऊ आणि कंट्रोलचा व्ह्यू त्याच्या गुणधर्मांमध्ये जोडला गेला आहे का ते तपासू - - - आणि हुर्रा, आम्हाला तेथे दृश्य दिसत आहे - स्विच फील्ड.

आता फॉर्म पहा, आपण काय पाहतो:

आम्ही पाहतो - 3 डीफॉल्ट मूल्ये, 3 स्विचेस, परंतु आम्हाला त्यापैकी दोन आवश्यक आहेत, पुन्हा विशेषताच्या गुणधर्मांवर जा आणि तेथे "स्तंभांची संख्या" गुणधर्म पहा.

2 साठी - स्तंभांची संख्या - 2 सेट करा.

हे कदाचित थकलेल्या प्रोग्रामरला थोडेसे थांबवू शकते)), परंतु आता त्याला आणि आम्हाला दोघांनाही ते माहित आहे!

8.2 नियमित फॉर्म.

सामान्य फॉर्म मध्ये स्विच सह कंटाळवाणे.
असे काही क्षण असतात, आणि ते घडतात) जेव्हा तुम्हाला काही तयार फॉर्ममध्ये बदल करण्याची आवश्यकता असते, ज्यामध्ये आधीपासून काही स्विच आहेत आणि तुम्हाला या फॉर्ममध्ये दुसरा स्विच जोडण्याची आवश्यकता असते. इथेच एक प्रकारचा कंटाळा येतो, ज्यात बराच वेळ लागतो आणि कोड प्रोग्रामिंगसाठी वेळ नाही - परंतु वापरकर्त्यासाठी हे स्विचेस प्रदर्शित करण्यासाठी वेळ वाया जातो.

तर एक उदाहरण पाहू. 1C UPP मध्ये पावत्या समायोजित करण्यासाठी असा एक दस्तऐवज आहे - तो निश्चितपणे अस्तित्वात आहे. आम्हाला एकदा त्यात स्विच जोडणे आवश्यक होते जेणेकरून अकाउंटिंगसाठी थोड्या वेगळ्या नोंदी काढल्या जातील. काय अडचण आहे, असे दिसते की आपण केलेच पाहिजे, आपण केले पाहिजे, आपण ते करू. परंतु या फॉर्ममध्ये आधीपासूनच 2 रेडिओ बटणे आहेत.

हा फॉर्म कसा दिसतो ज्यामध्ये आपल्याला अधिक स्विच जोडण्याची आवश्यकता आहे

प्रगत टॅबवर, आम्हाला आणखी दोन रेडिओ बटणे ठेवायची आहेत. म्हणून पहिली पायरी म्हणजे धैर्याने आम्हाला आवश्यक असलेल्या ठिकाणी नवीन नियंत्रण घटक जोडणे आणि ते समाविष्ट करणे.

असे दिसते की सर्वकाही सोपे आहे. आम्ही "नंबर" प्रकारासह एक नवीन विशेषता तयार करतो आणि 2 स्विच समाविष्ट करतो, त्यापैकी एक विशेषतामध्ये डेटा लिहिण्यास सक्षम असेल आणि दुसरा नाही.

एक नवीन नियंत्रण घटक जोडा - स्विच करा, स्विचची संख्या आणि वर्णनासह टेबलमध्ये स्विच2 जोडा, गटामध्ये प्रथम स्विच1 सेट करा आणि ओके दाबा. तयार केलेली नियंत्रणे फॉर्मवर ठेवा. आम्ही डेटाबेस कॉन्फिगरेशन (F7) अद्यतनित करतो आणि ते डीबगिंगसाठी चालवतो.

कार्यान्वित करताना (1C:एंटरप्राइझ मोडमध्ये नवीन दस्तऐवज तयार करताना), आपण पाहतो की आपण स्विच2 वर कितीही क्लिक करण्याचा प्रयत्न केला तरीही काहीही होत नाही. घटक जसे पाहिजे तसे कार्य करत नाहीत. येथे एक युक्ती आहे.
कॉन्फिगरेटरवर परत या. मेनू आयटम फॉर्म निवडा -> ट्रॅव्हर्सल ऑर्डर सेट करा... (स्क्रीनवर फॉर्म उघडा असणे महत्वाचे आहे)

आमचे स्विच कार्य करण्यासाठी, तुम्ही स्वयंचलित ऑर्डर खंडित करणे आणि मॅन्युअलला सहमती देणे आवश्यक आहे. आणि ते फॉर्ममध्ये ठेवा जेणेकरून आमचे स्विच एकामागून एक क्रमाने जातील.

ठीक आहे. कॉन्फिगरेशन अपडेट करा आणि ते चालवण्याचा प्रयत्न करा.
मस्त. सर्व काही काम केले.

याव्यतिरिक्त - व्हिडिओ (ध्वनीशिवाय, सर्वकाही स्पष्ट आहे)