देशी सी/सी ++ और सी # (.NET) के बीच सबसे हल्का आईपीसी समाधान क्या है?

Question

मेरे पास मूल सी ++ विजुअल स्टूडियो 2010 समाधान है और मैं एक .NET ऐप (सी # डब्ल्यूपीएफ) को डेटा भेजना चाहता हूं क्या सी/सी ++ कोड की कुछ पंक्ति के साथ ऐसा करने का कोई तरीका है? मैं सी/सी ++ पक्ष पर बाहरी निर्भरताओं का उपयोग नहीं करना चाहता हूं। क्या इसके बारे में कोई नमूना कोड है?

अधिक जानकारी: सी/सी ++ मूल ऐप वास्तव में एक npapi dll है जो chrome.exe प्रक्रिया में लोड होता है। मुझे नहीं लगता कि यह महत्वपूर्ण है, कृपया पुष्टि करें।

Answer 1

ऐसा लगता है कि आप प्रक्रियाओं के बीच संवाद करने के लिए named pipes का उपयोग कर सकते हैं।

This question आपको सही दिशा में इंगित करने में मदद करनी चाहिए।

Answer 2

मैं नामित पाइप्स की सिफारिश करता हूं; here सी # & सी ++ के बीच एक नामित पाइप कार्यान्वयन का एक अच्छा उदाहरण है। आप COM Interop भी कार्यान्वित कर सकते हैं। एक अन्य विकल्प WM_COPYDATA संदेशों का उपयोग किया जाएगा (उन्हें पकड़ने आप WndProc ओवरराइड करने के लिए की जरूरत है), जो कर रहे हैं, हालांकि, बहुत सीमित हो, तब:

public static class CopyDataHelper 
{ 
    [StructLayout(LayoutKind.Sequential, Pack=1)] 
    public struct COPYDATASTRUCT 
    { 
     private Int32 _dwData; 
     private Int32 _cbData; 
     private IntPtr _lpData; 

     public Int32 DataId 
     { 
      get { return _dwData; } 
      set { _dwData = value; } 
     } 

     public Int32 DataSize 
     { 
      get { return _cbData; } 
     } 

     public IntPtr Data 
     { 
      get { return _lpData; } 
     } 

     public T GetData<T>() where T : struct 
     { 
      return (T)Marshal.PtrToStructure(_lpData, typeof(T)); 
     } 

     public void SetData<T>(T data) where T : struct 
     { 
      Int32 size = Marshal.SizeOf(typeof(T)); 
      IntPtr ptr = Marshal.AllocHGlobal(size); 
      Marshal.StructureToPtr(data, ptr, true); 

      _cbData = size; 
      _lpData = ptr; 
     } 
    } 

    [DllImport("User32.dll", CharSet=CharSet.Unicode, ExactSpelling=true, SetLastError=true)] 
    [return: MarshalAs(UnmanagedType.Bool)] 
    internal static extern Boolean SendMessage([In] IntPtr hWnd, [In] UInt32 msg, [In] IntPtr wParam, [In, Out] ref COPYDATASTRUCT lParam); 

    public const Int32 WM_COPYDATA = 0x004A; 

    public static Boolean Send<T>(IntPtr fromHwnd, IntPtr toHwnd, Int32 dataId, T data) where T : struct 
    { 
     IntPtr ptr = IntPtr.Zero; 

     try 
     { 
      COPYDATASTRUCT cds = new COPYDATASTRUCT(); 
      cds.DataId = dataId; 
      cds.SetData(data); 
      return SendMessage(toHwnd, WM_COPYDATA, fromHwnd, ref cds); 
     } 
     finally 
     { 
      if (ptr != IntPtr.Zero) 
       Marshal.FreeHGlobal(ptr); 
     } 
    } 

    public static COPYDATASTRUCT Receive(Message msg) 
    { 
     if (msg.Msg != WM_COPYDATA) 
      throw new ArgumentException("This is not a WM_COPYDATA message!"); 

     return (COPYDATASTRUCT)msg.GetLParam(typeof(COPYDATASTRUCT)); 
    } 
} 

// Override 

protected override void WndProc(ref Message msg) 
{ 
    if (msg.Msg == CopyDataHelper.WM_COPYDATA) 
    { 
     CopyDataHelper.COPYDATASTRUCT cds = CopyDataHelper.Receive(msg); 

     if (cds.DataId == myDataId) 
     { 
      MyData data = cds.GetData<MyData>(); 
      msg.Result = DoSomething(data); 
      return; 
     } 
    } 

    base.WndProc(ref msg); 
} 

आखिरी मौका गूगल के प्रोटोकॉल बफ़र उपयोग करने के लिए है: मूल कार्यान्वयन केवल सी का समर्थन करता है ++, जावा & पायथन ... लेकिन .NET के लिए protobuf-net है।