windows进程共享内存技术

最新推荐文章于 2024-06-21 10:56:54 发布
最新推荐文章于 2024-06-21 10:56:54 发布
阅读量890 收藏 1
点赞数 1
分类专栏： windows技术 文章标签： 共享内存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011152007/article/details/52125879
版权

API：

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;

namespace ShareMemory
{
    public class ShareMemoryAPI
    {
        public static void WriteLog(string funName)
        {
            string logFile = GetAssemblyPath() + "BusDriverLog.txt";
            int errorCode = GetLastError();
            string logMsg = DateTime.Now.ToString() + "\t" + funName + "\t Code" + errorCode;
            System.IO.File.AppendAllText(logFile, logMsg + "\r\n");
        }

        /// <summary>
        /// 获取当前运行dll的路径
        /// </summary>
        /// <returns>路径</returns>
        public static string GetAssemblyPath()
        {
            string codeBase = System.Reflection.Assembly.GetExecutingAssembly().CodeBase;

            codeBase = codeBase.Substring(8, codeBase.Length - 8);    // 8是file:// 的长度

            string[] arrSection = codeBase.Split(new char[] { '/' });

            string folderPath = "";
            for (int i = 0; i < arrSection.Length - 1; i++)
            {
                folderPath += arrSection[i] + "/";
            }

            return folderPath;
        }

        [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr CreateFileMapping(int hFile, IntPtr lpAttributes, uint flProtect, uint dwMaxSizeHi,
                                                      uint dwMaxSizeLow, string lpName);

        [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr OpenFileMapping(int dwDesiredAccess,
                                                    [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, string lpName);

        [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr MapViewOfFile(IntPtr hFileMapping, uint dwDesiredAccess, uint dwFileOffsetHigh,
                                                  uint dwFileOffsetLow, uint dwNumberOfBytesToMap);

        [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
        public static extern bool UnmapViewOfFile(IntPtr pvBaseAddress);

        [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
        public static extern bool CloseHandle(IntPtr handle);

        [DllImport("kernel32", EntryPoint = "GetLastError")]
        public static extern int GetLastError();

        public const int ERROR_ALREADY_EXISTS = 183;
        public const int FILE_MAP_COPY = 0x0001;
        public const int FILE_MAP_WRITE = 0x0002;

        public const int FILE_MAP_READ = 0x0004;
        public const int FILE_MAP_ALL_ACCESS = 0x0002 | 0x0004;
        public const int PAGE_READONLY = 0x02;
        public const int PAGE_READWRITE = 0x04;
        public const int PAGE_WRITECOPY = 0x08;
        public const int PAGE_EXECUTE = 0x10;
        public const int PAGE_EXECUTE_READ = 0x20;
        public const int PAGE_EXECUTE_READWRITE = 0x40;
        public const int SEC_COMMIT = 0x8000000;
        public const int SEC_IMAGE = 0x1000000;
        public const int SEC_NOCACHE = 0x10000000;
        public const int SEC_RESERVE = 0x4000000;
        public const int INVALID_HANDLE_VALUE = -1;
    }






}

Memery Read：

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Drawing;

namespace ShareMemory
{
    public class ShareMemoryRead
    {
        private static object _lockerObj = new object();
        /// <summary>
        /// 根据图片大小从共享内存中读取图片数据
        /// </summary>
        /// <param name="lpName"></param>
        /// <param name="imageSize"></param>
        /// <returns></returns>
        public static byte[] ReadImage(string lpName, Size imageSize, int imageDepth)
        {
            lock (_lockerObj)
            {
                IntPtr hFileRead = IntPtr.Zero;
                try
                {
                    hFileRead = ShareMemoryAPI.OpenFileMapping(ShareMemoryAPI.FILE_MAP_ALL_ACCESS, false, lpName);
                    if (IntPtr.Zero == hFileRead)
                    {
                        ShareMemoryAPI.WriteLog("ShareMemoryAPI.OpenFileMapping");
                        return null;
                    }

                    IntPtr pMemory = ShareMemoryAPI.MapViewOfFile(hFileRead, ShareMemoryAPI.FILE_MAP_READ, 0, 0,
                                                                   (uint)(imageSize.Width * imageSize.Height * sizeof(byte) * imageDepth / 8));
                    if (IntPtr.Zero == pMemory)
                    {
                        ShareMemoryAPI.WriteLog("ShareMemoryAPI.MapViewOfFile");
                        return null;
                    }
                    byte[] bytes24 = new byte[imageSize.Width * imageSize.Height * imageDepth / 8];
                    Marshal.Copy(pMemory, bytes24, 0, imageSize.Width * imageSize.Height * imageDepth / 8);
                    ShareMemoryAPI.UnmapViewOfFile(pMemory);
                    return bytes24;
                }
                catch (Exception)
                {
                    ShareMemoryAPI.WriteLog("ShareMemoryRead.Read");
                    return null;
                }
                finally
                {
                    ShareMemoryAPI.CloseHandle(hFileRead);
                }
            }
        }

        /// <summary>
        /// 根据激光数据行列数，从共享内存中读取激光数据
        /// 此激光数据只包含Z值，未经过标定
        /// </summary>
        /// <param name="lpName"></param>
        /// <param name="row"></param>
        /// <param name="col"></param>
        /// <returns>返回未经标定，Z值二维数组</returns>
        public static float[,] Read(string lpName, int row, int col)
        {
            lock (_lockerObj)
            {
                IntPtr hFileWrite = IntPtr.Zero;
                try
                {
                    hFileWrite = ShareMemoryAPI.OpenFileMapping(ShareMemoryAPI.FILE_MAP_ALL_ACCESS, false, lpName);
                    if (IntPtr.Zero == hFileWrite)
                    {
                        ShareMemoryAPI.WriteLog("ShareMemoryAPI.OpenFileMapping");
                        return null;
                    }

                    IntPtr pMemory = ShareMemoryAPI.MapViewOfFile(hFileWrite, ShareMemoryAPI.FILE_MAP_WRITE, 0, 0, (uint)(row * col * sizeof(double)));
                    if (IntPtr.Zero == pMemory)
                    {
                        ShareMemoryAPI.WriteLog("ShareMemoryAPI.MapViewOfFile");
                        return null;
                    }
                    float[,] pointClode = new float[row, col];
                    unsafe
                    {
                        fixed (float* p = &pointClode[0, 0])
                        {
                            float* pByter = (float*)pMemory;
                            float* p1 = p;
                            for (int i = 0; i < row; i++)
                            {
                                for (int j = 0; j < col; j++)
                                {
                                    *p1 = *pByter;
                                    p1++;
                                    pByter++;
                                }
                            }
                        }
                    }
                    ShareMemoryAPI.UnmapViewOfFile(pMemory);
                    return pointClode;
                }
                catch (Exception)
                {
                    ShareMemoryAPI.WriteLog("ShareMemoryRead.Read");
                    return null;
                }
                finally
                {
                    ShareMemoryAPI.CloseHandle(hFileWrite);
                }
            }
        }


    }
}

Memery Write:

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;


namespace ShareMemory
{
    public class ShareMemoryWrite
    {
        private static object _lockerObj = new object();
        /// <summary>
        /// 将图片数据写入至共享内存
        /// </summary>
        /// <param name="ptr"></param>
        /// <param name="image"></param>
        public static IntPtr WriteImage(string lpName, int imageWidth, int imageHeight, int imageDepth, byte[] image)
        {
            lock (_lockerObj)
            {
                IntPtr pMemory = IntPtr.Zero;
                try
                {
                    IntPtr pFile = ShareMemoryAPI.CreateFileMapping(ShareMemoryAPI.INVALID_HANDLE_VALUE, IntPtr.Zero, ShareMemoryAPI.PAGE_READWRITE,
                                                     0, (uint)(imageWidth * imageHeight * sizeof(byte) * imageDepth / 8), lpName);
                    if (IntPtr.Zero == pFile)
                    {
                        ShareMemoryAPI.WriteLog("ShareMemoryAPI.CreateShareMemory");
                        return IntPtr.Zero;
                    }

                    pMemory = ShareMemoryAPI.MapViewOfFile(pFile, ShareMemoryAPI.FILE_MAP_WRITE, 0, 0, (uint)(imageWidth * imageHeight * sizeof(byte) * imageDepth / 8));
                    if (IntPtr.Zero == pMemory)
                    {
                        ShareMemoryAPI.WriteLog("ShareMemoryAPI.MapViewOfFile");
                    }
                    Marshal.Copy(image, 0, pMemory, image.Length);
                    image = new byte[0];
                    image = null;
                    return pFile;
                }
                catch (Exception)
                {
                    ShareMemoryAPI.WriteLog("ShareMemoryWrite.WriteImage");
                    return IntPtr.Zero;
                }
                finally
                {
                    ShareMemoryAPI.UnmapViewOfFile(pMemory);
                }
            }
        }

        /// <summary>
        /// 将未标定激光数据写入至共享内存，
        /// </summary>
        /// <param name="ptr"></param>
        /// <param name="points">未标定激光数据，只有Z值</param>
        /// <param name="row">激光数据行数</param>
        /// <param name="col">激光数据列数</param>
        public static void WriteLaser(string lpName, float[,] points, int row, int col)
        {
            lock (_lockerObj)
            {
                IntPtr pMemory = IntPtr.Zero;
                try
                {
                    IntPtr pFile = ShareMemoryAPI.CreateFileMapping(ShareMemoryAPI.INVALID_HANDLE_VALUE, IntPtr.Zero, ShareMemoryAPI.PAGE_READWRITE,
                                                           0, (uint)(row * col * sizeof(double)), lpName);
                    if (IntPtr.Zero == pFile)
                    {
                        ShareMemoryAPI.WriteLog("ShareMemoryAPI.OpenFileMapping");
                        return;
                    }

                    pMemory = ShareMemoryAPI.MapViewOfFile(pFile, ShareMemoryAPI.FILE_MAP_WRITE, 0, 0, (uint)(row * col * sizeof(double)));
                    if (IntPtr.Zero == pMemory)
                    {
                        ShareMemoryAPI.WriteLog("ShareMemoryAPI.MapViewOfFile");
                        return;
                    }
                    unsafe
                    {
                        fixed (float* p = &points[0, 0])
                        {
                            float* pByter = (float*)pMemory;
                            float* p1 = p;
                            for (int i = 0; i < row; i++)
                            {
                                for (int j = 0; j < col; j++)
                                {
                                    *pByter = *p1;
                                    p1++;
                                    pByter++;
                                }
                            }
                        }
                    }
                }
                catch (Exception)
                {
                    ShareMemoryAPI.WriteLog("ShareMemoryWrite.WriteLaser");
                }
                finally
                {
                    ShareMemoryAPI.UnmapViewOfFile(pMemory);
                }
            }
        }

        /// <summary>
        /// 将已标定激光数据写入至共享内存
        /// </summary>
        /// <param name="lpName"></param>
        /// <param name="pointsX">已标定激光数据X值</param>
        /// <param name="pointsY">已标定激光数据Y值</param>
        /// <param name="pointsZ">已标定激光数据Z值</param>
        /// <param name="row">激光数据行数</param>
        /// <param name="col">激光数据列数</param>
        public static IntPtr WriteLaser(string lpName, float[,] pointsX, float[,] pointsY, float[,] pointsZ, int row, int col)
        {
            lock (_lockerObj)
            {
                IntPtr pMemory = IntPtr.Zero;
                try
                {
                    IntPtr pFile = ShareMemoryAPI.CreateFileMapping(ShareMemoryAPI.INVALID_HANDLE_VALUE, IntPtr.Zero, ShareMemoryAPI.PAGE_READWRITE,
                                                        0, (uint)(row * col * sizeof(double) * 3), lpName);
                    if (IntPtr.Zero == pFile)
                    {
                        ShareMemoryAPI.WriteLog("ShareMemoryAPI.CreateShareMemory");
                        return IntPtr.Zero;
                    }
                    pMemory = ShareMemoryAPI.MapViewOfFile(pFile, ShareMemoryAPI.FILE_MAP_WRITE, 0, 0, (uint)(row * col * sizeof(double) * 3));
                    if (IntPtr.Zero == pMemory)
                    {
                        ShareMemoryAPI.WriteLog("ShareMemoryAPI.MapViewOfFile");
                        return IntPtr.Zero;
                    }
                    unsafe
                    {
                        fixed (float* pX = &pointsX[0, 0], pY = &pointsY[0, 0], pZ = &pointsZ[0, 0])
                        {
                            float* pByter = (float*)pMemory;
                            float* p1 = pX;
                            float* p2 = pY;
                            float* p3 = pZ;
                            for (int i = 0; i < row; i++)
                            {
                                for (int j = 0; j < col; j++)
                                {
                                    // 将当前x、y、z值依次写入共享内存
                                    *pByter = *p1;
                                    *(pByter + 1) = *p2;
                                    *(pByter + 2) = *p3;

                                    // 共享内存指针后移3位，x、y、z数据分别后移一位
                                    pByter += 3;
                                    p1++;
                                    p2++;
                                    p3++;
                                }
                            }
                        }
                    }
                    return pFile;
                }
                catch (Exception)
                {
                    ShareMemoryAPI.WriteLog("ShareMemoryWrite.WriteLaser");
                    return IntPtr.Zero;
                }
                finally
                {
                    ShareMemoryAPI.UnmapViewOfFile(pMemory);
                }
            }
        }
    }
}
JJ爆了
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows下共享内存
04-28
Windows下共享内存
Windows共享内存
qq_29067611的博客
12-13 369
共享内存主要是通过映射机制实现的。 　　Windows 下进程的地址空间在逻辑上是相互隔离的，但在物理上却是重叠的。所谓的重叠是指同一块内存区域可能被多个进程同时使用。当调用 CreateFileMapping 创建命名的内存映射文件对象时，Windows 即在物理内存申请一块指定大小的内存区域，返回文件映射对象的句柄 hMap。为了能够访问这块内存区域必须调用 MapViewOfFile 函数
深入理解和实现Windows进程间通信（共享内存）
最新发布
LeoLei8060的博客
06-21 2575
Windows共享内存（Shared Memory in Windows）是一种操作系统机制，允许不同的进程（程序）共享一段内存空间。这意味着多个进程可以同时访问同一个内存区域，用以交换数据或进行通信，这是进程间通信（IPC）的一种形式。使用共享内存通常可以提高应用程序之间的数据交换效率，因为它避免了数据的复制过程，直接在内存中进行读写。基于实际的磁盘文件或系统分页文件来创建内存映射文件对象。
windows的共享内存
weixin_30360497的博客
08-07 63
https://blog.csdn.net/stpeace/article/details/39534361 转载于:https://www.cnblogs.com/132818Creator/p/9435670.html
Windows共享内存示例
weixin_34128839的博客
04-28 314
　　共享内存主要是通过映射机制实现的。　　Windows 下进程的地址空间在逻辑上是相互隔离的，但在物理上却是重叠的。所谓的重叠是指同一块内存区域可能被多个进程同时使用。当调用 CreateFileMapping 创建命名的内存映射文件对象时，Windows 即在物理内存申请一块指定大小的内存区域，返回文件映射对象的句柄 hMap。为了能够访问这块内存区域必须调用 MapViewOfFile 函数...
Windows驱动中通过MDL实现用户态与核心态共享内存
世事难料，保持低调
11-19 5310
Windows驱动跑在核心态(Kernel mode)，驱动的调用者跑在用户态。如何使用户态进程与核心态驱动共享内存呢 ? 我们知道32位Windows中，默认状态下虚拟空间有4G，前2G是每个进程私有的，也就是说在进程切换的时候会变化，后2G是操作系统的，所以是固定的。既然用户态进程和核心态驱动在同一个进程空间里，是不是只要直接传个内存地址过来，就可以访问了？理论上可以但实际上不行，因为用
shm.rar_进程共享内存
09-24
在IT领域，进程共享内存是一种高效的数据通信方式，它允许多个进程之间共享同一块内存空间，从而实现数据的快速交换。这种技术广泛应用于并发编程，特别是在多处理器或多核系统中，能够极大地提高程序的执行效率。 ...
Windows共享内存使用方法
01-02
共享内存是一种在多进程间高效通信的技术，尤其在Windows操作系统中，它被广泛应用于需要快速交换数据的进程间通信（IPC）...这些文件可以帮助你深入理解并掌握Windows下的共享内存技术，以便在实际项目中灵活运用。
Windows进程通信_共享内存
12-20
标题“Windows进程通信_共享内存”提示我们，这个项目或教程将专注于如何在Windows系统下利用共享内存来实现进程间的通信。共享内存的优势在于它的高速性，因为它避免了传统通信方式中的数据复制步骤。 描述中提到...
Windows进程间通信之共享内存
05-13
共享内存方式实现进程间通信。详细看我的博客：http://blog.csdn.net/pengguokan/article/details/8921346
进程共享内存
02-15
进程共享内存是操作系统中一种进程间通信（IPC, Inter-Process Communication）机制，它允许不同进程之间直接交换数据，而无需通过传统的输入/输出或消息传递。这种通信方式速度快，效率高，因为数据只需在内存中...
windows共享内存操作
09-20
windows 共享内存
windows中进程共享内存的方法
01-05
该文档介绍了在windows上进程间几种共享内存的方式
共享内存技术代码
11-21
共享内存技术代码，此代码是已经封装好的共享内存，可以直接使用
【Windows进程通信】共享内存
Flywithdawn的博客
04-14 1426
共享内存主要是通过映射机制实现的。 　　Windows 下进程的地址空间在逻辑上是相互隔离的，但在物理上却是重叠的。所谓的重叠是指同一块内存区域可能被多个进程同时使用。系统把同一块内存区域映射到了不同进程的地址空间中，从而达到共享内存的目的。 　　示例代码中，一方是QT编写的程序来创建并读取共享内存的内容，另一方是VC程序修改共享内存中的内容： 　　QT： #include "mainwindow.h" #include "ui_mainwindow.h" #include <QDebug> #
windows上共享内存操作
llfjcmx的博客
05-27 6850
windows共享内存 共享内存主要是通过映射机制实现的。windows下进程的地址空间在逻辑上是相互隔离的，但是在物理上确实相互重叠的。所谓的重叠是指同一块内存区域可能被多个进程同时使用。 在windows程序开发过程中，当多个进程之间需要访问共同的数据的时候，最好的方式就是使用共享内存进行处理。 编写共享内存的程序模式上基本上是一样的，大致为下面几个过程： 调用CreateFileMappi...
windows共享内存的使用
MY博客
02-18 2162
windows共享内存的使用 1、共享内存 进程之间通过共享内存的方式通信。 2、使用逻辑 首先开启一块共享区域，并且给这个名字指定一个唯一名称标识。然后获取这块共享区域的指针，对其实现读写。 第一步： 打开一个内存映射的句柄（handle），前提是该内存映射区域已经被创建。 第二步： 如果第一步打开失败，则需要创建该内存映射的句柄（handle）。 第三步： 获取该共享内存在当前进程地址空间的映射地址。也可以是指定共享内存的一部分区域的指针。 第四步： 获取地址指针后，可以进行内容的读
Windows共享内存以及相关函数的使用
浴血重生-学习空间
01-29 3799
程序与程序之间、进程与进程之间、线程与线程之间进行数据交互与共享的方法是决定一个程序运行效率与速度的关键。 方法1：共享内存函数 CreateFileMapping HANDLE CreateFileMapping( HANDLE hFile, //物理文件句柄 LPSECURITY_ATTRIBUTES lpAttributes,
共享内存技术
Gaodes的博客
11-21 861
共享内存允许两个不相关的进程去访问同一部分逻辑内存 如果需要在两个运行中的进程之间传输数据，共享内存将是一种效率极高的解决方案。 共享内存是由IPC为一个进程创建的一个特殊的地址范围，它将出现在进程的地址空间中。 其他进程可以把同一段共享内存段“连接到”它们自己的地址空间里去。 所有进程都可以访问共享内存地址，就好像它们是有malloc分配的一样 如果一个进程向这段共享内存写了数据，所做的改动会...
windows进程共享内存
05-21
在Windows中，进程间可以通过共享内存来进行数据交换。具体步骤如下： 1. 使用 CreateFileMapping 函数来创建一个文件映射对象。这个函数可以创建一个内存映射文件，也可以创建一个匿名内存映射。 2. 使用 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值