सी # कॉलिंग सी फ़ंक्शन जो फिक्स्ड साइज चार सरणी

Question

के साथ स्ट्रक्चर देता है, इसलिए, इस प्रश्न के कई रूप हैं, और कई को देखने के बाद भी मैं इसे समझ नहीं पाया।

typedef struct 
{ 
unsigned long Identifier; 
char Name[128]; 
} Frame; 

Frame GetFrame(int index); 

यह सी # कोड है::

इस सी कोड है

struct Frame 
{ 
    public ulong Identifier; 
    [MarshalAs(UnmanagedType.ByValArray, ArraySubType = UnmanagedType.I1, SizeConst = 128)] 
    public char[] Name; 
} 

[DllImport("XNETDB.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)] 
private static extern Frame GetFrame(int index); 

यह अंतिम प्रयास मैं सी # में करने की कोशिश की है, और यह बहुत तार्किक लगता है, लेकिन मैं मिलता है त्रुटि "विधि का हस्ताक्षर PInvoke संगत नहीं है।" तो, मैं आगे की कोशिश करने के लिए क्या खो गया हूँ। किसी भी मदद की सराहना की है।

धन्यवाद, केविन

अपडेट किया गयाकेविन मेरे जवाब देने के लिए एक संपादन के रूप में इस जोड़ा

मैं बजाय मेरी सी कोड बदलना चाहिए:

void GetFrame(int index, Frame * f); 

और सी # के लिए बजाय का उपयोग :

struct Frame 
{ 
    public uint Identifier; 
    [MarshalAsAttribute(UnmanagedType.ByValTStr, SizeConst = 128)] 
    public string Name; 
} 

[DllImport("XNETDB.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)] 
private static extern void GetFrame(int index, ref Frame f); 

Answer 1

समस्या देशी समारोह की वापसी मान के रूप में एक गैर blittable प्रकार देता है कि है।

http://msdn.microsoft.com/en-us/library/ef4c3t39.aspx

पी/आह्वान एक वापसी मान के रूप में गैर blittable प्रकार नहीं हो सकता।

आप नहीं पी/कि विधि आह्वान कर सकते हैं।

मूल्य से 132 बाइट्स रिटर्निंग [संपादितयह वास्तव में संभव है, JaredPar's answer देखें] एक बुरा विचार है। यदि यह मूल कोड आपका है, तो मैं इसे ठीक कर दूंगा। आप 132 बाइट आवंटित करके और पॉइंटर लौटकर इसे ठीक कर सकते हैं। फिर उस स्मृति को रिलीज़ करने के लिए एक फ्रीफ्रेम विधि जोड़ें। अब यह पी/आमंत्रित किया जा सकता है।

वैकल्पिक रूप से, आप फ्रेम स्मृति के लिए सूचक स्वीकार करने के लिए है कि यह भर देंगे करने के लिए JaredPar के सी # तय आकार बफर सुविधा का उपयोग करने के लिए है यह बदल सकता है।

Answer 2

आपके द्वारा चुने गए PInvoke हस्ताक्षर के साथ दो समस्याएं हैं।

पहला तय करना आसान है। आपके पास unsigned long का गलत अनुवाद है। सी unsigned long आमतौर पर केवल 4 बाइट्स है। आपने सी # प्रकार long चुना है जो 8 बाइट्स है। uint का उपयोग करने के लिए सी # कोड बदलना इसे ठीक करेगा।

दूसरा थोड़ा कठिन है। जैसा कि टर्गीवर ने सीएलआर मार्शलर को इंगित किया है कि यह वापसी की स्थिति में केवल एक संरचना का समर्थन करता है यदि यह विचित्र है। ब्लिटेबल कहने का एक शानदार तरीका है कि इसका मूल और प्रबंधित कोड में सटीक स्मृति प्रतिनिधित्व है। आपके द्वारा चुने गए स्ट्रक्चर परिभाषा को ब्लिटेबल नहीं है क्योंकि इसमें घोंसला वाला सरणी है।

यह याद किया जा सकता है कि यदि आपको याद है कि PInvoke एक बहुत ही सरल प्रक्रिया है। CLR Marshaller वास्तव में सिर्फ अपने प्रकार के हस्ताक्षर और PInvoke तरीकों

• मैं कितने बाइट्स को कॉपी कर रहा हूँ के साथ 2 प्रश्नों के उत्तर देने की जरूरत है?
• किस दिशा में उन्हें जाने की आवश्यकता है?

इस मामले में बाइट की संख्या sizeof(unsigned long) + 128 == 132 है। तो हमें बस इतना करना है कि एक प्रबंधित प्रकार का निर्माण करें जो कि विचित्र है और इसका आकार 132 बाइट है। यह करने के लिए सबसे आसान तरीका है सरणी भाग

[StructLayout(LayoutKind.Sequential, Size = 128)] 
struct Blob 
{ 
    // Intentionally left empty. It's just a blob 
} 

यह कोई सदस्यों को बताया कि 128 बाइट्स का एक आकार होने के रूप में marshaller के लिए दिखाई देगा के साथ एक struct है संभालने के लिए एक ब्लॉब परिभाषित करने के लिए है (और एक बोनस के रूप में यह blittable है !)। अब हम आसानी से एक uint का एक संयोजन और इस प्रकार

struct Frame 
{ 
    public int Identifier; 
    public Blob NameBlob; 
    ... 
} 

अब हम एक आकार marshaller 132 बाइट के रूप में देखेंगे के साथ एक blittable प्रकार है के रूप में Frame संरचना परिभाषित कर सकते हैं।इसका मतलब है कि यह GetFrame हस्ताक्षर के साथ ठीक काम करेगा जो आपने

एकमात्र हिस्सा छोड़ा है, जो आपको नाम के लिए वास्तविक char[] तक पहुंच प्रदान कर रहा है। यह थोड़ा मुश्किल है लेकिन थोड़ा सा मार्शल जादू के साथ हल किया जा सकता है।

public string GetName() 
{ 
    IntPtr ptr = IntPtr.Zero; 
    try 
    { 
     ptr = Marshal.AllocHGlobal(128); 
     Marshal.StructureToPtr(NameBlob, ptr, false); 
     return Marshal.PtrToStringAnsi(ptr, 128); 
    } 
    finally 
    { 
     if (ptr != IntPtr.Zero) 
     { 
      Marshal.FreeHGlobal(ptr); 
     } 
    } 
} 

नोट: क्योंकि मैं GetFrame एपीआई के साथ अपरिचित हूँ मैं बुला सम्मेलन हिस्से पर टिप्पणी नहीं कर सकता, लेकिन जो कुछ मैं निश्चित रूप से पर जांच करेंगे।

Answer 3

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

class Program 
{ 
    private const int SIZE = 128; 

    unsafe public struct Frame 
    { 
     public uint Identifier; 
     public fixed byte Name[SIZE]; 
    } 

    [DllImport("PinvokeTest2.DLL", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)] 
    private static extern Frame GetFrame(int index); 

    static unsafe string GetNameFromFrame(Frame frame) 
    { 
     //Option 1: Use if the string in the buffer is always null terminated 
     //return Marshal.PtrToStringAnsi(new IntPtr(frame.Name)); 

     //Option 2: Use if the string might not be null terminated for any reason, 
     //like if were 128 non-null characters, or the buffer has corrupt data. 

     return Marshal.PtrToStringAnsi(new IntPtr(frame.Name), SIZE).Split('\0')[0]; 
    } 

    static void Main() 
    { 
     Frame a = GetFrame(0); 
     Console.WriteLine(GetNameFromFrame(a)); 
    } 
}