进程监控

最新推荐文章于 2024-08-29 13:00:00 发布
最新推荐文章于 2024-08-29 13:00:00 发布
阅读量254 收藏
点赞数
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012329314/article/details/71523963
版权

    本来以hook方式hook系统api函数，后来发现不同的进程启动走的函数api是不同的，特别的对于父进程不是explorer的，比如在cmd下启动的exe这样hook的方式就不能够实现的。linux下有do_fork函数。win只能走内核去监控，幸好，微软为我们考虑了这层。开放了PsSetCreateProcessNotifyRoutine函数来实现进程线程的监控.

#include "ntddk.h"
#include "windef.h"
#include "define.h"

#define SYSNAME "System"
#define VERSIONLEN 100

const WCHAR devLink[] = L"\\DosDevices\\MyEvent";
const WCHAR devName[] = L"\\Device\\MyEvent";
UNICODE_STRING          devNameUnicd;
UNICODE_STRING          devLinkUnicd;
PVOID                    gpEventObject = NULL;            // 与应用程序通信的 Event 对象
ULONG                    ProcessNameOffset = 0;
PVOID                    outBuf[255];
BOOL                    g_bMainThread;
ULONG                    g_dwParentId;
CHECKLIST                CheckList;
ULONG                    BuildNumber;                    //系统版本号                    
ULONG                    SYSTEMID;                    //System进程的ID
PWCHAR                    Version[VERSIONLEN];

NTSTATUS PsLookupProcessByProcessId(IN ULONG ulProcId, OUT PEPROCESS * pEProcess);

ULONG GetProcessNameOffset()
{
    PEPROCESS curproc;
    int i;

    curproc = PsGetCurrentProcess();

    for (i = 0; i < 3 * PAGE_SIZE; i++)
    {
        if (!strncmp(SYSNAME, (PCHAR)curproc + i, strlen(SYSNAME)))
        {
            return i;
        }
    }

    return 0;
}

NTSTATUS GetRegValue(PCWSTR RegPath, PCWSTR ValueName, PWCHAR Value)
{
    int ReturnValue = 0;
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE KeyHandle;
    PKEY_VALUE_PARTIAL_INFORMATION valueInfoP;
    ULONG valueInfoLength, returnLength;
    UNICODE_STRING UnicodeRegPath;
    UNICODE_STRING UnicodeValueName;

    RtlInitUnicodeString(&UnicodeRegPath, RegPath);
    RtlInitUnicodeString(&UnicodeValueName, ValueName);

    InitializeObjectAttributes(&ObjectAttributes,
        &UnicodeRegPath,
        OBJ_CASE_INSENSITIVE, // Flags
        NULL, // Root directory
        NULL); // Security descriptor

    Status = ZwOpenKey(&KeyHandle,
        KEY_ALL_ACCESS,
        &ObjectAttributes);
    if (Status != STATUS_SUCCESS)
    {
        DbgPrint("ZwOpenKey Wrong\n");
        return 0;
    }

    valueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION)+VERSIONLEN;
    valueInfoP = (PKEY_VALUE_PARTIAL_INFORMATION)ExAllocatePool
        (NonPagedPool, valueInfoLength);
    Status = ZwQueryValueKey(KeyHandle,
        &UnicodeValueName,
        KeyValuePartialInformation,
        valueInfoP,
        valueInfoLength,
        &returnLength);

    if (!NT_SUCCESS(Status))
    {
        DbgPrint("ZwQueryValueKey Wrong:%08x\n", Status);
        return Status;
    }
    else
    {
        RtlCopyMemory((PCHAR)Value, (PCHAR)valueInfoP->Data, valueInfoP->DataLength);
        ReturnValue = 1;
    }

    if (!valueInfoP);
    ExFreePool(valueInfoP);
    ZwClose(KeyHandle);
    return ReturnValue;
}

VOID ThreadCreateMon(IN HANDLE PId, IN HANDLE TId, IN BOOLEAN  bCreate)
{

    PEPROCESS   EProcess, PEProcess;
    NTSTATUS    status;
    HANDLE        dwParentPID;

    status = PsLookupProcessByProcessId((ULONG)PId, &EProcess);
    if (!NT_SUCCESS(status))
    {
        DbgPrint("PsLookupProcessByProcessId()\n");
        return;
    }

    if (bCreate)
    {
        dwParentPID = PsGetCurrentProcessId();
        status = PsLookupProcessByProcessId(
            (ULONG)dwParentPID,
            &PEProcess);
        if (!NT_SUCCESS(status))
        {
            DbgPrint("PsLookupProcessByProcessId()\n");
            return;
        }
        if (PId == 4)    //System进程创建的东东我们不管
            //在2000下是0,在XP后是4
            return;
        if ((g_bMainThread == TRUE)
            && (g_dwParentId != dwParentPID)
            && (dwParentPID != PId)
            )
        {
            g_bMainThread = FALSE;
            sprintf(outBuf, "=============================="
                "Remote Thread :"
                "=============================="
                "\nT:%18s%9d%9d%25s%9d\n"
                "======================================"
                "======================================\n",
                (char *)((char *)EProcess + ProcessNameOffset),
                PId, TId,
                (char *)((char *)PEProcess + ProcessNameOffset), dwParentPID);
            if (gpEventObject != NULL)
                KeSetEvent((PRKEVENT)gpEventObject, 0, FALSE);
        }
        if (CheckList.ONLYSHOWREMOTETHREAD)    //只显示远线程
            return;
        DbgPrint("T:%18s%9d%9d%25s%9d\n",
            (char *)((char *)EProcess + ProcessNameOffset),
            PId, TId,
            (char *)((char *)PEProcess + ProcessNameOffset), dwParentPID);
        sprintf(outBuf, "T:%18s%9d%9d%25s%9d\n",
            (char *)((char *)EProcess + ProcessNameOffset),
            PId, TId,
            (char *)((char *)PEProcess + ProcessNameOffset), dwParentPID);
        if (gpEventObject != NULL)
            KeSetEvent((PRKEVENT)gpEventObject, 0, FALSE);
    }
    else if (CheckList.SHOWTERMINATETHREAD)
    {
        DbgPrint("TERMINATED == THREAD ID: %d\n", TId);
        sprintf(outBuf, "TERMINATED == THREAD ID: %d\n", TId);
        if (gpEventObject != NULL)
            KeSetEvent((PRKEVENT)gpEventObject, 0, FALSE);
    }
}


VOID ProcessCreateMon(HANDLE hParentId, HANDLE PId, BOOLEAN bCreate)
{

    PEPROCESS        EProcess, PProcess;
    NTSTATUS        status;
    HANDLE            TId;

    g_dwParentId = hParentId;
    status = PsLookupProcessByProcessId((ULONG)PId, &EProcess);
    if (!NT_SUCCESS(status))
    {
        DbgPrint("PsLookupProcessByProcessId()\n");
        return;
    }
    status = PsLookupProcessByProcessId((ULONG)hParentId, &PProcess);
    if (!NT_SUCCESS(status))
    {
        DbgPrint("PsLookupProcessByProcessId()\n");
        return;
    }

    if (bCreate)
    {
        g_bMainThread = TRUE;
        DbgPrint("P:%18s%9d%9d%25s%9d\n",
            (char *)((char *)EProcess + ProcessNameOffset),
            PId, PsGetCurrentThreadId(),
            (char *)((char *)PProcess + ProcessNameOffset),
            hParentId
            );
        sprintf(outBuf, "P:%18s%9d%9d%25s%9d\n",
            (char *)((char *)EProcess + ProcessNameOffset),
            PId, PsGetCurrentThreadId(),
            (char *)((char *)PProcess + ProcessNameOffset),
            hParentId
            );
        if (gpEventObject != NULL)
            KeSetEvent((PRKEVENT)gpEventObject, 0, FALSE);
    }
    else if (CheckList.SHOWTERMINATEPROCESS)
    {
        DbgPrint("TERMINATED == PROCESS ID: %d\n", PId);
        sprintf(outBuf, "TERMINATED == PROCESS ID: %d\n", PId);
        if (gpEventObject != NULL)
            KeSetEvent((PRKEVENT)gpEventObject, 0, FALSE);
    }

}

NTSTATUS OnUnload(IN PDRIVER_OBJECT pDriverObject)
{
    DbgPrint("OnUnload called\n");
    return STATUS_SUCCESS;
}

NTSTATUS DeviceIoControlDispatch(
    IN  PDEVICE_OBJECT  DeviceObject,
    IN  PIRP            pIrp
    )
{
    PIO_STACK_LOCATION              irpStack;
    NTSTATUS                        status;
    PVOID                           inputBuffer;
    ULONG                           inputLength;
    PVOID                           outputBuffer;
    ULONG                           outputLength;
    OBJECT_HANDLE_INFORMATION        objHandleInfo;

    status = STATUS_SUCCESS;
    // 取出IOCTL请求代码
    irpStack = IoGetCurrentIrpStackLocation(pIrp);

    switch (irpStack->MajorFunction)
    {
    case IRP_MJ_CREATE:
        DbgPrint("Call IRP_MJ_CREATE\n");
        break;
    case IRP_MJ_CLOSE:
        DbgPrint("Call IRP_MJ_CLOSE\n");
        break;
    case IRP_MJ_DEVICE_CONTROL:
        DbgPrint("IRP_MJ_DEVICE_CONTROL\n");
        inputLength = irpStack->Parameters.DeviceIoControl.InputBufferLength;
        outputLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
        switch (irpStack->Parameters.DeviceIoControl.IoControlCode)
        {
        case IOCTL_PASSEVENT:    //用事件做通信
            inputBuffer = pIrp->AssociatedIrp.SystemBuffer;

            DbgPrint("inputBuffer:%08x\n", (HANDLE)inputBuffer);
            status = ObReferenceObjectByHandle(*(HANDLE *)inputBuffer,
                GENERIC_ALL,
                NULL,
                KernelMode,
                &gpEventObject,
                &objHandleInfo);

            if (status != STATUS_SUCCESS)
            {
                DbgPrint("wrong\n");
                break;
            }
            break;
        case IOCTL_UNPASSEVENT:
            if (gpEventObject)
                ObDereferenceObject(gpEventObject);
            DbgPrint("UNPASSEVENT called\n");
            break;
        case IOCTL_PASSBUF:
            RtlCopyMemory(pIrp->UserBuffer, outBuf, outputLength);
            break;
        case IOCTL_PASSEVSTRUCT:
            inputBuffer = pIrp->AssociatedIrp.SystemBuffer;
            memset(&CheckList, 0, sizeof(CheckList));
            RtlCopyMemory(&CheckList, inputBuffer, sizeof(CheckList));
            DbgPrint("%d:%d\n", CheckList.ONLYSHOWREMOTETHREAD, CheckList.SHOWTHREAD);
            break;
        default:
            break;
        }
        break;
    default:
        DbgPrint("Call IRP_MJ_UNKNOWN\n");
        break;
    }

    pIrp->IoStatus.Status = status;
    pIrp->IoStatus.Information = 0;
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    return status;
}

NTSTATUS DriverEntry(IN PDRIVER_OBJECT pDriverObject, IN PUNICODE_STRING theRegistryPath)
{
    NTSTATUS                Status;
    PDEVICE_OBJECT            pDevice;

    DbgPrint("DriverEntry called!\n");
    g_bMainThread = FALSE;

    if (1 != GetRegValue(L"\\Registry\\Machine\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", L"CSDVersion", Version))
    {
        DbgPrint("GetRegValueDword Wrong\n");
    }
    PsGetVersion(NULL, NULL, &BuildNumber, NULL);
    DbgPrint("[[[%d]]]:[[[%ws]]]", BuildNumber, Version);

    RtlInitUnicodeString(&devNameUnicd, devName);
    RtlInitUnicodeString(&devLinkUnicd, devLink);

    Status = IoCreateDevice(pDriverObject,
        0,
        &devNameUnicd,
        FILE_DEVICE_UNKNOWN,
        0,
        TRUE,
        &pDevice);
    if (!NT_SUCCESS(Status))
    {
        DbgPrint(("Can not create device.\n"));
        return Status;
    }

    Status = IoCreateSymbolicLink(&devLinkUnicd, &devNameUnicd);
    if (!NT_SUCCESS(Status))
    {
        DbgPrint(("Cannot create link.\n"));
        return Status;
    }

    ProcessNameOffset = GetProcessNameOffset();

    pDriverObject->DriverUnload = OnUnload;
    pDriverObject->MajorFunction[IRP_MJ_CREATE] =
        pDriverObject->MajorFunction[IRP_MJ_CLOSE] =
        pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DeviceIoControlDispatch;//irp有27个派遣例程 具体参照相关的头文件

    Status = PsSetCreateProcessNotifyRoutine(ProcessCreateMon, FALSE);
    if (!NT_SUCCESS(Status))
    {
        DbgPrint("PsSetCreateProcessNotifyRoutine()\n");
        return Status;
    }

    Status = PsSetCreateThreadNotifyRoutine(ThreadCreateMon);
    if (!NT_SUCCESS(Status))
    {
        DbgPrint("PsSetCreateThreadNotifyRoutine()\n");
        return Status;
    }

    return STATUS_SUCCESS;
}#include "stdio.h"

#define FILE_DEVICE_EVENT  0x8000

// Define Interface reference/dereference routines for
// Interfaces exported by IRP_MN_QUERY_INTERFACE

#define EVENT_IOCTL(index) \
    CTL_CODE(FILE_DEVICE_EVENT, index, METHOD_BUFFERED, FILE_READ_DATA)

#define IOCTL_PASSEVENT \
    CTL_CODE(FILE_DEVICE_EVENT, 0x801, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_PASSBUF \
    CTL_CODE(FILE_DEVICE_EVENT, 0x802, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_UNPASSEVENT \
    CTL_CODE(FILE_DEVICE_EVENT, 0x803, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_PASSEVSTRUCT \
    CTL_CODE(FILE_DEVICE_EVENT, 0x804, METHOD_BUFFERED, FILE_ANY_ACCESS)

typedef struct        
{
    int SHOWTHREAD;
    int ONLYSHOWREMOTETHREAD;
    int SHOWTERMINATEPROCESS;
    int SHOWTERMINATETHREAD;
}CHECKLIST, *PCHECKLIST;


win2003 部分头找不到 

用这个 
#include "stdio.h"
#define FILE_DEVICE_EVENT  0x8000

#define FILE_ANY_ACCESS  0
#define METHOD_BUFFERED  0

#define CTL_CODE( DeviceType, Function, Method, Access ) (                 \
    ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \
    )

// Define Interface reference/dereference routines for
// Interfaces exported by IRP_MN_QUERY_INTERFACE

#define EVENT_IOCTL(index) \
    CTL_CODE(FILE_DEVICE_EVENT, index, METHOD_BUFFERED, FILE_READ_DATA)

#define IOCTL_PASSEVENT \
    CTL_CODE(FILE_DEVICE_EVENT, 0x801, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_PASSBUF \
    CTL_CODE(FILE_DEVICE_EVENT, 0x802, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_UNPASSEVENT \
    CTL_CODE(FILE_DEVICE_EVENT, 0x803, METHOD_BUFFERED, FILE_ANY_ACCESS)
#define IOCTL_PASSEVSTRUCT \
    CTL_CODE(FILE_DEVICE_EVENT, 0x804, METHOD_BUFFERED, FILE_ANY_ACCESS)

typedef struct        
{
    BOOL SHOWTHREAD;
    BOOL ONLYSHOWREMOTETHREAD;
    BOOL SHOWTERMINATEPROCESS;
    BOOL SHOWTERMINATETHREAD;
}CHECKLIST, *PCHECKLIST;

可以参考0day安全

Z000000Y
关注
专栏目录
[转载]内核级利用通用Hook函数方法检测进程
05-14 709
内核级利用通用Hook函数方法检测进程作者：    LionD8QQ：    10415468Email： LionD8@126.comBlog：    http://blog.csdn.net/LionD8     or http://liond8.126.com介绍通用Hook的一点思想：    在系统内核级中，MS的很多信息都没公开，包括函数的参数数目，每个参数的类型等。在系统内核中，访问了
linux 监控进程重启,linux进程监控与自动重启的简单实现方法
weixin_33362939的博客
04-28 2430
linux进程监控与自动重启的简单实现方法目的：linux 下服务器程序会因为各种原因dump掉，就会影响用户使用，这里提供一个简单的进程监控和重启功能。实现原理：由定时任务crontab调用脚本，脚本用ps检查进程是否存在，如果不存在则重启并写入日志。crontab修改# crontab -e*/5 * * * * /mnt/bindmonitor.sh/mnt/bindmonitor.sh 的...
(转载)安全稳定的实现进线程监控
Kendiv's Box
03-26 5248
安全稳定的实现进线程监控创建时间：2005-03-24文章属性：原创文章提交：suei8423 (suei8423_at_163.com)安全稳定的实现进线程监控作者:ZwelL    用PsSetCreateProcessNotifyRoutine,PsSetCreateThreadNotifyRoutine来进行进程线程监控我想大家已经都非常熟练了.sinister在>一文中已经实现得很好了.
高级IO操作—ioctl设备操作
Half-up的博客
05-12 2263
为了处理设备非数据的操作(这些可以通过read、write接口来实现),内核将对设备的控制操作委派给了ioctl接口，ioctl 也是一个系统调用，其函数原型如下。 int ioctl(int d,int request,...); d是要操作文件的文件描述符，request 是代表不同操作的数字值，比如驱动可以规定0x12345678表示点灯，而0x12345679表示灭灯等。但是这个操作码，更确切地说是命令，应该具有一定的编码规则，这个我们在后面会介绍。...表示C语言中实参个数可变的.但在这里表示的
linux 进程监控
Ericohe的博客
12-01 904
linux 进程监控 https://developer.aliyun.com/article/50081
Supervisor - 用户进程监控利器
u013433591的博客
11-26 1600
应用进程监控重启、运维监控工具、系统自动重启
开源轻量级进程监控工具monit的使用以及monit进程监控工具常用的监控配置案例示例大全
本博客记录了从2014年以来在工作学习中遇到的技术问题、解决方法以及部分个人人生经历、经验等内容。
08-29 1855
今天在服务器杀进程时，发现有一个进程一直在重启，寻找服务器各种定时任务未发现有定时程序，也没有发现supervisord的进程管理服务，后来才发现服务器上启用了monit这个工具，monit是一个开源的轻量级监控工具，功能挺强大，基本可以满足大多数的需求，它能从多个层面进行监控，比如可以通过PID文件，可以通过端口号等来监控进程，也可以对服务器的负载内存等各数据进行监制，以自动维护进程，发送报警等。进程监控：monit可以监控守护进程，当被监控进程异常退出时，可以自动被拉起。【alert】 触发报警邮件。
linux c进程监控
kchuang2008的博客
07-18 1127
【转载，原文地址：https://blog.csdn.net/MINGTING1323/article/details/81906216】 我们经常需要实现进程监控，如果某一进程异常退出或是跑飞则立即重启。通常使用的有2种方法： 一.supervisor来管理进程。 二.自己写程序来监管。 对于1而言，有些文件系统中不支持，需要移植安装。 对于2而言，不少都是单独写个监管程序，通过写入文件PID定...
linux 进程监控 工具,你值得拥有：25个Linux性能监控工具
weixin_34826752的博客
04-28 2633
一段时间以来，我们在网上向读者介绍了如何为Linux以及类Linux操作系统配置多种不同的性能监控工具。在这篇文章中我们将罗列一系列使用最频繁的性能监控工具，并对介绍到的每一个工具提供了相应的简介链接，大致将其划分为两类，基于命令行的和提供图形化接口的。一、基于命令行的性能监控工具1.dstat - 多类型资源统计工具该命令整合了vmstat，iostat和ifstat三种命令。同时增加了新的特性...
prometheus进程监控与告警
qq_33816243的博客
09-15 4793
如果想要对主机的进程进行监控，例如chronyd，sshd等服务进程以及自定义脚本程序运行状态监控。我们使用node exporter就不能实现需求了，此时就需要使用process exporter来做进程状态的监控。
c# winform实现进程监控
08-18
在C# WinForm环境中开发进程监控程序是一项常见的任务，它涉及到对系统进程的实时跟踪、控制和管理。本文将深入探讨如何使用C#语言和Windows Forms（WinForm）框架来实现这一功能，以及如何设计一个能够按设定顺序...
shell脚本实现服务器进程监控的方法
09-15
### Shell 脚本实现服务器进程监控方法详解 在IT运维和开发环境中，服务器进程的稳定运行至关重要。本文将深入探讨如何使用Shell脚本实现服务器进程监控，这不仅有助于及时发现异常情况，还能提高系统的可用性和...
linux进程监控与自动重启的简单实现方法
01-10
linux 下服务器程序会因为各种原因dump掉，就会影响用户使用，这里提供一个简单的进程监控和重启功能。 实现原理： 由定时任务crontab调用脚本，脚本用ps检查进程是否存在，如果不存在则重启并写入日志。 crontab...
易语言-进程监控例子开源
06-25
"易语言-进程监控例子开源"这个标题表明，这是一个关于使用易语言实现进程监控功能的开源示例项目。这样的项目通常包含了源代码、相关文档以及可能的编译或运行脚本，为学习者提供了实际操作的机会。 进程监控是...
易语言进程监控
08-21
易语言进程监控源码系统结构:KillProcess,循环查杀进程,保存数据,读取数据,保存配置,读取配置,开机自启动,开启自我保护,CloseHandle,CreateToolhelp32Snapshot,Process32First,Process32Next,OpenProcess,Term
5.C-Demo-排序
09-20
5.C-Demo-排序_快速排序
java-ssm942基于ssm的保险公司营销管理系统+jsp程序源码数据库含论文.rar
09-20
本系统基于SSM(Spring+SpringMVC+MyBatis)框架,适用于毕业设计， 基于B/S模式, mysql数据库,感兴趣的朋友们可以下载研究一下。 后端采用java语言，ssm框架，mybatis操作数据源，使用软件：idea,eclipse、MySQL。完成了用户登录管理等模块的设计与实现。完成了系统数据库的设计，并基于MySQL数据库管理系统 jdk版本:jdk1.8+ 前端：jsp 开发工具：IDEA 或者eclipse都支持 编程语言: java 框架支持：ssm 数据库: mysql 版本不限 数据库工具：Navicat/SQLyog都可以 详细技术：java+ssm+jsp+MYSQL+MAVEN
基于uni-app、uView UI开发的用于表白的微信小程序项目.zip(毕设&课设&实训&大作业&竞赛&项目)
最新发布
09-20
项目工程资源经过严格测试可直接运行成功且功能正常的情况才上传，可轻松复刻，拿到资料包后可轻松复现出一样的项目，本人系统开发经验充足（全领域），有任何使用问题欢迎随时与我联系，我会及时为您解惑，提供帮助。 【资源内容】：包含完整源码+工程文件+说明（如有）等。答辩评审平均分达到96分，放心下载使用！可轻松复现，设计报告也可借鉴此项目，该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 【提供帮助】：有任何使用问题欢迎随时与我联系，我会及时解答解惑，提供帮助 【附带帮助】：若还需要相关开发工具、学习资料等，我会提供帮助，提供资料，鼓励学习进步 【项目价值】：可用在相关项目设计中，皆可应用在项目、毕业设计、课程设计、期末/期中/大作业、工程实训、大创等学科竞赛比赛、初期项目立项、学习/练手等方面，可借鉴此优质项目实现复刻，设计报告也可借鉴此项目，也可基于此项目来扩展开发出更多功能 下载后请首先打开README文件（如有），项目工程可直接复现复刻，如果基础还行，也可在此程序基础上进行修改，以实现其它功能。供开源学习/技术交流/学习参考，勿用于商业用途。质量优质，放心下载使用。
基于java的高考志愿选择辅助系统设计与实现.docx
09-20
基于java的高考志愿选择辅助系统设计与实现.docx
C#编程：深入理解进程监控
“C#进程监控文档，介绍如何使用C#进行进程操作，深入理解C#进程管理。” 在C#编程中，对进程的监控是一项重要的任务，它可以帮助开发者了解应用程序的运行状态，优化性能，或者在出现问题时进行调试。本文档主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值