अनवांटेड से प्रबंधित कोड को कॉल करना

यह आलेख एक प्रबंधित C कोड से प्रबंधित C # कोड (.Net) को कॉल करने पर दिखेगा।
एक बार काम करने के बाद उन्होंने एक प्रोजेक्ट दिया, या फिर प्रोजेक्ट ही नहीं, बल्कि उसका केवल एक हिस्सा। परियोजना में स्वयं दो भाग शामिल थे: C में लिखा गया एक कार्यात्मक (अनवांटेड कोड) और C # (प्रबंधित कोड) में लिखा गया एक इंटरफ़ेस भाग। मेरा काम एक इंटरफ़ेस लिखना और इसे कार्यक्षमता के साथ जोड़ना था।

बाद में इस लेख में, प्रबंधित कोड को शीर्ष स्तर कहा जाएगा, अप्रबंधित - नीचे।

जैसा कि आप जानते हैं, पी / इनवोक (प्लेटफॉर्म इनवोक) तंत्र का उपयोग C # में शीर्ष से निचले स्तर तक पहुंचने के लिए किया जाता है। ऐसा करने के लिए, निचले स्तर को Dll में लपेटा जाता है (अर्थात निचले स्तर के सभी कार्यों को निर्यात किया जाता है) और DllImport विशेषता का उपयोग करके ऊपर से बुलाया जाता है। इस तंत्र से अपरिचित लोगों के लिए - msdn.microsoft.com/en-us/library/aa288468 (v = बनाम 71) .asp

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

समझ को सरल बनाने के लिए, दो परियोजनाओं सहित एक नया समाधान बनाया गया था: एक निम्न-स्तरीय परियोजना (CallC) और एक उच्च-स्तरीय परियोजना (SharpForCall)।

तो, हमारे पास एक खाली सी # परियोजना (कंसोल एप्लीकेशन) है और किसी ने एक सी परियोजना लिखी है (मुझे शुरू में केवल एच-फाइल करना था, हम परियोजना को सरलता के लिए तुरंत ले जाते हैं)। C में प्रोजेक्ट का प्रकार Dll है, जो स्वाभाविक रूप से C # में प्राप्त हमारे निष्पादन योग्य के बगल में होना चाहिए। परियोजना में निम्नलिखित सामग्री के साथ एक .cpp फ़ाइल है:

/**    */ typedef VOID (__stdcall * pResultCallBack)( int nStatus ); __declspec(dllexport) int FuncC(pResultCallBack pfResult, PVOID pContext) { // //  -  // /*       (C#)   */ pfResult(1); return 1; } 

एक बार फिर मैं इसका अर्थ बताऊंगा कि क्या किया जाना चाहिए। यहां निर्यात किया गया फ़ंक्शन (FuncC) C # साइड पर आयात किया जाएगा, जिसे मान लिया जाता है, जब उपयोगकर्ता एक बटन दबाता है (चलो यह न भूलें कि मुख्य कार्य इंटरफ़ेस के साथ कार्यात्मक को जोड़ना है)। यह फ़ंक्शन (C # साइड पर आयात किया गया) स्वाभाविक रूप से दिए गए * .cpp फ़ाइल (ऊपर देखें) में FuncC फ़ंक्शन को कॉल करेगा, जिसे निष्पादन के बाद pResultCallBack फ़ंक्शन को कॉल करके निष्पादन के परिणाम C # पर वापस रिपोर्ट करना चाहिए। शीर्ष-स्तर की ओर, pResultCallBack फ़ंक्शन (हमारे मामले में, FuncCSharp, नीचे देखें), FuncC फ़ंक्शन के परिणाम का विश्लेषण करेगा और, इसके लिए दिए गए मूल्य के आधार पर, कुछ क्रियाएं (उदाहरण के लिए, जब एक स्थिति कोड वापस करने में विफल कॉल का संकेत देता है, तो आप कॉल को दोहरा सकते हैं)। डी।)। सामान्य तौर पर, इस विचार का उपयोग एक मशीन (मेजबान) को दूसरी मशीन द्वारा नियंत्रित करने के लिए किया जा सकता है।

आइए क्रियान्वयन के लिए नीचे उतरें।

सबसे पहले, कॉन्फ़िगरेशन गुण-> सामान्य-> आउटपुट निर्देशिका में C-sh प्रोजेक्ट की सेटिंग पर जाएं और C # प्रोजेक्ट के निष्पादन योग्य फ़ोल्डर के लिए पथ लिखें।



दूसरी बात, C # प्रोजेक्ट के प्रोजेक्ट डिपेंडेंसी में जाने और C- प्रोजेक्ट के बगल में स्थित बॉक्स को चेक करना न भूलें।



अगला, हम Import.cs वर्ग बनाते हैं, जिसमें हम P / Invoke तंत्र का उपयोग करके आयातित फ़ंक्शन का वर्णन करते हैं।

 using System; using System.Runtime.InteropServices;//    namespace SharpForCall { class Import { [DllImport("CallC.dll", CallingConvention = CallingConvention.Cdecl)] public static extern int FuncC( [MarshalAs(UnmanagedType.FunctionPtr)] ResultCallBack pfResult, IntPtr pContext); } } 

हम PVOID को IntPtr, और सूचक को ResultCallBack प्रतिनिधि के साथ pResultCallBack फ़ंक्शन में प्रतिस्थापित करते हैं, जो कि इस प्रकार Program.cs फ़ाइल में वर्णित है:

 using System; namespace SharpForCall { public delegate void ResultCallBack(Int32 nStatus); class Program { static void Main(string[] args) { ResultCallBack result = new ResultCallBack(FuncCSharp); IntPtr pContext = IntPtr.Zero; /*    Dll */ int nRes = Import.FuncC(result, pContext); } /**    . *   unmanaged . */ public static void FuncCSharp(Int32 nStatus) { if ( 1 == nStatus ) { //   } if ( 2 == nStatus ) { //   } //    return ; } } } 

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



, तो हम __stdcall कॉलबैक की परिभाषा में साइड C पर जोड़ते हैं।

यदि यह मदद नहीं करता है, तो कक्षा आयात में C # तरफ, आपको DllImport विशेषता को कॉल करते समय CallingConvention = CallingConvention.Cdecl जोड़ना होगा। स्टैक को उसकी मूल स्थिति में वापस करने के लिए यह सभी आवश्यक है।

अब सब कुछ काम करता है। हमने अभी पूरा किया है जो कई असंभव मानते हैं - हमने प्रबंधित कोड को अप्रबंधित से बुलाया।

पुनश्च: मुझे लगता है कि कोई काम आएगा। आपकी टिप्पणियों की प्रतीक्षा है ...