मैं सी #+ डीएल में सी # + डीएल में एक फ़ंक्शन कैसे कॉल करूं जिसमें शून्य * कॉलबैक और ऑब्जेक्ट पैरामीटर

Question

मैं एक सी डीएल में एक रैपर बनाने की कोशिश कर रहा हूं और मैं एक फ़ंक्शन कॉल करने का प्रयास कर रहा हूं जिसमें कॉलबैक फ़ंक्शन है, प्राप्त करता है एक वस्तु जो एक सूचक के रूप में वापस पारित किया जाता है।

ज फ़ाइल delares

extern int SetErrorHandler(void (*handler) (int, const char*, void*), 
           void *data_ptr); 

हैंडलर एक कॉलबैक फ़ंक्शन एक त्रुटि होती है और data_ptr के मामले में, किसी भी वस्तु (राज्य) है कि आप करने के लिए वापस पारित हो जाता है तब होता है जब कहा जाता है वह यह है कि मेरी ऐप जो यह होगा (वर्तमान वस्तु)।

मैं एक डीएल में फ़ंक्शंस को कॉल करने में सक्षम हूं जो सरल प्रकार के तारों, इन्स इत्यादि जैसे मार्शल किए गए निरंतर प्रकारों का उपयोग करता है लेकिन मैं यह नहीं समझ सकता कि कैसे एक सी # ऑब्जेक्ट को पॉइंटर को मार्शल करना है।

सी फ़ंक्शन के ऑब्जेक्ट संदर्भ को यहां से खोजकर जो मिला है उससे प्राप्त करने के लिए और अन्यथा ऐसा लगता है कि मुझे फ़ंक्शन में मार्शल करने में सक्षम होने के लिए संरचना प्रकार की आवश्यकता है, इसलिए मैंने अपनी ऑब्जेक्ट को पकड़ने के लिए एक स्ट्रक्चर बनाया :

[StructLayout(LayoutKind.Sequential)] 
struct MyObjectState 
{ 
    public object state; 
} 

संपादित करें: मैं एक विशेषता डालने की कोशिश की: public object state संपत्ति पर [MarshalAs(UnmanagedType.Struct, SizeConst = 4)], लेकिन यह एक ही त्रुटि पैदा करता है, तो मैं इसे हटा दिया, यह does not वैसे भी काम करेगा लगता है।

संरचना में कॉलबैक फ़ंक्शन के लिए किसी ऑब्जेक्ट को रखने के लिए एक ऑब्जेक्ट प्रॉपर्टी होती है।

मैं इस प्रकार सी # में प्रतिनिधि की घोषणा की:

delegate void ErrorHandler(int errorCode, IntPtr name, IntPtr data); 

तब मैं सी # में आयात समारोह घोषित इस प्रकार है:

[DllImport("somedll.dll", CallingConvention = CallingConvention.Cdecl)] 
static extern int SetErrorHandler handler, IntPtr data); 

तब मैं अपने सी # कोड में एक कॉलबैक फ़ंक्शन बनाया:

void MyErrorHandler(int errorCode, IntPtr name, IntPtr data) 
{ 
    var strName = Marshal.PtrToStringAnsi(name); 
    var state = new MyObjectState(); 
    Marshal.PtrToStructure(data, state); 
    Console.WriteLine(strName); 
} 

मैं लाइब्रेरी फ़ंक्शन को निम्नानुसार कॉल करने में सक्षम हूं:

var state = new MyObjectState() 
{ 
    state = this 
}; 
IntPtr pStruct = Marshal.AllocHGlobal(Marshal.SizeOf(state)); 
Marshal.StructureToPtr(state, pStruct, true); 
int ret = SetErrorHandler(MyErrorHandler, pStruct); 

कॉल काम करता है और कॉलबैक फ़ंक्शन कहा जाता है, लेकिन मैं कॉलबैक फ़ंक्शन में डेटा का उपयोग करने में असमर्थ हूँ और जब मैं Marshal.PtrToStructure कोशिश मैं एक त्रुटि मिलती है:

The structure must not be a value class.

मैं खोज की एक बहुत कुछ किया यहां और मार्शल और शून्य * पर विभिन्न चीजें मिलीं लेकिन कुछ भी मुझे काम करने में मदद नहीं मिली है

धन्यवाद।

Answer 1

आप इसे जितना अधिक जटिल बना रहे हैं उससे कहीं अधिक जटिल बना रहे हैं। आपके सी # क्लाइंट को data_ptr पैरामीटर का उपयोग करने की आवश्यकता नहीं है क्योंकि सी # प्रतिनिधि पहले से ही this पॉइंटर को बनाए रखने के लिए तंत्र में निर्मित है।

तो आप प्रतिनिधि को IntPtr.Zero पास कर सकते हैं। आपके त्रुटि हैंडलर प्रतिनिधि के अंदर आप data_ptr के मान को अनदेखा करते हैं क्योंकि this उपलब्ध होगा।

यदि आप इस विवरण का पालन नहीं करते हैं, तो मेरा मतलब यह समझाने के लिए एक छोटा कार्यक्रम है। नोट करें कि MyErrorHandler एक उदाहरण विधि है जो त्रुटि हैंडलर के रूप में कार्य करती है, और इंस्टेंस डेटा संशोधित कर सकती है।

class Wrapper 
{ 
    [UnmanagedFunctionPointer(CallingConvention.Cdecl)] 
    delegate void ErrorHandler(int errorCode, string name, IntPtr data); 

    [DllImport("somedll.dll", CallingConvention = CallingConvention.Cdecl)] 
    static extern int SetErrorHandler(ErrorHandler handler, IntPtr data); 

    void MyErrorHandler(int errorCode, string name, IntPtr data) 
    { 
     lastError = errorCode; 
     lastErrorName = name; 
    } 

    public Wrapper() 
    { 
     SetErrorHandler(MyErrorHandler, IntPtr.Zero); 
    }    

    public int lastError { get; set; } 
    public string lastErrorName { get; set; } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     Wrapper wrapper = new Wrapper(); 
    } 
} 

Answer 2

ऐसा करने का एक तरीका बहुत अच्छा हो सकता है, लेकिन मैंने बहुत समय पहले छोड़ दिया था। समाधान मैं ले कर आए हैं थोड़ा hackish है, लेकिन यह बहुत प्रभावी है और सब कुछ मैं इसे फेंक दिया गया है के साथ काम करता है:

सी # -> प्रबंधित सी ++ -> मूल निवासी कॉल

यह इस तरह से आप खत्म कर प्रबंधित सी ++ में एक छोटा रैपर लिखना, जो दर्द का प्रकार है, लेकिन मुझे उस मार्शलिंग कोड की तुलना में अधिक सक्षम और कम दर्दनाक पाया गया।

ईमानदारी से हालांकि मैं उम्मीद कर रहा हूं कि कोई गैर-उत्पीड़नपूर्ण उत्तर देता है, मैंने कुछ समय से इसके साथ संघर्ष किया है।