1C 8.2 में बाहरी घटक

परिचय

यह लेख "1 सी: एंटरप्राइज" सिस्टम में बाहरी घटकों के काम का एक विचार देता है।
कार्य के फ़ाइल संस्करण के साथ विंडोज ऑपरेटिंग सिस्टम पर चलने वाले "1C: एंटरप्राइज" सिस्टम संस्करण 8.2 के लिए एक बाहरी घटक विकसित करने की प्रक्रिया दिखाई जाएगी। यह कार्य विकल्प छोटे व्यवसायों के लिए डिज़ाइन किए गए अधिकांश समाधानों में उपयोग किया जाता है। VK C ++ प्रोग्रामिंग भाषा में लागू किया जाएगा।

बाहरी घटक "1C: एंटरप्राइज"

"IC: एंटरप्राइज" एक विस्तार योग्य प्रणाली है। सिस्टम की कार्यक्षमता का विस्तार करने के लिए, बाहरी घटकों (वीके) का उपयोग किया जाता है। डेवलपर के दृष्टिकोण से, VC एक बाहरी वस्तु है जिसमें गुण और विधियाँ हैं, और यह 1C: एंटरप्राइज़ सिस्टम द्वारा प्रसंस्करण के लिए घटनाओं को भी उत्पन्न कर सकता है।
बाहरी घटकों का उपयोग उन समस्याओं के एक वर्ग को हल करने के लिए किया जा सकता है जो 1 सी में निर्मित प्रोग्रामिंग भाषा का उपयोग करके लागू करना मुश्किल या असंभव है: एंटरप्राइज। विशेष रूप से, जिन कार्यों के लिए ऑपरेटिंग सिस्टम के साथ निम्न-स्तरीय इंटरैक्शन की आवश्यकता होती है, उदाहरण के लिए, विशिष्ट उपकरणों के साथ काम करने के लिए, इस वर्ग के लिए जिम्मेदार ठहराया जा सकता है।
1C: एंटरप्राइज़ सिस्टम बाहरी घटकों को बनाने के लिए दो तकनीकों का उपयोग करता है:

• देशी एपीआई का उपयोग करना
• COM तकनीक का उपयोग करना

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

वीके संरचना

1C का बाहरी घटक: एंटरप्राइज़ सिस्टम को DLL लाइब्रेरी के रूप में प्रस्तुत किया गया है। लाइब्रेरी कोड IComponentBase वंशज वर्ग का वर्णन करता है। निर्मित वर्ग में, बाहरी घटक के कार्यों के कार्यान्वयन के लिए जिम्मेदार तरीकों को परिभाषित किया जाना चाहिए। सामग्री के प्रस्तुतीकरण के दौरान नीचे दिए गए तरीकों के बारे में अधिक विस्तार से वर्णन किया जाएगा।

डेमो VK लॉन्च करें

उद्देश्य:

1. ITS सदस्यता के साथ आपूर्ति की गई बाहरी घटक का निर्माण करें और 1C में बाहरी घटक तंत्र की बुनियादी क्षमताओं को प्रदर्शित करने के लिए डिज़ाइन किया गया
2. डेमो घटक को 1C कॉन्फ़िगरेशन से कनेक्ट करें
3. घोषित कार्यों की सही कार्यक्षमता सुनिश्चित करें

संकलन

डेमो वीके निर्देशिका में ITS सदस्यता डिस्क पर स्थित है "/ VNCOMP82 / उदाहरण / NativeAPI"।
डेमो VK के निर्माण के लिए हम Microsoft Visual Studio 2008 का उपयोग करेंगे। इस उत्पाद के अन्य संस्करण उपयोग किए गए Visual Studio प्रोजेक्ट प्रारूप का समर्थन नहीं करते हैं।

AddInNative प्रोजेक्ट खोलें। प्रोजेक्ट सेटिंग्स में, हम प्रोजेक्ट को बनाने के लिए आवश्यक हेडर फ़ाइलों के साथ डायरेक्टरी को जोड़ते हैं। डिफ़ॉल्ट रूप से, वे / VNCOMP82 / निर्देशिका में ITS ड्राइव पर स्थित हैं।
असेंबली का परिणाम फ़ाइल /bind/AddInNative.dll है । यह 1 सी विन्यास से जुड़ने के लिए संकलित पुस्तकालय है।

1C कॉन्फ़िगरेशन के लिए वीके कनेक्शन

एक खाली 1C विन्यास बनाएँ।
निम्नलिखित प्रबंधित मॉड्यूल के लिए कोड है।

 ;  () ("...\bind\AddInNative.dll", "DemoVK", .Native);  = ("AddIn.DemoVK.AddInNativeExtension");  

यदि 1 सी कॉन्फ़िगरेशन शुरू करते समय कोई त्रुटि रिपोर्ट नहीं की गई थी, तो वीके सफलतापूर्वक जुड़ा हुआ था।
उपरोक्त कोड को निष्पादित करने के परिणामस्वरूप, डेमोकॉम ऑब्जेक्ट ऑब्जेक्ट कॉन्फ़िगरेशन की वैश्विक दृश्यता में दिखाई देता है, जिसमें गुण और विधियां हैं जो बाहरी घटक के कोड में परिभाषित हैं।

एम्बेडेड कार्यक्षमता का प्रदर्शन

डेमो वीके के प्रदर्शन की जांच करें। ऐसा करने के लिए, कुछ गुणों को सेट करने और पढ़ने का प्रयास करें, कुछ VK विधियों को कॉल करें, और VK संदेश को भी प्राप्त करें और संसाधित करें।
ITS डिस्क पर दिए गए प्रलेखन में डेमो VK की निम्न कार्यक्षमता बताई गई है:

1. एक घटक वस्तु की स्थिति को नियंत्रित करना
   विधियाँ: सक्षम , अक्षम करें
   गुण: शामिल हैं
2. समय पर नियंत्रण
   हर सेकंड, घटक 1C को संदेश भेजता है: घटक , टाइमर पैरामीटर और सिस्टम क्लॉक काउंटर की लाइन के साथ एंटरप्राइज सिस्टम।
   तरीके: StartTimer , StopTimer
   गुण: हाँ टाइमर
3. ShowInStatusStroke विधि, जो विधि बार में पैरामीटर के रूप में विधि को दिए गए पाठ को प्रदर्शित करती है
4. विधि डाउनलोड चित्र । निर्दिष्ट फ़ाइल से एक छवि को लोड करता है और इसे 1 सी में स्थानांतरित करता है: बाइनरी डेटा के रूप में एंटरप्राइज सिस्टम।

हम इन कार्यों के संचालन की पुष्टि करेंगे। ऐसा करने के लिए, निम्नलिखित कोड निष्पादित करें:

  ;  () (...);  = ("AddIn.DemoVK.AddInNativeExtension"); .(); (.); .(); (.); .();   (, , ) ( + " " +  + " " + );  

कॉन्फ़िगरेशन शुरू करने का परिणाम छवि में दिखाया गया है

"संदेश" पैनल डेमोकॉम को कॉल के परिणाम प्रदर्शित करता है। अक्षम करें () और डेमोकॉम । सक्षम करें () के तरीके। एक ही पैनल पर बाद की पंक्तियों में क्रमशः वीसी - सोर्स , इवेंट और डेटा से प्राप्त संदेशों के प्रसंस्करण के परिणाम होते हैं।

बाहरी घटक का मनमाना नाम

कार्य: किसी भी बाहरी घटक का नाम बदलें।
पिछले अनुभाग में AddInNativeExtension पहचानकर्ता का उपयोग किया गया था, जिसका अर्थ समझाया नहीं गया था। इस स्थिति में, AddInNativeExtension एक्सटेंशन का नाम है।
VC कोड में, RegisterExtensionAs विधि को परिभाषित किया गया है, जो उस नाम को लौटाता है जो सिस्टम में वीसी के बाद के पंजीकरण के लिए आवश्यक है 1C: एंटरप्राइज़ सिस्टम। एक पहचानकर्ता को निर्दिष्ट करने की सिफारिश की जाती है जो कुछ हद तक बाहरी घटक के सार को प्रकट करता है।
परिवर्तित नाम के साथ RegisterExtensionAs विधि का पूरा कोड यहां दिया गया है:

 bool CAddInNative::RegisterExtensionAs(WCHAR_T** wsExtensionName) { wchar_t *wsExtension = L"SomeName"; int iActualSize = ::wcslen(wsExtension) + 1; WCHAR_T* dest = 0; if (m_iMemory) { if(m_iMemory->AllocMemory((void**)wsExtensionName, iActualSize * sizeof(WCHAR_T))) ::convToShortWchar(wsExtensionName, wsExtension, iActualSize); return true; } return false; } 

उपरोक्त उदाहरण में, VK नाम को SomeName में बदल दिया गया है। फिर वीसी को जोड़ने पर, आपको एक नया नाम बताना होगा:

  = ("AddIn.DemoVK.SomeName"); 

वीके की संपत्तियों की सूची का विस्तार

उद्देश्य:

1. वीसी संपत्तियों के कार्यान्वयन का अन्वेषण करें
2. एक स्ट्रिंग प्रकार की संपत्ति को पढ़ने योग्य और लिखने योग्य जोड़ें
3. स्ट्रिंग प्रकार का एक पठन-लेखन गुण जोड़ें जो अंतिम संपत्ति सेट के डेटा प्रकार को संग्रहीत करता है। संपत्ति मूल्य सेट करते समय, कोई कार्रवाई नहीं की जाती है
4. सुनिश्चित करें कि किए गए परिवर्तन काम कर रहे हैं।

निर्मित घटक के गुणों को निर्धारित करने के लिए, डेवलपर को AddInNative.cpp लाइब्रेरी के कोड में निम्नलिखित विधियों को लागू करने की आवश्यकता है:
GetNProps
इस विस्तार के गुणों की संख्या लौटाता है, 0 - गुणों की अनुपस्थिति में
FindProp
उस प्रॉपर्टी का सीरियल नंबर लौटाता है, जिसका नाम मापदंडों में दिया गया है
GetPropName
संपत्ति का नाम उसके सीरियल नंबर और प्रेषित भाषा पहचानकर्ता द्वारा लौटाता है
GetPropVal
निर्दिष्ट सीरियल नंबर के साथ संपत्ति का मूल्य लौटाता है
SetPropVal
निर्दिष्ट सीरियल नंबर के साथ संपत्ति का मूल्य निर्धारित करता है
IsPropReadable
निर्दिष्ट सीरियल नंबर के साथ संपत्ति को पढ़ने की क्षमता के झंडे को वापस करता है
IsPropWritable
निर्दिष्ट सीरियल नंबर के साथ गुणों को लिखने की क्षमता के झंडे को वापस लौटाता है

मापदंडों की एक सूची सहित विधियों का एक पूरा विवरण, ITS डिस्क पर आपूर्ति किए गए प्रलेखन में विस्तार से वर्णित है।
CAddInNative वर्ग के उपरोक्त तरीकों के कार्यान्वयन पर विचार करें।
डेमो VK में, 2 गुण परिभाषित किए गए हैं: सक्षम और IsTimer ( IsEnabled और IsTimerPresent )।
लाइब्रेरी कोड के वैश्विक दायरे में दो सरणियों को परिभाषित किया गया है:

 static wchar_t *g_PropNames[] = {L"IsEnabled", L"IsTimerPresent"}; static wchar_t *g_PropNamesRu[] = {L"", L""}; 

जो रूसी और अंग्रेजी संपत्ति के नाम संग्रहीत करते हैं। शीर्ष लेख फ़ाइल AddInNative.h गणन को परिभाषित करता है:

 enum Props { ePropIsEnabled = 0, ePropIsTimerPresent, ePropLast // Always last }; 

ePropIsEnabled और ePropIsTimerPresent , क्रमशः, 0 और 1 के मान के साथ संपत्ति सीरियल नंबर को सार्थक पहचानकर्ताओं के साथ बदलने के लिए उपयोग किया जाता है। 2 के मान के साथ एक ePropLast का उपयोग गुणों की संख्या (GetNProps विधि का उपयोग करके) प्राप्त करने के लिए किया जाता है। ये नाम केवल घटक कोड के अंदर उपयोग किए जाते हैं और बाहर से पहुंच योग्य नहीं होते हैं।
FindProp और GetPropName विधियाँ g_PropNames और g_PropNamesRu सरणियाँ खोजती हैं ।
लायब्रेरी मॉड्यूल में फ़ील्ड मानों को संग्रहीत करने के लिए, CAddInNative वर्ग उन गुणों को परिभाषित करता है जो घटक गुणों का मान संग्रहीत करते हैं। GetPropVal और SetPropVal विधियाँ क्रमशः लौटती हैं और इन गुणों का मान निर्धारित करती हैं।
IsPropReadable और IsPropWritable विधियाँ , ट्रेजरी या असत्य दोनों को लौटाती हैं , जो कि एप्लीकेशन लॉजिक के अनुसार संपत्ति की उत्तीर्ण क्रम संख्या के आधार पर होती है।
मनमानी संपत्ति जोड़ने के लिए, आपको यह करना होगा:

1. G_PropNames और g_PropNamesRu सरणियों में जोड़ी जाने वाली संपत्ति का नाम जोड़ें ( AddInNative.cpp फ़ाइल)
2. प्रॉप एन्यूमरेशन ( AddInNative.h फ़ाइल) में ePropLast से पहले एक नाम जोड़ें जो विशिष्ट रूप से जोड़े जा रही संपत्ति की पहचान करता है
3. संपत्ति मूल्यों को संग्रहीत करने के लिए मेमोरी व्यवस्थित करें (संबंधित मानों को संग्रहीत करने के लिए घटक मॉड्यूल फ़ील्ड बनाएं)
4. पिछले चरण में आवंटित मेमोरी के साथ सहभागिता करने के लिए GetPropVal और SetPropVal विधियों में परिवर्तन करें
5. एप्लिकेशन लॉजिक के अनुसार, IsPropReadable और IsPropWritable के तरीकों में बदलाव करें

पैराग्राफ 1, 2, 5 को स्पष्ट करने की आवश्यकता नहीं है। लेख में परिशिष्ट का अध्ययन करके इन चरणों के कार्यान्वयन का विवरण पाया जा सकता है।
परीक्षण गुण टेस्ट और टाइप टेस्ट को नाम दें। फिर, पैराग्राफ 1 के परिणामस्वरूप, हमारे पास:

 static wchar_t *g_PropNames[] = {L"IsEnabled", L"IsTimerPresent", L"Test", L"TestType"}; static wchar_t *g_PropNamesRu[] = {L"", L"", L"", L""}; 

गणना प्रॉप्स की तरह दिखेगा:

  enum Props { ePropIsEnabled = 0, ePropIsTimerPresent, ePropTest1, ePropTest2, ePropLast // Always last }; 

कोड को सरल बनाने के लिए, हम STL C ++ का उपयोग करेंगे। विशेष रूप से, WCHAR स्ट्रिंग्स के साथ काम करने के लिए, हम wstring लाइब्रेरी को कनेक्ट करेंगे।
परीक्षण विधि के मान को बचाने के लिए, CAddInNative वर्ग के दायरे में एक निजी क्षेत्र को परिभाषित करें:

 string test1; 

1C: एंटरप्राइज़ और बाहरी घटकों के बीच स्ट्रिंग पैरामीटर को स्थानांतरित करने के लिए, 1C: एंटरप्राइज़ मेमोरी प्रबंधक का उपयोग किया जाता है। उनके काम पर अधिक विस्तार से विचार करें। क्रमशः मेमोरी और आवंटित करने के लिए, ImemoryManager.h फ़ाइल में परिभाषित AllocMemory और FreeMemory फ़ंक्शन का उपयोग किया जाता है । यदि आवश्यक हो, स्ट्रिंग पैरामीटर को 1 सी पास करें: एंटरप्राइज सिस्टम, बाहरी घटक को AllocMory फ़ंक्शन को कॉल करके इसके लिए मेमोरी आवंटित करनी चाहिए। उसका प्रोटोटाइप इस प्रकार है:

 virtual bool ADDIN_API AllocMemory (void** pMemory, unsigned long ulCountByte) = 0; 

जहां pMemory उस सूचक का पता है जिसमें आवंटित मेमोरी का पता रखा जाएगा,
ulCountByte - आवंटित स्मृति का आकार।
एक स्ट्रिंग के लिए मेमोरी आवंटित करने का एक उदाहरण:

 WCHAR_T *t1 = NULL, *test = L"TEST_STRING"; int iActualSize = wcslen(test1)+1; m_iMemory->AllocMemory((void**)&t1, iActualSize * sizeof(WCHAR_T)); ::convToShortWchar(&t1, test1, iActualSize); 

स्ट्रिंग डेटा प्रकारों के साथ काम करने की सुविधा के लिए, हम wstring_to_p फ़ंक्शन का वर्णन करते हैं। यह एक पैरामीटर के रूप में एक wstring स्ट्रिंग प्राप्त करता है। फ़ंक्शन का परिणाम भरा tVariant संरचना है। समारोह कोड:

 bool CAddInNative::wstring_to_p(std::wstring str, tVariant* val) { char* t1; TV_VT(val) = VTYPE_PWSTR; m_iMemory->AllocMemory((void**)&t1, (str.length()+1) * sizeof(WCHAR_T)); memcpy(t1, str.c_str(), (str.length()+1) * sizeof(WCHAR_T)); val -> pstrVal = t1; val -> strLen = str.length(); return true; } 

फिर GetPropVal विधि के स्विच स्टेटमेंट का संबंधित केस सेक्शन फॉर्म लेता है:

 case ePropTest1: wstring_to_p(test1, pvarPropVal); break; 

सेटप्रॉपवेल तरीके:

  case ePropTest1: if (TV_VT(varPropVal) != VTYPE_PWSTR) return false; test1 = std::wstring((wchar_t*)(varPropVal -> pstrVal)); break; 

दूसरी संपत्ति को लागू करने के लिए, CaddInNative वर्ग के एक क्षेत्र को परिभाषित करें

 uint8_t last_type; 

जिसमें हम अंतिम संचरित मूल्य के प्रकार को बचाएंगे। ऐसा करने के लिए, CaddInNative :: SetPropVal विधि में कमांड जोड़ें:

 last_type = TV_VT(varPropVal); 

अब, जब हम दूसरी संपत्ति के मूल्यों को पढ़ने का अनुरोध करते हैं, तो हम last_type के मान को वापस करेंगे, जो कि संकेतित कार्य द्वारा आवश्यक है।
किए गए परिवर्तनों की संचालनशीलता की जाँच करें।
ऐसा करने के लिए, हम फॉर्म में 1C कॉन्फ़िगरेशन की उपस्थिति लाते हैं:

  ;  () ("...", "DemoVK", .Native);  = ("AddIn.DemoVK.SomeName"); . = 1; ((.)); . = ""; ((.)); . = ""; ((.)); ((.));  

लॉन्च के परिणामस्वरूप, हमें संदेशों का क्रम मिलता है:
3


22

दूसरा और तीसरा संदेश पिछले चरण में सेट की गई संपत्ति को पढ़ने का परिणाम है। पहले और दूसरे संदेशों में अंतिम सेट संपत्ति के प्रकार का एक कोड होता है। 3 एक पूर्णांक मान, 22 से एक स्ट्रिंग मान से मेल खाती है। प्रकार और उनके कोड का पत्राचार type.h फ़ाइल में सेट किया गया है, जो ITS डिस्क पर स्थित है।

विधियों की सूची का विस्तार

उद्देश्य:

1. निम्नलिखित कार्यक्षमता के साथ बाहरी घटक की कार्यक्षमता बढ़ाएँ:
2. बाहरी घटक विधियों को लागू करने के तरीकों का अन्वेषण करें
3. फ़ंक्शन विधि Funkts1 जोड़ें, जो एक पैरामीटर ("पैरामीटर 1" और "पैरामीटर 2") के रूप में दो लाइनें लेता है। परिणामस्वरूप, प्रपत्र की एक स्ट्रिंग: "जाँच करें। पैरामीटर 1, पैरामीटर 2 »
4. सुनिश्चित करें कि किए गए परिवर्तन काम कर रहे हैं।

निर्मित घटक के तरीकों को निर्धारित करने के लिए, डेवलपर को AddInNative लाइब्रेरी के कोड में निम्नलिखित विधियों को लागू करने की आवश्यकता है:
GetNMethods , FindMethod , GetMethodName
तरीकों की संख्या क्रमशः प्राप्त करने के लिए बनाया गया है, विधि की संख्या और नाम के लिए खोज करें। गुणों के लिए इसी तरीके के समान।
GetNParams
निर्दिष्ट अनुक्रम संख्या के साथ विधि मापदंडों की संख्या लौटाता है; यदि इस संख्या के साथ विधि अनुपस्थित है या कोई पैरामीटर नहीं है, तो रिटर्न 0 है
GetParamDefValue
निर्दिष्ट विधि के निर्दिष्ट पैरामीटर का डिफ़ॉल्ट मान लौटाता है
HasRetVal
रिटर्न वैल्यू के निर्दिष्ट सीरियल नंबर के साथ एक विधि की उपस्थिति का झंडा लौटाता है: रिटर्न वैल्यू वाले तरीकों के लिए सही और गलत अन्यथा
CallAsProc
निर्दिष्ट अनुक्रम संख्या के साथ एक विधि निष्पादित करता है। यदि विधि गलत आती है , तो रनटाइम त्रुटि होती है और 1C का निष्पादन: एंटरप्राइज़ मॉड्यूल समाप्त हो जाता है। मापदंडों की एक सरणी के लिए मेमोरी 1 सी: एंटरप्राइज़ द्वारा आवंटित और मुक्त की जाती है।
CallAsFunc
निर्दिष्ट अनुक्रम संख्या के साथ एक विधि निष्पादित करता है। यदि विधि गलत आती है , तो रनटाइम त्रुटि होती है और 1C का निष्पादन: एंटरप्राइज़ मॉड्यूल समाप्त हो जाता है। मापदंडों की एक सरणी के लिए मेमोरी 1 सी आवंटित की जाती है: एंटरप्राइज। यदि रिटर्न मान टाइप स्ट्रिंग या बाइनरी डेटा का है, तो घटक मेमोरी मैनेजर के AllocMemory फ़ंक्शन के साथ मेमोरी आवंटित करता है, वहां डेटा लिखता है, और इस पते को संरचना के संबंधित क्षेत्र में संग्रहीत करता है। 1C: एंटरप्राइज FreeMemory पर कॉल करके इस मेमोरी को फ्री करेगा।
मापदंडों की एक सूची सहित विधियों का एक पूरा विवरण, ITS डिस्क पर आपूर्ति किए गए प्रलेखन में विस्तार से वर्णित है।
ऊपर वर्णित विधियों के कार्यान्वयन पर विचार करें।
घटक कोड में, दो सरणियों को परिभाषित किया गया है:

 static wchar_t *g_MethodNames[] = {L"Enable", L"Disable", L"ShowInStatusLine", L"StartTimer", L"StopTimer", L"LoadPicture"}; static wchar_t *g_MethodNamesRu[] = {L"", L"", L"", L"", L"", L""}; 

और लिस्टिंग:

 enum Methods { eMethEnable = 0, eMethDisable, eMethShowInStatusLine, eMethStartTimer, eMethStopTimer, eMethLoadPicture, eMethLast // Always last }; 

वे GetNMethods , FindMethod, और GetMethodName फ़ंक्शंस में गुणों के वर्णन के समान उपयोग किए जाते हैं।
GetNParams , GetParamDefValue , HasRetVal पद्धतियां एक स्विच को लागू करती हैं, जो पारित किए गए मापदंडों और आवेदन तर्क के आधार पर, आवश्यक मान लौटाता है। अपने कोड में HasRetVal विधि में केवल उन विधियों की एक सूची है जो एक परिणाम दे सकते हैं। उनके लिए, यह सच है । सभी स्टील विधियों के लिए, झूठी लौटा दी जाती है।
CallAsProc और CallAsFunc विधियों में सीधे निष्पादन योग्य विधि कोड होता है।
एक विधि जोड़ने के लिए जिसे केवल एक फ़ंक्शन के रूप में कहा जा सकता है, आपको बाहरी घटक के स्रोत कोड में निम्नलिखित परिवर्तन करने की आवश्यकता है:

1. विधि का नाम g_MethodNames और g_MethodNamesRu सरणियों में जोड़ें ( AddInNative.cn फ़ाइल)
2. विधियाँ गणना के लिए एक सार्थक विधि पहचानकर्ता जोड़ें ( AddInNative.h फ़ाइल)
3. प्रोग्राम तर्क के अनुसार GetNParams फ़ंक्शन के कोड में परिवर्तन करें
4. यदि आवश्यक हो, तो विधि पैरामीटर के डिफ़ॉल्ट मानों का उपयोग करना चाहते हैं, तो GetParamDefValue विधि कोड में परिवर्तन करें।
5. HasRetVal फ़ंक्शन में परिवर्तन करें
6. सीधे निष्पादन योग्य विधि कोड रखकर CallAsProc या CallAsFunc फ़ंक्शन के तर्क में परिवर्तन करें

यहाँ g_MethodNames और g_MethodNamesRu सरणियाँ हैं , साथ ही विधियाँ शामिल हैं :

 static wchar_t *g_MethodNames[] = {L"Enable", L"Disable", L"ShowInStatusLine", L"StartTimer", L"StopTimer", L"LoadPicture", L"Test"}; static wchar_t *g_MethodNamesRu[] = {L"", L"", L"", L"", L"", L"", L""}; 

  enum Methods { eMethEnable = 0, eMethDisable, eMethShowInStatusLine, eMethStartTimer, eMethStopTimer, eMethLoadPicture, eMethTest, eMethLast // Always last }; 

आइए GetNProps फ़ंक्शन को संपादित करें ताकि यह टेस्ट विधि के मापदंडों की संख्या लौटाए:

 long CAddInNative::GetNParams(const long lMethodNum) { switch(lMethodNum) { case eMethShowInStatusLine: return 1; case eMethLoadPicture: return 1; case eMethTest: return 2; default: return 0; } return 0; } 

चलो CAddInNative में परिवर्तन करें :: GetParamDefValue फ़ंक्शन :

 bool CAddInNative::GetParamDefValue(const long lMethodNum, const long lParamNum, tVariant *pvarParamDefValue) { TV_VT(pvarParamDefValue)= VTYPE_EMPTY; switch(lMethodNum) { case eMethEnable: case eMethDisable: case eMethShowInStatusLine: case eMethStartTimer: case eMethStopTimer: case eMethTest: // There are no parameter values by default break; default: return false; } return false; } 

अतिरिक्त लाइन के लिए धन्यवाद

 case eMethTest: 

एक या अधिक तर्कों के अभाव में, संबंधित मापदंडों का एक खाली मान होगा ( VTYPE_EMPTY )। यदि आपको पैरामीटर के लिए डिफ़ॉल्ट मान की आवश्यकता है, तो आपको इसे CAddInNative के स्विच स्टेटमेंट :: GetParamDefValue फ़ंक्शन के eMethTest अनुभाग में सेट करना होगा।
चूंकि टेस्ट विधि एक मान लौटा सकती है, इसलिए HasRetVal फ़ंक्शन कोड में परिवर्तन करना आवश्यक है:

 bool CAddInNative::HasRetVal(const long lMethodNum) { switch(lMethodNum) { case eMethLoadPicture: case eMethTest: return true; default: return false; } return false; } 

और CallAsFunc फ़ंक्शन के लिए निष्पादन योग्य विधि कोड जोड़ें:

 bool CAddInNative::CallAsFunc(const long lMethodNum, tVariant* pvarRetValue, tVariant* paParams, const long lSizeArray) { ... std::wstring s1, s2; switch(lMethodNum) { case eMethLoadPicture: ... break; case eMethTest: if (!lSizeArray || !paParams) return false; s1 = (paParams) -> pwstrVal; s2 = (paParams+1) -> pwstrVal; wstring_to_p(std::wstring(s1+s2), pvarRetValue); ret = true; break; } return ret; } 

घटक को संकलित करें और कॉन्फ़िगरेशन कोड को फॉर्म में लाएं:

  ;  () ("...", "DemoVK", .Native);  = ("AddIn.DemoVK.SomeName");  = .(", ", "!"); ();  

कॉन्फ़िगरेशन शुरू करने के बाद, हमें संदेश प्राप्त होगा: "हैलो वर्ल्ड!", जो इंगित करता है कि विधि सफलतापूर्वक काम की है।

घड़ी

उद्देश्य:

1. डेमो वीके में टाइमर कार्यान्वयन जानें
2. "StartTimer" विधि को संशोधित करें, टाइमर अंतराल (मिलीसेकंड में) मापदंडों में पारित करने की क्षमता जोड़ रहा है
3. सुनिश्चित करें कि किए गए परिवर्तन काम कर रहे हैं।

WinAPI में, आप समय के साथ काम करने के लिए WM_TIMER संदेश का उपयोग कर सकते हैं। यह संदेश आपके प्रोग्राम में उस समय अंतराल पर भेजा जाएगा जो आपने टाइमर बनाते समय सेट किया था।
टाइमर बनाने के लिए, SetTimer फ़ंक्शन का उपयोग करें:

 UINT SetTimer(HWND hWnd, //   UINT nIDevent, //  ()  UINT nElapse, //  TIMERPROC lpTimerFunc); //    

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

 void __stdcall TimerProc (HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime) 

एक डेमो वीके में एक टाइमर कार्यान्वयन पर विचार करें।
चूंकि हम विंडोज परिवार के एक ओएस के लिए एक बाहरी घटक विकसित करने की प्रक्रिया पर विचार कर रहे हैं, हम अन्य ऑपरेटिंग सिस्टम में टाइमर के कार्यान्वयन पर विचार नहीं करेंगे। जीएनयू / लिनक्स के लिए, विशेष रूप से, सेटटाइमर और टिमरप्रोक फ़ंक्शन के सिंटैक्स में कार्यान्वयन अलग-अलग होगा।
निष्पादन योग्य कोड में, सेटटीमर विधि कहा जाता है , जिसके लिए MyTimerProc फ़ंक्शन पारित किया जाता है :

 m_uiTimer = ::SetTimer(NULL,0,100,(TIMERPROC)MyTimerProc); 

निर्मित टाइमर की पहचानकर्ता को m_uiTimer चर में रखा गया है ताकि इसे बाद में अक्षम किया जा सके।
MyTimerProc फ़ंक्शन निम्नानुसार है:

 VOID CALLBACK MyTimerProc( HWND hwnd, // handle of window for timer messages UINT uMsg, // WM_TIMER message UINT idEvent, // timer identifier DWORD dwTime // current system time ) { if (!pAsyncEvent) return; wchar_t *who = L"ComponentNative", *what = L"Timer"; wchar_t *wstime = new wchar_t[TIME_LEN]; if (wstime) { wmemset(wstime, 0, TIME_LEN); ::_ultow(dwTime, wstime, 10); pAsyncEvent->ExternalEvent(who, what, wstime); delete[] wstime; } } 

फ़ंक्शन का सार यह है कि बाहरी विधि को कहा जाता है, जो 1 सी: एंटरप्राइज सिस्टम को एक संदेश भेजता है।
StartTimer विधि की कार्यक्षमता का विस्तार करने के लिए, हम निम्नलिखित क्रियाएं करते हैं:
हम GetNParams विधि के कोड को संशोधित करते हैं ताकि यह eMethStartTimer विधि के लिए 1 लौटे :

 case eMethStartTimer: return 1; 

आइए CallAsProc विधि के कोड को फॉर्म में लाएं :

 case eMethStartTimer: if (!lSizeArray || TV_VT(paParams) != VTYPE_I4 || TV_I4(paParams) <= 0) return false; pAsyncEvent = m_iConnect; #ifndef __linux__ m_uiTimer = ::SetTimer(NULL,0,TV_I4(paParams),(TIMERPROC)MyTimerProc); #else //   GNU/Linux #endif break; 

अब प्रदर्शन की जाँच करें। ऐसा करने के लिए, हम कॉन्फ़िगरेशन के लिए प्रबंधित एप्लिकेशन के मॉड्यूल में कोड लिखेंगे:

  ;  () ("...", "DemoVK", .Native);  = ("AddIn.DemoVK.SomeName"); .(2000);  

कॉन्फ़िगरेशन शुरू करने के बाद, कार्यक्रम 2 सेकंड के अंतराल के साथ संदेश प्राप्त करेगा, जो टाइमर के सही संचालन को इंगित करता है।

सिस्टम के साथ सहभागिता "1C: एंटरप्राइज"

बाहरी घटक और 1C के बीच बातचीत के लिए: एंटरप्राइज़ सिस्टम, AddInDefBase.h फ़ाइल में वर्णित IAddInDefBase वर्ग के तरीकों का उपयोग किया जाता है । हम सबसे अधिक इस्तेमाल की जाने वाली सूची:
त्रुटि संदेश निर्माण

 virtual bool ADDIN_API AddError(unsigned short wcode, const WCHAR_T* source, const WCHAR_T* descr, long scode) 

wcode , scode - त्रुटि कोड (विवरण के साथ त्रुटि कोड की एक सूची ITS डिस्क पर पाई जा सकती है)
source - त्रुटि का स्रोत
descr - त्रुटि विवरण
1 सी को संदेश भेजना: एंटरप्राइज सिस्टम

 virtual bool ADDIN_API ExternalEvent(WCHAR_T* wszSource, WCHAR_T* wszMessage, WCHAR_T* wszData) = 0; 

wszSource - संदेश स्रोत
wszMessage - संदेश पाठ
wszData - प्रेषित डेटा
संदेश अवरोधन बाहरी ईवेंट प्रोसेसिंग प्रक्रिया द्वारा किया जाता है
1C में एक बाहरी घटक का पंजीकरण: एंटरप्राइज सिस्टम

 virtual bool ADDIN_API RegisterProfileAs(WCHAR_T* wszProfileName) 

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

TVariant डेटा प्रकार

बाहरी घटक और 1C: एंटरप्राइज़ सिस्टम के बीच डेटा का आदान-प्रदान करते समय, tVariant डेटा प्रकार का उपयोग किया जाता है। यह type.h फ़ाइल में वर्णित है, जिसे ITS ड्राइव पर पाया जा सकता है:

 struct _tVariant { _ANONYMOUS_UNION union { int8_t i8Val; int16_t shortVal; int32_t lVal; int intVal; unsigned int uintVal; int64_t llVal; uint8_t ui8Val; uint16_t ushortVal; uint32_t ulVal; uint64_t ullVal; int32_t errCode; long hRes; float fltVal; double dblVal; bool bVal; char chVal; wchar_t wchVal; DATE date; IID IDVal; struct _tVariant *pvarVal; struct tm tmVal; _ANONYMOUS_STRUCT struct { void* pInterfaceVal; IID InterfaceID; } __VARIANT_NAME_2/*iface*/; _ANONYMOUS_STRUCT struct { char* pstrVal; uint32_t strLen; //count of bytes } __VARIANT_NAME_3/*str*/; _ANONYMOUS_STRUCT struct { WCHAR_T* pwstrVal; uint32_t wstrLen; //count of symbol } __VARIANT_NAME_4/*wstr*/; } __VARIANT_NAME_1; uint32_t cbElements; //Dimension for an one-dimensional array in pvarVal TYPEVAR vt; }; 

टाइप वेरिएंट एक संरचना है जिसमें शामिल हैं:

• मिश्रण (संघ) सीधे डेटा भंडारण के लिए करना है
• डेटा प्रकार पहचानकर्ता

सामान्य तौर पर, वैरिएंट प्रकार के चर के साथ काम करना निम्न एल्गोरिथम के अनुसार होता है:

1. वर्तमान में एक चर में संग्रहीत डेटा का प्रकार निर्धारित करना
2. डेटा तक सीधे पहुंच के लिए, मिश्रण के संबंधित क्षेत्र तक पहुंच

TVariant प्रकार का उपयोग करना 1C: एंटरप्राइज़ सिस्टम और बाहरी घटक की सहभागिता को बहुत सरल करता है

आवेदन

उदाहरण निर्देशिका में लेख
उदाहरण / 1 के लिए उदाहरण शामिल हैं - डेमो घटक
उदाहरण / 2 लॉन्च करना - संपत्ति सूची के
उदाहरणों का विस्तार प्रदर्शित करना 3 / - विधियों की सूची के विस्तार का प्रदर्शन
प्रत्येक निर्देशिका में वीएस 2008 परियोजना और एक तैयार 1 सी कॉन्फ़िगरेशन शामिल है।
एप्लिकेशन डाउनलोड करें