C#内存共享_内存共享库

转载 2011年01月11日 11:49:00
C#内存共享一
2008年11月13日 星期四 下午 07:19
// 内存共享库
using System;
using System.Text;
using System.Collections;
using Microsoft.Win32.SafeHandles;
using System.Runtime.InteropServices;

namespace MQAD
{
    public class CShareMem
    {
        private IntPtr m_hMap;
        private IntPtr m_addr;
        const uint m_mapLength = 1024 * 256;

        public CShareMem(string shareName)
        {
            //m_hMap = CShareMem.OpenFileMapping(FILE_MAP_READ | FILE_MAP_WRITE, 0, shareName);

            m_hMap = CShareMem.CreateFileMapping((IntPtr)(-1), //HANDLE hFile,INVALID_HANDLE_VALUE = -1
            0,//LPSECURITY_ATTRIBUTES lpAttributes,        //0
            0x04,//DWORD flProtect,        PAGE_READWRITE = 0x04
            0,//DWORD dwMaximumSizeHigh,
            1024 * 256,//DWORD dwMaximumSizeLow,
            shareName //LPCTSTR lpName
            );
            if ((int)m_hMap > 0)
            {
                m_addr = CShareMem.MapViewOfFile(m_hMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
            }
        }

        ~CShareMem()
        {
            if ((int)m_addr > 0)
            {
                UnmapViewOfFile(m_addr);
                CloseHandle(m_hMap);
            }
        }
        public IntPtr GetAddr()
        {
            return m_addr;
        }


        [DllImport("User32.dll", EntryPoint = "SendMessage")]
        private static extern int SendMessage(
            int hWnd,    //目标窗口的handle
            int Msg,    // 消息
            int wParam, // 第一个消息参数
            ref COPYDATASTRUCT lParam // 第二个消息参数
            );

        [DllImport("User32.dll", EntryPoint = "FindWindow")]
        private static extern int FindWindow(string lpClassName, string
            lpWindowName);

        public struct COPYDATASTRUCT
        {
            public IntPtr dwData;
            public int cbData;
            [MarshalAs(UnmanagedType.LPStr)]
            public string lpData;
        }

        const int WM_COPYDATA = 0x004A;
        const int INVALID_HANDLE_VALUE = -1;
        const int PAGE_READWRITE = 0x04;


        //共享内存
        [DllImport("Kernel32.dll", EntryPoint = "CreateFileMapping")]
        public static extern IntPtr CreateFileMapping(IntPtr hFile,    //HANDLE hFile,INVALID_HANDLE_VALUE = -1
            UInt32 lpAttributes,//LPSECURITY_ATTRIBUTES lpAttributes,        //0
            UInt32 flProtect,//DWORD flProtect,        PAGE_READWRITE = 0x04
            UInt32 dwMaximumSizeHigh,//DWORD dwMaximumSizeHigh,
            UInt32 dwMaximumSizeLow,//DWORD dwMaximumSizeLow,
            string lpName//LPCTSTR lpName
            );

        [DllImport("Kernel32.dll", EntryPoint = "OpenFileMapping")]
        public static extern IntPtr OpenFileMapping(
            UInt32 dwDesiredAccess,//DWORD dwDesiredAccess,
            int bInheritHandle,//BOOL bInheritHandle,
            string lpName//LPCTSTR lpName
            );

        public const int FILE_MAP_ALL_ACCESS = 0x0002;
        public const int FILE_MAP_WRITE = 0x0002;
        public const int FILE_MAP_READ = 0x0004;

        [DllImport("Kernel32.dll", EntryPoint = "MapViewOfFile")]
        public static extern IntPtr MapViewOfFile(
            IntPtr hFileMappingObject,//HANDLE hFileMappingObject,
            UInt32 dwDesiredAccess,//DWORD dwDesiredAccess,    FILE_MAP_ALL_ACCESS Same as FILE_MAP_WRITE = 0x0002
            UInt32 dwFileOffsetHight,//DWORD dwFileOffsetHigh,
            UInt32 dwFileOffsetLow,//DWORD dwFileOffsetLow,
            UInt32 dwNumberOfBytesToMap//SIZE_T dwNumberOfBytesToMap
            );

        [DllImport("Kernel32.dll", EntryPoint = "UnmapViewOfFile")]
        public static extern int UnmapViewOfFile(IntPtr lpBaseAddress);

        [DllImport("Kernel32.dll", EntryPoint = "CloseHandle")]
        public static extern int CloseHandle(IntPtr hObject);

        //         [DllImport("shl2wapi.dll",EntryPoint="StrCpy")]
        //         private static extern string StrCpy(IntPtr psz1,string psz2);
        //         //LPTSTR StrCpy(LPTSTR psz1,LPCTSTR psz2);

        public unsafe void Copy(string src, IntPtr dst)
        {
            byte[] byteSrc = Encoding.Default.GetBytes(src);
            Copy(byteSrc, dst);
        }
        public void Clear()
        {
            if ((int)m_addr > 0)
            {
                byte[] b = new byte[m_mapLength];

                Copy(b, m_addr);
            }
        }

        public unsafe void Copy(byte[] byteSrc, IntPtr dst)
        {
            fixed (byte* pSrc = byteSrc)
            {
                byte* pDst = (byte*)dst;
                byte* psrc = pSrc;
                for (int i = 0; i < byteSrc.Length; i++)
                {
                    *pDst = *psrc;
                    pDst++;
                    psrc++;
                }
            }
        }

        public unsafe string GetString()
        {
            byte[] byteDst = new byte[1024 * 256];
            ArrayList arr = new ArrayList();

            int len = 0;
            fixed (byte* pd = byteDst)
            {
                byte* pSrc = (byte*)m_addr;
                byte* pDst = pd;
                for (int i = 0; (*pSrc) != '/0'; i++)
                {
                    *pDst = *pSrc;
                    arr.Add(*pSrc);

                    *pSrc = 0;

                    pDst++;
                    pSrc++;
                    len++;

                }
            }

            byte[] b = new byte[arr.Count];
            arr.CopyTo(b);

            string s = Encoding.Default.GetString(b);
            return s;

            //return Encoding.Default.GetString(byteDst);
        }
    }

    public class Win32Event
    {
        private string m_eventName = null;

        public Win32Event(string eventName)
        {
            m_eventName = eventName;
        }
        public Win32Event()
        {
            m_eventName = "";
        }

        //OPEN EVENT
        [DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        public static extern SafeWaitHandle OpenEvent(UInt32
            dwDesiredAccess, Boolean bInheritHandle, String lpName);

        [DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        public static extern SafeWaitHandle CreateEvent(IntPtr LPSECURITY_ATTRIBUTES, Boolean bManualReset, Boolean bInitialState, String lpName);
    }
}
举报

相关文章推荐

C#内存共享_内存共享库

C#内存共享一2008年11月13日 星期四 下午 07:19// 内存共享库using System;using System.Text;using System.Collections;using...

共享内存

共享内存 共享内存就是允许两个或更多进程访问同一个块内存。共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排为同一段物理内存。进程可以将同一段共享内...
  • ADDw1
  • ADDw1
  • 2017-03-16 20:12
  • 122

精选:深入理解 Docker 内部原理及网络配置

网络绝对是任何系统的核心,对于容器而言也是如此。Docker 作为目前最火的轻量级容器技术,有很多令人称道的功能,如 Docker 的镜像管理。然而,Docker的网络一直以来都比较薄弱,所以我们有必要深入了解Docker的网络知识,以满足更高的网络需求。

共享内存

共享内存:     共享内存区域是被多个进程共享的一部分物理内存.     不同的进程可以通过共享内存通信,是进程间共享数据的一种最快的方法.     一个进程向共享内存区域写入了数据,共享这个...

共享内存

一、什么是共享内存        共享内存可以说是最有用的进程间通信方式,也是最快的IPC形式。两个不同进程A、B共享内存的意思是,同一块物理内存被映 射到进程A、B各自的进程地址空间。进程A...

共享内存

共享内存     共享内存是被多个进程共享的一部分物理内存。共享内存是进程间共享数据的一种最快的方法,一个进程向共享内存区域写入了数据,共享这个内存区域的所有进程就可以立刻看到其中的内容。原理图...

共享内存

关于linux共享内存的主要函数与操作

共享内存

引用头文件 #include #include #include #include #include #include #include #include #define SHMS...
  • sblig
  • sblig
  • 2011-11-29 10:29
  • 273

共享内存

shmdt- detaches shared memory segment   .shmdt detaches from the calling processs data segment the s...

共享内存

共享内存可以说是最有用的进程间通信方式,也是最快的IPC形式。两个不同进程A、B共享内存的意思是,同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新,反...

共享内存

共享内存实际上是可受用户控制的一级内存。每个SM中的一级内存与共享内存共享一个64KB的内存段。在开普勒架构的设备中,根据应用程序的需要,每一个线程块可以配置为16KB的一级内存或共享内存;而在费米架...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)