🍮 🌎 👩🏻‍🔬 P / Invoke के बिना प्रबंधित से अनवांटेड कोड को कॉल करना 🛀 🧑🏾‍🤝‍🧑🏽 🚎

हम मार्शल जारी रखते हैं। इस बार हम P / Invoke ([DllImport]) का उपयोग किए बिना C # से C- फ़ंक्शन को कॉल करने के लिए एक विधि पर विचार करेंगे। और सटीक होना है, तो [DllImport] को अभी भी उपयोग करना होगा, लेकिन केवल एक बार। अनिवार्य रूप से, यह लेख कार्य करने वाले प्रतिनिधियों और इसके विपरीत प्रतिनिधियों के मार्शलिंग के बारे में एक लेख है।
तो चलिए शुरू करते हैं।

पहली चीज जिसे आपको शुरू करने की आवश्यकता है, यह याद रखना चाहिए कि जब हम कुछ छोड़ देते हैं (इस मामले में [डीएलआईएमपोर्ट]), तो हम इसे किसी और चीज़ से बदल देते हैं। तो यह यहाँ है। P / Invoke (C # में) और Dll (C) से निर्यात करने के बाद, आपको पॉइंटर्स के साथ एक फ़ंक्शन (C में) और डेलिगेट्स के साथ एक स्ट्रक्चर (C # में) घोषित करना होगा।
मान लें कि आपके पास एक हेडर फ़ाइल और एक कार्यान्वयन फ़ाइल है जिसमें निम्न कोड है (इससे कोई फर्क नहीं पड़ता कि वे कहाँ से आए और कैसे आए):

NativeCode.h फ़ाइल

/* ,    */ typedef int (__stdcall * pFuncInterface)( __in int nStatus ); typedef struct _Interface { //         pFuncInterface m_pfInterface; //      DWORD m_dwData; } SInterface, *PSInterface; /*    */ __declspec(dllexport) int CreateInterface( __inout PSInterface pInterface );

NativeCode.cpp फ़ाइल

 int __stdcall FuncInterface( __in int nStatus) { nStatus = 5; return 1; } /*   */ int CreateInterface( __inout PSInterface pInterface) { //       pInterface->m_pfInterface = FuncInterface; // -  pInterface->m_dwData = 5; return pInterface->m_dwData; }

नोट 1 : इस उदाहरण में, __stdcall को स्टैक की स्थिति को पुनर्स्थापित करने के लिए पहले से ही पाठक द्वारा जोड़ा जाता है।
नोट 2 : संरचना फ़ील्ड ( SInterface ) के रूप में घोषित फ़ंक्शन पॉइंटर्स की संख्या भिन्न हो सकती है, अर्थात, संरचना में एक भिन्न प्रकार के फ़ंक्शन पॉइंटर्स हो सकते हैं।

जैसा कि आप उदाहरण से देख सकते हैं, हमारे पास एक फ़ंक्शन ( FuncInterface ) के लिए एक सूचक ( pFuncInterface ) है जो एक इंट लेता है और एक इंट , दो फ़ील्ड ( SInterface ) के साथ एक संरचना देता है, जिनमें से एक फ़ंक्शन के लिए एक संकेतक है, और फ़ील्ड ( CreateInterface ) द्वारा संरचना को भरने के लिए एक फ़ंक्शन है ।

हमारा काम इस संरचना के साथ बातचीत के लिए सी # में कोड लिखना है। पहली बात जो दिमाग में आती है, वह है कि सभी कार्यों को सी साइड पर एक्सपोर्ट करें और सी # साइड पर [डेलमपोर्ट] के माध्यम से कॉल करें, और संरचना में केवल डेटा फ़ील्ड छोड़ें (फ़ंक्शन पॉइंटर्स को बाहर करें)। लेकिन मैं कोड को बदलना नहीं चाहता (इसके अलावा, अगर यह आपका नहीं है, तो यह सबसे सरल रूप से संभव है और इसे बदलना असंभव है)।

इस मामले में, निम्नानुसार आगे बढ़ें।

हमेशा की तरह, हम एक Win32 प्रोजेक्ट (कंसोल एप्लिकेशन) बनाते हैं और संकेत देते हैं कि यह Dll में संकलित करेगा, और C # प्रोजेक्ट - कंसोल एप्लिकेशन भी बनाएगा। हम Dll में अपनी स्रोत फ़ाइलों में से दो जोड़ते हैं और निर्यात किए गए क्षेत्रों द्वारा संरचना को भरने का कार्य करते हैं (यह एकमात्र फ़ंक्शन है जिसे पी / इनवोक के लिए कॉल की आवश्यकता होगी)। तो, हमारे पास केवल निर्यात किए गए फ़ंक्शन CreateInterface () के साथ एक Dll है।

इस विधि का नुकसान यह है कि सी # तरफ आपको ठीक उसी संरचना को घोषित करना होगा जिसमें फ़ंक्शन पॉइंटर्स को प्रतिनिधियों द्वारा प्रतिस्थापित किया जाता है (आपको प्रत्येक फ़ंक्शन पर एक प्रतिनिधि को घोषित करना होगा), अर्थात, संक्षेप में, सी # तरफ, * .h फ़ाइल कोड डुप्लिकेट है ( इस मामले में, NativeCode.h )। फिर भी, CreateInterface () के लिए ऐसा करने के साथ-साथ [DllImport], हम प्राप्त करते हैं:

 using System; using System.Runtime.InteropServices; namespace SharpCode { /****************************************************/ //    *.h  public delegate int pInterface(int nStatus); [StructLayout(LayoutKind.Sequential, Pack = 1)] struct SInterface { public pInterface m_pfpInterface; public UInt32 m_dwData; } /****************************************************/ class Program { private static SInterface stInterface = new SInterface(); [DllImport("NativeDll", CallingConvention = CallingConvention.Cdecl)] public static extern int CreateInterface( ref SInterface pInterface ); static void Main(string[] args) { CreateInterface(ref stInterface); //         //  unmanaged code   P/Invoke int nRes = stInterface.m_pfpInterface(1); Console.WriteLine("Result = {0}", nRes); } } }

अब यह __stdcall को दो स्थानों और वॉइला में जोड़ने के लिए रहता है, सब कुछ काम करता है। Dll से CreateInterface () कॉल करके, SInterface संरचना बिंदुओं से फ़ंक्शन (इस मामले में, एक) से भर जाती है, जिसे C # पक्ष में प्रतिनिधियों के लिए मार्श किया जाता है। अब आप पी / इनवोक तंत्र को दरकिनार करते हुए फ़ंक्शन को सीधे अनवांटेड कोड से फ़ंक्शन को कॉल करने के लिए उपयोग कर सकते हैं।

उम्मीद के मुताबिक कार्यक्रम का नतीजा:

PS: यह विधि P / Invoke के साथ अनवांटेड कोड को कॉल करने का एक विकल्प है।

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

More articles: