(一)記憶體掃描器(面向過程版)

来源:https://www.cnblogs.com/hanpto/archive/2023/03/21/17241832.html
-Advertisement-
Play Games

以下是一個基於C語言和Win32API的記憶體掃描器的實現代碼 首先定義一個結構體MEMBLOCK，用來存儲記憶體塊的信息 點擊查看代碼 typedef struct _MEMBLOCK { HANDLE hProcess; //進程句柄 PVOID addr; //記憶體塊地址 int size; // ...


以下是一個基於C語言和Win32API的記憶體掃描器的實現代碼

首先定義一個結構體MEMBLOCK，用來存儲記憶體塊的信息

點擊查看代碼 
typedef struct _MEMBLOCK
{
	HANDLE hProcess; //進程句柄
	PVOID addr;	 //記憶體塊地址
	int size;	 //記憶體塊大小
	char* buffer;	 //記憶體數據

	char* searchmask;//搜索標識符，標識每一位元組的數據是否在搜索列表中
	int matches;	 //匹配的數據個數
	int data_size;   //數據大小(單位位元組)
	struct _MEMBLOCK* next;
}MEMBLOCK;
再定義一個關於搜索方式的枚舉SEARCH_CONDITION
點擊查看代碼 
typedef enum
{
	COND_UNCONDITIONAL, //每個位元組
	COND_EQUALS,		//數值為特定值的位元組
	COND_INCREASE,		//數值增大的位元組
	COND_DECREASE,		//數值減小的位元組
}SEARCH_CONDITION;
之後我們實現對記憶體塊的創建，釋放及更新操作。記憶體塊的創建及釋放只涉及記憶體申請及釋放，更新操作則是利用ReadProcessMemory API函數更新我們的記憶體塊內容
點擊查看代碼 
MEMBLOCK* create_memblock(HANDLE hProcess, MEMORY_BASIC_INFORMATION* meminfo, int data_size)
{
	MEMBLOCK* mb = (MEMBLOCK*)malloc(sizeof(MEMBLOCK));
	if (mb)
	{
		mb->hProcess = hProcess;
		mb->addr = meminfo->BaseAddress;
		mb->size = meminfo->RegionSize;
		mb->buffer = (char*)malloc(meminfo->RegionSize);

		//初始化搜索掩碼為0xff，表示每一個位元組都在搜索列表中
		mb->searchmask = (char*)malloc(meminfo->RegionSize / 8);
		memset(mb->searchmask, 0xff, meminfo->RegionSize / 8);

		mb->matches = meminfo->RegionSize;
		mb->data_size = data_size;
		mb->next = NULL;
	}

	return mb;
}

void free_memblock(MEMBLOCK* mb)
{
	if (mb)
	{
		if (mb->buffer)
		{
			free(mb->buffer);
		}
		if (mb->searchmask)
		{
			free(mb->searchmask);
		}
		free(mb);
	}
}

void update_memblock(MEMBLOCK* mb, SEARCH_CONDITION condition, int val)
{
	static unsigned char tempbuf[128 * 1024];//0x20000
	unsigned int bytes_left;//當前未處理的位元組數
	unsigned int total_read;//已經處理的位元組數
	unsigned int bytes_to_read;
	SIZE_T bytes_read;

	if (mb->matches > 0)
	{
		bytes_left = mb->size;
		total_read = 0;

		mb->matches = 0;

		while (bytes_left)
		{
			bytes_to_read = (bytes_left > sizeof(tempbuf)) ? sizeof(tempbuf) : bytes_left;
			ReadProcessMemory(mb->hProcess, (LPCVOID)((SIZE_T)mb->addr + total_read), tempbuf, bytes_to_read, &bytes_read);
			//如果讀失敗了，則結束
			if (bytes_to_read != bytes_read) break;

			//條件搜索處
			if (condition == COND_UNCONDITIONAL)//無條件，則所有數據都匹配
			{
				memset(mb->searchmask + total_read / 8, 0xff, bytes_read / 8);
				mb->matches += bytes_read;
			}
			else//遍歷臨時buffer
			{
				for (int offset = 0; offset < bytes_read; offset += mb->data_size)
				{
					if (IS_IN_SEARCH(mb, (total_read + offset)))
					{
						BOOL is_match = FALSE;
						int temp_val;
						int prev_val;
						switch (mb->data_size)//獲取臨時數值的大小
						{
						case 1:
							temp_val = tempbuf[offset];
							prev_val = *((char*)&mb->buffer[total_read + offset]);
							break;
						case 2:
							temp_val = *((short*)&tempbuf[offset]);
							prev_val = *((short*)&mb->buffer[total_read + offset]);
							break;
						case 4:
						default:
							temp_val = *((int*)&tempbuf[offset]);
							prev_val = *((short*)&mb->buffer[total_read + offset]);
							break;
						}

						switch (condition)//根據不同搜索條件處理
						{
						case COND_EQUALS:
							is_match = (temp_val == val);
							break;
						case COND_INCREASE:
							is_match = (temp_val > prev_val);
							break;
						case COND_DECREASE:
							is_match = (temp_val < prev_val);
							break;
						default:
							break;
						}

						if (is_match)
						{
							mb->matches++;
						}
						else
						{
							REMOVE_FROM_SEARCH(mb, (total_read + offset));
						}
					}
				}
			}


			memcpy(mb->buffer + total_read, tempbuf, bytes_read);

			bytes_left -= bytes_read;
			total_read += bytes_read;
		}
		mb->size = total_read;

	}
}
接下來我們實現掃描器

創建掃描器主要是利用VirutualQueryEx API函數,對目標進程的虛擬記憶體塊進行過濾。即只選擇記憶體保護屬性帶有可寫(write)屬性的且已經被分配了物理記憶體的記憶體，為其申請記憶體。可寫屬性包括以下：PAGE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY

釋放掃描器和更新掃描器則只是調用我們的記憶體塊的相關函數。

點擊查看代碼 
MEMBLOCK* create_scan(int pid, int data_size)
{
	MEMBLOCK* mb_list = NULL;
	MEMORY_BASIC_INFORMATION meminfo;
	PVOID addr = 0;

	HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
	if (hProcess)
	{
		while (1)
		{
			//查詢失敗，返回
			if (!VirtualQueryEx(hProcess, addr, &meminfo, sizeof(meminfo)))
			{
				break;
			}
#define WRITABLE (PAGE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY)

			if ((meminfo.State & MEM_COMMIT) && (meminfo.Protect & WRITABLE))
			{
				MEMBLOCK* mb = create_memblock(hProcess, &meminfo, data_size);
				//頭插法將掃描的記憶體塊存入記憶體塊列表中
				if (mb)
				{
					mb->next = mb_list;
					mb_list = mb;
				}
			}

			addr = (LPVOID)((SIZE_T)meminfo.BaseAddress + meminfo.RegionSize);void free_scan(MEMBLOCK* mb_list)
{
	CloseHandle(mb_list->hProcess);
	while (mb_list)
	{
		MEMBLOCK* mb = mb_list;
		mb_list = mb_list->next;
		free_memblock(mb);
	}
}

void update_scan(MEMBLOCK* mb_list, SEARCH_CONDITION condition, int val)
{
	MEMBLOCK* mb = mb_list;
	while (mb)
	{
		update_memblock(mb, condition, val);
		mb = mb->next;
	}
}
		}
	}

	return mb_list;
}

void free_scan(MEMBLOCK* mb_list)
{
	CloseHandle(mb_list->hProcess);
	while (mb_list)
	{
		MEMBLOCK* mb = mb_list;
		mb_list = mb_list->next;
		free_memblock(mb);
	}
}

void update_scan(MEMBLOCK* mb_list, SEARCH_CONDITION condition, int val)
{
	MEMBLOCK* mb = mb_list;
	while (mb)
	{
		update_memblock(mb, condition, val);
		mb = mb->next;
	}
}

之後我們再封裝一下記憶體讀寫函數

點擊查看代碼 
void poke(HANDLE hProcess, int data_size, PVOID addr, int val)//寫記憶體
{
	if (!WriteProcessMemory(hProcess, addr, &val, data_size, NULL))
	{
		printf("poke failed\r\n");
	}
}
int peek(HANDLE hProcess, int data_size, PVOID addr)
{
	int val = 0;
	if (!ReadProcessMemory(hProcess, addr, &val, data_size, NULL))
	{
		printf("peek failed\r\n");
	}
	return val;
}

至此，我們的記憶體掃描器的核心功能已完全實現

最後附上運行示例及完整源碼：
image

完整源碼：

點擊查看代碼 
#pragma once
#include<Windows.h>
#include<iostream>

typedef struct _MEMBLOCK
{
	HANDLE hProcess;
	PVOID addr;		 //記憶體塊地址
	int size;		 //記憶體塊大小
	char* buffer;	 //記憶體數據

	char* searchmask;//搜索標識符，標識每一位元組的數據是否在搜索列表中
	int matches;	 //匹配的數據個數
	int data_size;   //數據大小(單位位元組)
	struct _MEMBLOCK* next;
}MEMBLOCK;

typedef enum
{
	COND_UNCONDITIONAL, //每個位元組
	COND_EQUALS,		//數值為特定值的位元組
	COND_INCREASE,		//數值增大的位元組
	COND_DECREASE,		//數值減小的位元組
}SEARCH_CONDITION;


MEMBLOCK* create_memblock(HANDLE hProcess, MEMORY_BASIC_INFORMATION* meminfo, int data_size);
void update_memblock(MEMBLOCK* mb, SEARCH_CONDITION condition, int val);
void free_memblock(MEMBLOCK* mb);


MEMBLOCK* create_scan(int pid, int data_size);
void update_scan(MEMBLOCK* mb_list, SEARCH_CONDITION condition, int val);
void free_scan(MEMBLOCK* mb_list);
void dump_scan_info(MEMBLOCK* mb_list);

void poke(HANDLE hProcess, int data_size, PVOID addr, int val);
int peek(HANDLE hProcess, int data_size, PVOID addr);

void print_matches(MEMBLOCK* mb_list);
int get_match_count(MEMBLOCK* mb_list);


int str2int(char* s);


//ui
MEMBLOCK* ui_new_scan(void);
void ui_poke(HANDLE hProcess, int data_size);
void ui_run_scan();

#include"memoryScanner.h"
using namespace std;

#define IS_IN_SEARCH(mb,offset) (mb->searchmask[(offset)/8] & (1<<((offset)%8)))
#define REMOVE_FROM_SEARCH(mb,offset) mb->searchmask[(offset)/8]&=~(1<<((offset)%8));


int main()
{
	
	ui_run_scan();

	return 0;
}


MEMBLOCK* create_memblock(HANDLE hProcess, MEMORY_BASIC_INFORMATION* meminfo, int data_size)
{
	MEMBLOCK* mb = (MEMBLOCK*)malloc(sizeof(MEMBLOCK));
	if (mb)
	{
		mb->hProcess = hProcess;
		mb->addr = meminfo->BaseAddress;
		mb->size = meminfo->RegionSize;
		mb->buffer = (char*)malloc(meminfo->RegionSize);

		//初始化搜索掩碼為0xff，表示每一個位元組都在搜索列表中
		mb->searchmask = (char*)malloc(meminfo->RegionSize / 8);
		memset(mb->searchmask, 0xff, meminfo->RegionSize / 8);

		mb->matches = meminfo->RegionSize;
		mb->data_size = data_size;
		mb->next = NULL;
	}

	return mb;
}
void update_memblock(MEMBLOCK* mb, SEARCH_CONDITION condition, int val)
{
	static unsigned char tempbuf[128 * 1024];//0x20000
	unsigned int bytes_left;//當前未處理的位元組數
	unsigned int total_read;//已經處理的位元組數
	unsigned int bytes_to_read;
	SIZE_T bytes_read;

	if (mb->matches > 0)
	{
		bytes_left = mb->size;
		total_read = 0;

		mb->matches = 0;

		while (bytes_left)
		{
			bytes_to_read = (bytes_left > sizeof(tempbuf)) ? sizeof(tempbuf) : bytes_left;
			ReadProcessMemory(mb->hProcess, (LPCVOID)((SIZE_T)mb->addr + total_read), tempbuf, bytes_to_read, &bytes_read);
			//如果讀失敗了，則結束
			if (bytes_to_read != bytes_read) break;

			//條件搜索處
			if (condition == COND_UNCONDITIONAL)//無條件，則所有數據都匹配
			{
				memset(mb->searchmask + total_read / 8, 0xff, bytes_read / 8);
				mb->matches += bytes_read;
			}
			else//遍歷臨時buffer
			{
				for (int offset = 0; offset < bytes_read; offset += mb->data_size)
				{
					if (IS_IN_SEARCH(mb, (total_read + offset)))
					{
						BOOL is_match = FALSE;
						int temp_val;
						int prev_val;
						switch (mb->data_size)//獲取臨時數值的大小
						{
						case 1:
							temp_val = tempbuf[offset];
							prev_val = *((char*)&mb->buffer[total_read + offset]);
							break;
						case 2:
							temp_val = *((short*)&tempbuf[offset]);
							prev_val = *((short*)&mb->buffer[total_read + offset]);
							break;
						case 4:
						default:
							temp_val = *((int*)&tempbuf[offset]);
							prev_val = *((short*)&mb->buffer[total_read + offset]);
							break;
						}

						switch (condition)//根據不同搜索條件處理
						{
						case COND_EQUALS:
							is_match = (temp_val == val);
							break;
						case COND_INCREASE:
							is_match = (temp_val > prev_val);
							break;
						case COND_DECREASE:
							is_match = (temp_val < prev_val);
							break;
						default:
							break;
						}

						if (is_match)
						{
							mb->matches++;
						}
						else
						{
							REMOVE_FROM_SEARCH(mb, (total_read + offset));
						}
					}
				}
			}


			memcpy(mb->buffer + total_read, tempbuf, bytes_read);

			bytes_left -= bytes_read;
			total_read += bytes_read;
		}
		mb->size = total_read;

	}
}
void free_memblock(MEMBLOCK* mb)
{
	if (mb)
	{
		if (mb->buffer)
		{
			free(mb->buffer);
		}
		if (mb->searchmask)
		{
			free(mb->searchmask);
		}
		free(mb);
	}
}


MEMBLOCK* create_scan(int pid, int data_size)
{
	MEMBLOCK* mb_list = NULL;
	MEMORY_BASIC_INFORMATION meminfo;
	PVOID addr = 0;

	HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
	if (hProcess)
	{
		while (1)
		{
			//查詢失敗，返回
			if (!VirtualQueryEx(hProcess, addr, &meminfo, sizeof(meminfo)))
			{
				break;
			}
#define WRITABLE (PAGE_READWRITE|PAGE_WRITECOPY|PAGE_EXECUTE_READWRITE|PAGE_EXECUTE_WRITECOPY)

			if ((meminfo.State & MEM_COMMIT) && (meminfo.Protect & WRITABLE))
			{
				MEMBLOCK* mb = create_memblock(hProcess, &meminfo, data_size);
				//頭插法將掃描的記憶體塊存入記憶體塊列表中
				if (mb)
				{
					mb->next = mb_list;
					mb_list = mb;
				}
			}

			addr = (LPVOID)((SIZE_T)meminfo.BaseAddress + meminfo.RegionSize);
		}
	}

	return mb_list;
}
void update_scan(MEMBLOCK* mb_list, SEARCH_CONDITION condition, int val)
{
	MEMBLOCK* mb = mb_list;
	while (mb)
	{
		update_memblock(mb, condition, val);
		mb = mb->next;
	}
}
void free_scan(MEMBLOCK* mb_list)
{
	CloseHandle(mb_list->hProcess);
	while (mb_list)
	{
		MEMBLOCK* mb = mb_list;
		mb_list = mb_list->next;
		free_memblock(mb);
	}
}
void dump_scan_info(MEMBLOCK* mb_list)
{
	MEMBLOCK* mb = mb_list;
	while (mb)
	{
		//列印記憶體塊
		printf("0x%08x 0x%08x\r\n", mb->addr, mb->size);

		mb = mb->next;

		//列印記憶體塊中數據
		for (int i = 0; i < mb->size; i++)
		{
			printf("0x%02x ", mb->buffer[i]);
			if (i % 16 == 0) printf("\r\n");
		}
		printf("\r\n");
	}
}


void poke(HANDLE hProcess, int data_size, PVOID addr, int val)//寫記憶體
{
	if (!WriteProcessMemory(hProcess, addr, &val, data_size, NULL))
	{
		printf("poke failed\r\n");
	}
}
int peek(HANDLE hProcess, int data_size, PVOID addr)
{
	int val = 0;
	if (!ReadProcessMemory(hProcess, addr, &val, data_size, NULL))
	{
		printf("peek failed\r\n");
	}
	return val;
}


void print_matches(MEMBLOCK* mb_list)
{
	MEMBLOCK* mb = mb_list;
	while (mb)
	{
		for (int offset = 0; offset < mb->size; offset += mb->data_size)
		{
			if (IS_IN_SEARCH(mb, offset))
			{
				int val = peek(mb->hProcess, mb->data_size, (PVOID)((SIZE_T)mb->addr + offset));
				printf("0x%08x : %d\r\n", (SIZE_T)mb->addr + offset, val);
			}
		}
		mb = mb->next;
	}
}
int get_match_count(MEMBLOCK* mb_list)
{
	MEMBLOCK* mb = mb_list;
	int count = 0;
	while (mb)
	{
		count += mb->matches;
		mb = mb->next;
	}
	return count;
}


int str2int(char* s)
{
	int base = 10;
	if (s[0] == '0' && s[1] == 'x')
	{
		base = 16;
		s += 2;
	}
	return strtol(s, NULL, base);
}


MEMBLOCK* ui_new_scan(void)
{
	MEMBLOCK* scan = NULL;
	DWORD pid;
	int data_size;
	int start_val;
	SEARCH_CONDITION start_cond;
	char s[20];

	while (1)
	{
		printf("\r\nEnter the pid:");
		fgets(s, sizeof(s), stdin);
		pid = str2int(s);
		printf("\r\nEnter the data size:");
		fgets(s, sizeof(s), stdin);
		data_size = str2int(s);
		printf("\r\nEnter the start value or 'u' for unknown:");
		fgets(s, sizeof(s), stdin);
		if (s[0] == 'u')
		{
			start_cond = COND_UNCONDITIONAL;
			start_val = 0;
		}
		else
		{
			start_cond = COND_EQUALS;
			start_val = str2int(s);
		}

		scan = create_scan(pid, data_size);
		if (scan) break;//如果創建成功，則退出
		printf("\r\n invalid scan");
	}
	update_scan(scan, start_cond, start_val);
	printf("\r\n %d matches found\r\n", get_match_count(scan));

	return scan;
}
void ui_poke(HANDLE hProcess, int data_size)
{
	int addr;
	int val;
	char s[20];

	printf("Enter the address:");
	fgets(s, sizeof(s), stdin);
	addr = str2int(s);

	printf("Enter the value:");
	fgets(s, sizeof(s), stdin);
	val = str2int(s);

	poke(hProcess, data_size, (PVOID)addr, val);
}
void ui_run_scan()
{
	int val;
	char s[20];
	MEMBLOCK* scan;

	scan = ui_new_scan();

	while (1)
	{
		printf("\r\n Enter the next value or");
		printf("\r\n[i] increased");
		printf("\r\n[d] decreased");
		printf("\r\n[m] print matches");
		printf("\r\n[p] poke address");
		printf("\r\n[n] new scan");
		printf("\r\n[q] quit\r\n");

		fgets(s, sizeof(s), stdin);
		printf("\r\n");

		switch (s[0])
		{
		case 'i':
			update_memblock(scan, COND_INCREASE, 0);
			printf("%d matches found\r\n", get_match_count(scan));
			break;
		case 'd':
			update_memblock(scan, COND_DECREASE, 0);
			printf("%d matches found\r\n", get_match_count(scan));
			break;
		case 'm':
			print_matches(scan);
			break;
		case 'p':
			ui_poke(scan->hProcess, scan->data_size);
			break;
		case 'n':
			free(scan);
			scan = ui_new_scan();
			break;
		case 'q':
			free(scan);
			return;
		default:
			val = str2int(s);
			update_scan(scan, COND_EQUALS, val);
			printf("%d matches found\r\n", get_match_count(scan));
			break;

		}
	}
}

您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • CSS 高階小技巧 - 角向漸變的妙用！
    本文將介紹一個角向漸變的一個非常有意思的小技巧！ 我們嘗試使用 CSS 繪製如下圖形： 在之前，類似的圖案，其實我們有嘗試過，在 單標簽實現複雜的棋盤佈局 一文中，我們用單標簽實現了這樣一個棋盤佈局： 那麼，本文有什麼特殊之處呢？讓我們一探究竟。 快速實現網格佈局 首先，上述的佈局還是希望使用一個標 ...
  • 前端設計模式——橋接模式
    橋接模式（Bridge Pattern）是一種結構型設計模式，用於將一個大類或一系列緊密相關的類拆分為抽象和實現兩個獨立的層次結構，從而能夠更好地組合和擴展這些類。 在前端開發中，橋接模式通常用於處理 UI 組件的複雜性，將組件的抽象與實現分離，使得它們能夠獨立地變化。通過橋接模式，我們可以讓組件的 ...
  • KCP協議淺析
    概述 KCP協議結合了TCP和UDP協議的特點，是一個快速可靠的協議。 引述官方介紹： KCP是一個快速可靠協議，能以比 TCP浪費10%-20%的帶寬的代價，換取平均延遲降低 30%-40%，且最大延遲降低三倍的傳輸效果。純演算法實現，並不負責底層協議（如UDP）的收發，需要使用者自己定義下層數據的 ...
  • TCP和UDP協議的區別
    TCP/IP協議中有兩個具有代表性的傳輸層協議，分別是TCP協議和UDP協議。TCP協議全稱傳輸控制協議，是一種面向連接的、可靠的、基於位元組流的傳輸層通信協議。UDP協議全稱用戶數據報協議，是 TCP/IP協議模型傳輸層的無連接協議，它既不建立連接，也不檢查目標電腦是否已準備好接收，該協議只是將數... ...
  • Servlet的基本使用
    複習 Vue 1.vue的使用步驟: （1）導入vue.js （2）創建除body以外最大的div標簽，給定id值 （3）創建vue對象 new Vue({ "el":"#app", "data":{}, //定義變數 "methods":{}, //定義方法 "beforeCreate":func ...
  • JavaWeb使用Kaptcha生成驗證碼(jar版)
    Mybatis 環境： JDK1.8 Mysql maven IDEA 回顧： JDBC Mysql Java基礎 Maven Junit SSM框架：配置文件的。最好的方式：看官網文檔； 1、簡介 1.1、什麼是Mybatis MyBatis 是一款優秀的持久層框架 它支持自定義 SQL、存儲過程 ...
  • day09-攔截器&文件上傳
    攔截器&文件上傳 1.攔截器-Interceptor 1.1攔截器概念 攔截器 攔截器（Interceptor）：是一種動態攔截方法調用的機制，在SpringMVC中動態攔截控制器方法的執行。在SpringBoot中，攔截器是開發的常用手段，要用來登錄驗證、性能檢查、日誌記錄等 （1）SpringB ...
  • C++入門
    1 C++初識 1.1 變數 作用：給一段指定的記憶體空間起名，方便操作這段記憶體 **註意：**C++在創建變數時，必須給變數一個初始值，否則會報錯 1.2 常量 作用：用於記錄程式中不可更改的數據 C++定義常量兩種方式 #define 巨集常量： #define 常量名 常量值 通常在文件上方定義， ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類