c# 调用win32 API

最新推荐文章于 2024-01-11 17:31:37 发布
最新推荐文章于 2024-01-11 17:31:37 发布
阅读量2k 收藏
点赞数
分类专栏： c# 文章标签： c# api string user c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peter_666/article/details/7860315
版权 
[DllImport("User32.dll")]
        public static extern int MessageBox(int h, string m, string c, int type);

        static int TestWinApi()
        {
            MessageBox(0, "Hello Win32 Api", "peter", 4);
            Console.ReadLine();
            return 0;
        }

C#如何调用非托管代码


sender

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

namespace Client
{
    /// <summary>
    /// Sender(Client)
    /// </summary>
    class Program
    {

        static void Main(string[] args)
        {
            // 定义管道的名字
            string pipeName = "\\\\.\\pipe\\MyPipe";

            while (true)
            {
                Console.WriteLine("input:");

                string msg = Console.ReadLine();

                if (msg == "EXIT")
                    break;

                #region  package infomation

                    //定义转换类的一个对象并初始化

                    Converter Convert = new Converter();

                    //定义消息结构体

                    MyMessage m;
                    //初始化消息结构体

                    m = new MyMessage(msg);

                    m.cmd_type = 1633837924;

                    m.srcID = 1633837925;

                    m.dstID = 1633837926;

                    //使用转换类的对象的StructToBytes方法把m结构体转换成Byte

                    Byte[] msgBuffer = Convert.StructToBytes(m);

                #endregion

                IntPtr fileHandle;

                while (true)
                {
                    // 创建命名管道
                    fileHandle = NamedPipeNative.CreateFile(pipeName,
                        NamedPipeNative.GENERIC_READ | NamedPipeNative.GENERIC_WRITE,
                        0, null, NamedPipeNative.OPEN_EXISTING, 0, 0);

                    // 创建失败时，跳出循环
                    if (fileHandle.ToInt32() != NamedPipeNative.INVALID_HANDLE_VALUE)
                    {
                        break;
                    }

                    // 无法打开管道时，不再执行下面的操作
                    if (NamedPipeNative.GetLastError() != NamedPipeNative.ERROR_PIPE_BUSY)
                    {
                        Console.WriteLine("pipe is busing");
                        return;
                    }
                    if (!NamedPipeNative.WaitNamedPipe(pipeName, 20000))
                    {
                        Console.WriteLine("can't open pipe");
                        return;
                    }
                }

                uint pipeMode = NamedPipeNative.PIPE_READMODE_MESSAGE;

                bool success = NamedPipeNative.SetNamedPipeHandleState(fileHandle, ref pipeMode, IntPtr.Zero, IntPtr.Zero);

                if (!success)
                {
                    Console.WriteLine("设置管道状态失败");
                    return;
                }

                // 定义信息的长度
                uint len = (uint)msgBuffer.Length;

                byte[] numReadWritten = new byte[4];

                // 把数据写到管道
                success = NamedPipeNative.WriteFile(fileHandle, BitConverter.GetBytes(len), 4, numReadWritten, 0);

                // 写入数据失败时的处理
                if (!success)
                {
                    Console.WriteLine("写入数据失败");
                    return;
                }
                else
                {
                    NamedPipeNative.WriteFile(fileHandle, msgBuffer, len, numReadWritten, 0);
                }

                // 关闭打开的管道
                NamedPipeNative.CloseHandle(fileHandle);
            }
        }
    }
}

reveiver 


using System;
using System.Collections.Generic;
using System.Text;
using NamedPipeLib;
using System.Threading;

namespace Server
{
    /// <summary>
    /// Receive(Server)
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            while (true)
            {
                // 实例化跨网通讯，双向的可靠的管道
                IntPtr pipeHandle = NamedPipeNative.CreateNamedPipe(
                             "\\\\.\\pipe\\MyPipe",
                             NamedPipeNative.PIPE_ACCESS_DUPLEX,
                             NamedPipeNative.PIPE_TYPE_MESSAGE | NamedPipeNative.PIPE_READMODE_MESSAGE,
                             NamedPipeNative.PIPE_UNLIMITED_INSTANCES,
                             1024,
                             1024,
                             0,
                             IntPtr.Zero);

                // 返回前一个异常
                uint u = NamedPipeNative.GetLastError();

                // 创建实例失败时，返回INVALID_HANDLE_VALUE
                if (pipeHandle.ToInt32() == NamedPipeNative.INVALID_HANDLE_VALUE)
                {
                    Console.WriteLine("创建管道出错");
                    return;
                }

                // 启用命名管道服务器进程等待一个客户进程连接到命名管道实例。成功时返回true，失败时返回ERROR_PIPE_CONNECTED
                bool connected = NamedPipeNative.ConnectNamedPipe(pipeHandle, null) ? true : (NamedPipeNative.GetLastError() == NamedPipeNative.ERROR_PIPE_CONNECTED);
                
                // 成功启用命名管道服务器进程等待一个客户进程连接到命名管道实例
                if (connected)
                {
                    // 将ReadMessage方法排入队列以便执行，并指定包含该方法所用数据的对象pipeHandle。
                    // 此方法在有线程池线程变得可用时执行。
                    ThreadPool.QueueUserWorkItem(new WaitCallback(ReadMessage), pipeHandle);
                }
                else
                {
                    // 失败时，关闭打开的pipeHandle对象
                    NamedPipeNative.CloseHandle(pipeHandle);
                }
            }
 
        }

        /// <summary>
        /// 读取客户端数据
        /// </summary>
        /// <param name="arg"></param>
        public static void ReadMessage(object arg)
        {
            // 取得管道对象
            IntPtr pipeHandle = (IntPtr)arg;
  
            byte[] numReadWritten = new byte[4];
            byte[] intBytes = new byte[4];

            NamedPipeNative.ReadFile(pipeHandle, intBytes, 4, numReadWritten, 0);

            int len = BitConverter.ToInt32(intBytes, 0);

            byte[] recBuffer=new byte[len];

            NamedPipeNative.ReadFile(pipeHandle, recBuffer, (uint)len, numReadWritten, 0);

            // 取得客户端发送的信息
            //string str=Encoding.UTF8.GetString(recBuffer);

            #region  package infomation
            //定义转换类的一个对象并初始化
            Converter Convert = new Converter();
            MyMessage m = new MyMessage();
            MyMessage mm = (MyMessage)Convert.BytesToStruct(recBuffer, m.GetType());
            Console.WriteLine("1"+mm.cmd_type);
            Console.WriteLine("2"+mm.username);
            Console.WriteLine("3"+mm.srcID);
            Console.WriteLine("4"+mm.dstID);
            #endregion

            // 一个已被某客户端连接的管道句柄在被另一客户通过 ConnectNamedPipe建立连接之前，服务端必须用DisconnectNamedPipe函数对已存在的连接进行强行拆离。
            // 服务端拆离管道会造成管道中数据的丢失，用FlushFileBuffers函数可以保证数据不被丢失。
            NamedPipeNative.FlushFileBuffers(pipeHandle); // 刷新缓冲区的指定文件，并把所有缓冲数据写入到一个文件。
            // 从客户端进程断开以服务器端命名的管道实例
            NamedPipeNative.DisconnectNamedPipe(pipeHandle);
            // 关闭打开的管道对象
            NamedPipeNative.CloseHandle(pipeHandle); 
        }
    }
}

namlib 


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


namespace NamedPipeLib
{

    public static class NamedPipeNative
    {
        /// <summary>
        /// 3
        /// </summary>
        public const uint PIPE_ACCESS_DUPLEX = 0x00000003;
        /// <summary>
        /// 2
        /// </summary>
        public const uint PIPE_READMODE_MESSAGE = 0x00000002;
        /// <summary>
        /// 4
        /// </summary>
        public const uint PIPE_TYPE_MESSAGE = 0x00000004;
        /// <summary>
        /// 0
        /// </summary>
        public const uint PIPE_WAIT = 0x00000000;

        public const uint PIPE_UNLIMITED_INSTANCES = 255;

        public const int INVALID_HANDLE_VALUE = -1;

        public const ulong ERROR_PIPE_CONNECTED = 535;
        /// <summary>
        /// 1G
        /// </summary>
        public const uint GENERIC_WRITE = (0x40000000);

        /// <summary>
        /// 2G
        /// </summary>
        public const uint GENERIC_READ = (0x80000000);

        public const uint OPEN_EXISTING = 3;

        public const ulong ERROR_PIPE_BUSY = 231;
        
        /// <summary>
        /// 非托管代码调用  把win32要转成c#数据类型
        /// </summary>
        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern IntPtr CreateFile(
            String lpFileName,						  // file name
            uint dwDesiredAccess,					  // access mode
            uint dwShareMode,								// share mode
            SecurityAttributes attr,				// SD
            uint dwCreationDisposition,			// how to create
            uint dwFlagsAndAttributes,			// file attributes
            uint hTemplateFile);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern IntPtr CreateNamedPipe(
            String lpName,									// pipe name
            uint dwOpenMode,								// pipe open mode
            uint dwPipeMode,								// pipe-specific modes
            uint nMaxInstances,							// maximum number of instances
            uint nOutBufferSize,						// output buffer size
            uint nInBufferSize,							// input buffer size
            uint nDefaultTimeOut,						// time-out interval
            IntPtr pipeSecurityDescriptor		// SD
            );


        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool ConnectNamedPipe(
            IntPtr hHandle,									// handle to named pipe
            Overlapped lpOverlapped					// overlapped structure
            );


        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool ReadFile(
            IntPtr hHandle,											// handle to file
            byte[] lpBuffer,								// data buffer
            uint nNumberOfBytesToRead,			// number of bytes to read
            byte[] lpNumberOfBytesRead,			// number of bytes read
            uint lpOverlapped								// overlapped buffer
            );


        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool WriteFile(
            IntPtr hHandle,											// handle to file
            byte[] lpBuffer,							  // data buffer
            uint nNumberOfBytesToWrite,			// number of bytes to write
            byte[] lpNumberOfBytesWritten,	// number of bytes written
            uint lpOverlapped								// overlapped buffer
            );


        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool FlushFileBuffers(
            IntPtr hHandle);


        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool DisconnectNamedPipe(
            IntPtr hHandle);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool SetNamedPipeHandleState(
            IntPtr hHandle,
            ref uint mode,
            IntPtr cc,
            IntPtr cd);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool WaitNamedPipe(
            String name,
            int timeout);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern bool CloseHandle(
            IntPtr hHandle);

        [DllImport("kernel32.dll", SetLastError = true)]
        public static extern uint GetLastError();

    }

    [StructLayout(LayoutKind.Sequential)]
    public class Overlapped
    {
    }

    [StructLayout(LayoutKind.Sequential)]
    public class SecurityAttributes
    {
    }
}

mymessage 


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

namespace NamedPipeLib
{
    /// <summary>
    /// define struct message
    /// </summary>
    [StructLayout(LayoutKind.Sequential, Pack = 1)]
    public struct MyMessage
    {

        public UInt32 cmd_type;

        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]

        public string username;

        public UInt32 dstID;

        public UInt32 srcID;

        public MyMessage(string s)
        {

            cmd_type = 0;

            username = s;

            dstID = 0;

            srcID = 0;
        }

    }
}

cover 


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

namespace NamedPipeLib
{
    public class Converter
    {
        public Byte[] StructToBytes(Object structure)
        {

            Int32 size = Marshal.SizeOf(structure);

            //Console.WriteLine(size);

            IntPtr buffer = Marshal.AllocHGlobal(size);

            try
            {

                Marshal.StructureToPtr(structure, buffer, false);

                Byte[] bytes = new Byte[size];

                Marshal.Copy(buffer, bytes, 0, size);

                return bytes;

            }

            finally
            {

                Marshal.FreeHGlobal(buffer);

            }

        }

        public Object BytesToStruct(Byte[] bytes, Type strcutType)
        {

            Int32 size = Marshal.SizeOf(strcutType);

            IntPtr buffer = Marshal.AllocHGlobal(size);

            try
            {

                Marshal.Copy(bytes, 0, buffer, size);

                return Marshal.PtrToStructure(buffer, strcutType);

            }

            finally
            {

                Marshal.FreeHGlobal(buffer);

            }

        }
    }
}


peter_666
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 使用Win32 API的一些方法
BeanGo的博客
12-27 573
C# 使用Win32 API的一些方法
C#中调用Windows API
a3676212的专栏
12-30 605
C#中调用Windows API一、调用格式using System.Runtime.InteropServices; //引用此名称空间，简化后面的代码...//使用DllImportAttribute特性来引入api函数，注意声明的是空方法，即方法体为空。[DllImport("user32.dll")]public static extern ReturnType FunctionName(
Microsoft Win32 API函数的完整参考手册
01-07
Microsoft Win32 API函数的完整参考手册！
win32 CreateEvent
abc
05-31 596
参考网页： https://msdn.microsoft.com/en-us/library/windows/desktop/ms682396(v=vs.85).aspx Creates or opens a named or unnamed event object. To specify an access mask for the object, use the CreateEve...
C#代码中如何引用win32的函数
sunjiaoya的博客
03-21 516
C#代码中如何引用win32的函数
c#和WIN32 调用
weixin_30500663的博客
10-13 527
作者：刘铁猛日期：2005-12-20关键字：C# .NET Win32 API 版权声明:本文章受知识产权法保护，如果阁下想转载,在转载的时候烦劳阁下连同在下的姓名一起转载,并向bladey@tom.com发一个Mail,我很想知道我的文章都去哪里了.谢谢. 小序 Win32 API可以直接控制Microsoft Windows的核心，因为API（Application Pro...
关于使用C#调用Win32API,抓取第三方句柄,模拟鼠标点击,键盘发送事件(C2Prog.exe)
weixin_58819477的博客
05-23 3911
这个就是我们刚才拿到的句柄 0x0201 和0X0202分别是鼠标左键按下和弹起 我们运行后可以看到软件上按钮确实被单击了，你们要自己实践。这里需要注意一下我们的第三方软件句柄是每次重新打开软件都会重新分配的,所以句柄是一个不确定的值,那么我们该如何获取呢?我们只需要拖动查找工具,就是哪个圆形东西到指定窗体就能拿到窗体的句柄了。可以清晰看到我们的效果 文本框里面已经获取到了窗体的句柄 110BA8。我们只查找我们需要的,打开我们需要查找句柄的窗体。首先打开我们的SPY++工具。我用的工具是SPY++
C# 调用 Win32 API 源码
12-10
总结来说，C#调用Win32 API的过程包括定义API函数、结构体和枚举，然后使用P/Invoke调用这些API以执行特定任务。"Enums.cs"、"Win32API.cs"和"Structs.cs"文件分别包含了必要的定义，使得C#代码能够正确地与Win32 ...
C#调用win32 获取打印机状态
08-02
总结起来，C#调用Win32 API获取打印机状态是一个涉及到操作系统交互的过程，需要理解Win32 API的工作原理，并能正确地在C#中导入和使用这些API。通过这种方式，开发者可以构建出更强大的应用程序，能够实时监控和...
C#调用Win32 API如何处理指针类型的参数
01-17
在C#中调用Win32 API时处理指针类型的参数是一个常见的需求，尤其是在与操作系统底层交互或利用已有C/C++库功能时。Win32 API通常使用指针来传递数据，而C#作为一种托管语言，其对指针的支持有限且更安全。本文将...
C# 通过Win32的API来调用系统菜单
03-05
C# 通过Win32的API来调用系统菜单 C# 通过调用Win32的API来控制系统操作菜单，单就菜单来说，没有什么可借鉴的，但是实现的方法是学习重点，如上图示，通过程序可以复位系统菜单等操作。
c#使用win32api实现获取光标位置
09-02
这种方法通过调用Win32 API中的`mouse_event`函数来模拟鼠标移动和点击。`mouse_event`函数接受多个参数，包括鼠标事件类型（例如移动、左键按下/释放）以及坐标信息。这里，我们首先获取屏幕的尺寸，然后获取鼠标...
常用Win32API(C#里调用)
04-12
在这个主题中，我们将探讨如何在C#中调用Win32 API，并介绍几个常见的API函数。 首先，调用Win32 API通常需要使用`[DllImport]`特性来导入DLL（动态链接库）中的函数。例如，`GetDC`函数用于获取窗口的设备上下文...
C#【高级篇】.NET平台调用Win32 API
星Yeah 的博客
10-11 3422
.NET平台调用Win32 API
C# 使用Win32API 设置一个进程的窗口置顶显示
weixin_38940097的博客
09-14 2774
需求背景 需要满足打开一个进程，且要这个进程的窗口要显示在当前程序的窗口之上 设置SetWindowLong并不能置顶 ComNativeMethods.SetWindowLong(intPtr, -8, Parent); 尝试过设置父窗口的句柄，发现不行。 解决办法 需要调用2个API接口 //先设置窗口的显示层级 ComNativeMethods.SetWindowPos(intPtr, new IntPtr(ComNativeMethods.HWND_TOPMOST), 0, 0
C# win32 API编程(超详细)
03-02 7041
C# win32 API编程C# 用户经常提出两个问题：“我为什么要另外编写代码来使用内置于 Windows 中的功能？在框架中为什么没有相应的内容可以为我完成这一任务？”当框架小组构建他们的 .NET 部分时，他们评估了为使 .NET 程序员可以使用 Win32 而需要完成的工作，结果发现 Win32 API 集非常庞大。他们没有足够的资源为所有 Win32 API 编写托管接口、加以测试并
C#调用WinAPI部分命令
最新发布
dgnankai的专栏
01-11 888
C#是针对WIndows而生的，开发WIndows应用最快。然而想要让自己程序进阶，就不需深入Windows底层，WinAPI为我们提供了一把利刃。
理解C#调用Win32 API：内存管理和错误处理实践
ck23456的博客
11-13 212
在C#中调用Win32 API，是一种在托管环境中调用非托管函数的方法，它使得我们可以在C#程序中直接使用操作系统级别的功能。然而，在这个过程中，我们需要处理一些特殊的问题，其中最重要的两个就是内存管理和错误处理。本文将详细讲解如何处理这两个问题。虽然在C#中调用Win32 API需要处理一些额外的问题，如内存管理和错误处理，但只要我们理解了这些问题的原因，并学会了如何处理这些问题，就可以在C#中顺利使用Win32 API。希望本文能帮助你更好地理解和使用Win32 API。
C#有GUI交互的windows服务
peter_666的专栏
10-24 5103
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Security.Principal; using System.Runtime.InteropServices; namespace SchedulerServer {     c
C#调用Win32 API：Beep函数示例
"C# 调用 Win32 API 编程的示例和注意事项" C# 是一种面向对象的编程语言，通常用于构建 .NET 框架的应用程序。然而，有时开发者可能需要访问操作系统底层的功能，这些功能可能没有在 .NET Framework 中直接提供。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值