返回提交历史
Modified
XFEExtension.NetCore.MemoryEditor.sln
+7
-2
Modified
XFEExtension.NetCore.MemoryEditor/DynamicMemoryListener.cs
+5
-5
Modified
XFEExtension.NetCore.MemoryEditor/Manager/DynamicMemoryItem.cs
+45
-7
Modified
XFEExtension.NetCore.MemoryEditor/Manager/DynamicMemoryManager.cs
+23
-20
Added
XFEExtension.NetCore.MemoryEditor/Manager/IMemoryManager.cs
+28
-0
Modified
XFEExtension.NetCore.MemoryEditor/Manager/MemoryItem.cs
+60
-12
Added
XFEExtension.NetCore.MemoryEditor/Manager/MemoryItemBuilder.cs
+106
-0
Modified
XFEExtension.NetCore.MemoryEditor/Manager/MemoryListenerManager.cs
+71
-48
Added
XFEExtension.NetCore.MemoryEditor/Manager/MemoryListenerManagerBase.cs
+91
-0
Modified
XFEExtension.NetCore.MemoryEditor/Manager/MemoryManager.cs
+18
-24
Modified
XFEExtension.NetCore.MemoryEditor/Manager/StaticMemoryItem.cs
+41
-12
Modified
XFEExtension.NetCore.MemoryEditor/Manager/StaticMemoryManager.cs
+17
-43
Added
XFEExtension.NetCore.MemoryEditor/Manager/UpdatableMemoryItem.cs
+63
-0
Added
XFEExtension.NetCore.MemoryEditor/Manager/UpdatableMemoryManager.cs
+44
-0
Modified
XFEExtension.NetCore.MemoryEditor/MemoryEditor.cs
+81
-75
Modified
XFEExtension.NetCore.MemoryEditor/MemoryListener.cs
+2
-2
Modified
XFEExtension.NetCore.MemoryEditor/StaticMemoryListener.cs
+4
-4
Modified
XFEExtension.NetCore.MemoryEditor/UpdatableMemoryListener.cs
+13
-5
XFEstudio/XFEExtension.NetCore.MemoryEditor
添加构建器，完善构建器，完善所有类型内存管理器
ececf1c
代码差异
18 个文件
+719
-259
@@ -1,9 +1,10 @@
1
2
1
Microsoft Visual Studio Solution File, Format Version 12.00
3
2
# Visual Studio Version 17
4
3
VisualStudioVersion = 17.9.34728.123
5
4
MinimumVisualStudioVersion = 10.0.40219.1
6
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "XFEExtension.NetCore.MemoryEditor", "XFEExtension.NetCore.MemoryEditor\XFEExtension.NetCore.MemoryEditor.csproj", "{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}"
5
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "XFEExtension.NetCore.MemoryEditor", "..\..\..\..\..\..\Desktop\work\C#\GitHub\XFEstudio\XFEExtension.NetCore.MemoryEditor\XFEExtension.NetCore.MemoryEditor\XFEExtension.NetCore.MemoryEditor.csproj", "{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}"
6
EndProject
7
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SeaOfRadiationEditor", "..\..\..\..\..\..\Desktop\work\C#\GitHub\XFEstudio\SeaOfRadiationEditor\SeaOfRadiationEditor\SeaOfRadiationEditor.csproj", "{7D09E8EC-562E-496F-8362-5BEBD541238D}"
7
8
EndProject
8
9
Global
9
10
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -11,6 +12,10 @@ Global
11
12
Release|Any CPU = Release|Any CPU
12
13
EndGlobalSection
13
14
GlobalSection(ProjectConfigurationPlatforms) = postSolution
15
{7D09E8EC-562E-496F-8362-5BEBD541238D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
16
{7D09E8EC-562E-496F-8362-5BEBD541238D}.Debug|Any CPU.Build.0 = Debug|Any CPU
17
{7D09E8EC-562E-496F-8362-5BEBD541238D}.Release|Any CPU.ActiveCfg = Release|Any CPU
18
{7D09E8EC-562E-496F-8362-5BEBD541238D}.Release|Any CPU.Build.0 = Release|Any CPU
14
19
{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15
20
{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}.Debug|Any CPU.Build.0 = Debug|Any CPU
16
21
{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -22,7 +22,7 @@ public abstract class DynamicMemoryListener(string customName, Func<nint?> getAd
22
22
/// <param name="processHandler">监听的进程句柄</param>
23
23
/// <param name="frequency">监听检测频率</param>
24
24
/// <returns></returns>
25
public override async Task StartListen(nint processHandler, TimeSpan frequency)
25
public override async Task StartListen(nint processHandler, TimeSpan? frequency)
26
26
{
27
27
await base.StartListen(processHandler, frequency);
28
28
CurrentListeningTask = Task.Run(async () =>
@@ -30,7 +30,7 @@ public abstract class DynamicMemoryListener(string customName, Func<nint?> getAd
30
30
var memoryAddress = getAddressFunc.Invoke();
31
31
object? lastValue = null;
32
32
if (memoryAddress is not null)
33
try { lastValue = MemoryEditor.ReadMemory(processHandler, memoryAddress.Value, memoryAddressType); } catch { }
33
try { lastValue = MemoryEditor.ReadMemory(this.processHandler, memoryAddress.Value, memoryAddressType); } catch { }
34
34
while (isListening)
35
35
{
36
36
try
@@ -44,16 +44,16 @@ public abstract class DynamicMemoryListener(string customName, Func<nint?> getAd
44
44
while (memoryAddress == 0 && isListening)
45
45
{
46
46
memoryAddress = getAddressFunc.Invoke();
47
await Task.Delay(frequency);
47
await Task.Delay(this.frequency);
48
48
}
49
49
}
50
var currentValue = MemoryEditor.ReadMemory(processHandler, memoryAddress!.Value, memoryAddressType);
50
var currentValue = MemoryEditor.ReadMemory(this.processHandler, memoryAddress!.Value, memoryAddressType);
51
51
if (lastValue is null == currentValue is null || lastValue?.Equals(currentValue) == false)
52
52
{
53
53
valueChanged?.Invoke(this, new(lastValue is not null, currentValue is not null, lastValue, currentValue, name));
54
54
lastValue = currentValue;
55
55
}
56
await Task.Delay(frequency);
56
await Task.Delay(this.frequency);
57
57
}
58
58
catch { }
59
59
}
@@ -1,12 +1,50 @@
1
using System;
2
using System.Collections.Generic;
3
using System.Linq;
4
using System.Text;
5
using System.Threading.Tasks;
1
using XFEExtension.NetCore.ImplExtension;
6
2
7
namespace XFEExtension.NetCore.MemoryEditor.Manager
3
namespace XFEExtension.NetCore.MemoryEditor.Manager;
4
5
/// <summary>
6
/// 动态内存
7
/// </summary>
8
/// <param name="name">自定义标识名</param>
9
/// <param name="memoryAddressGetFunc">内存地址动态获取方法</param>
10
/// <param name="memoryItemType">内存地址数据类型</param>
11
/// <param name="memoryEditor">内存修改器</param>
12
[CreateImpl]
13
public abstract class DynamicMemoryItem(string name, Func<nint?> memoryAddressGetFunc, Type memoryItemType, MemoryEditor memoryEditor) : MemoryItem(name, memoryItemType, memoryEditor)
8
14
{
9
internal class DynamicMemoryItem
15
/// <summary>
16
/// 内存地址动态获取方法
17
/// </summary>
18
public Func<nint?> MemoryAddressGetFunc { get; init; } = memoryAddressGetFunc;
19
/// <summary>
20
/// 监听器
21
/// </summary>
22
public DynamicMemoryListener? Listener { get; protected set; }
23
/// <inheritdoc/>
24
public override bool HasListener { get => Listener is not null; }
25
/// <inheritdoc/>
26
public override void AddListener(TimeSpan? frequency = null, bool startListen = false) => Listener = memoryEditor.AddDynamicListener(Name, MemoryAddressGetFunc, frequency, MemoryItemType, startListen);
27
/// <inheritdoc/>
28
public override bool Read<T>(out T result) => memoryEditor.ReadMemory(MemoryAddressGetFunc.Invoke()!.Value, out result);
29
/// <inheritdoc/>
30
public override void RemoveListener()
31
{
32
memoryEditor.RemoveListener(Name);
33
Listener = null;
34
}
35
/// <inheritdoc/>
36
public override async Task StopListen()
37
{
38
if (Listener is null)
39
throw new InvalidOperationException($"{nameof(Listener)} 监听器为空");
40
await Listener.StopListen();
41
}
42
/// <inheritdoc/>
43
public override bool Write<T>(T value) => memoryEditor.WriteMemory(MemoryAddressGetFunc.Invoke()!.Value, value);
44
internal override async Task StartListen(nint processHandler, TimeSpan? frequency = null)
10
45
{
46
if (Listener is null)
47
throw new InvalidOperationException($"{nameof(Listener)} 监听器为空");
48
await Listener.StartListen(processHandler, frequency);
11
49
}
12
50
}
@@ -7,35 +7,38 @@ namespace XFEExtension.NetCore.MemoryEditor.Manager;
7
7
/// </summary>
8
8
public abstract class DynamicMemoryManager : MemoryManager
9
9
{
10
internal DynamicMemoryManager(nint processHandler) : base(processHandler)
11
{
12
}
13
10
/// <summary>
14
/// 索引器
11
/// 地址值字典
15
12
/// </summary>
16
/// <param name="addressName">地址名称</param>
17
/// <returns></returns>
18
public override nint? this[string addressName] => memoryAddressGetFuncDictionary[addressName].Invoke();
13
public Dictionary<string, DynamicMemoryItem> ItemDictionary { get; set; } = [];
19
14
/// <summary>
20
/// 添加地址
21
/// </summary>
22
/// <param name="addressName">标识名称</param>
23
/// <param name="addressGetFunc">地址的获取方法</param>
24
public override void Add(string addressName, Func<nint?> addressGetFunc) => memoryAddressGetFuncDictionary.Add(addressName, addressGetFunc);
25
/// <summary>
26
/// 设置指定名称的地址的获取方法
15
/// 索引器
27
16
/// </summary>
28
/// <param name="addressName">地址标识名称</param>
29
/// <param name="newAddressGetFun">新的获取方法</param>
30
public override void Set(string addressName, Func<nint?> newAddressGetFun) => memoryAddressGetFuncDictionary[addressName] = newAddressGetFun;
17
/// <param name="addressName">地址标识名</param>
18
/// <returns></returns>
19
public DynamicMemoryItem this[string addressName] => ItemDictionary[addressName];
20
internal override void Add(MemoryItemBuilder builder)
21
{
22
if (builder.DynamicMemoryAddress is null)
23
throw new ArgumentNullException(nameof(builder), "对于动态地址管理器，构建器的动态地址不可为空");
24
var dynamicMemoryItem = new DynamicMemoryItemImpl(builder.Name, builder.DynamicMemoryAddress, builder.MemoryAddressType, Editor);
25
if (builder.HasListener)
26
dynamicMemoryItem.AddListener(builder.ListenerFrequency, builder.StartListen);
27
ItemDictionary.Add(builder.Name, dynamicMemoryItem);
28
}
31
29
/// <summary>
32
30
/// 获取枚举器
33
31
/// </summary>
34
32
/// <returns></returns>
35
public override IEnumerator GetEnumerator() => memoryAddressGetFuncDictionary.Values.GetEnumerator();
33
public override IEnumerator GetEnumerator() => ItemDictionary.GetEnumerator();
36
34
/// <summary>
37
/// 移除指定名称的地址
35
/// 释放资源
38
36
/// </summary>
39
37
/// <param name="addressName">地址标识名称</param>
40
public override void Remove(string addressName) => memoryAddressGetFuncDictionary.Remove(addressName);
38
public override void Remove(string addressName) => ItemDictionary.Remove(addressName);
39
/// <summary>
40
/// 动态内存管理器
41
/// </summary>
42
/// <param name="builders">内存构建器组</param>
43
protected DynamicMemoryManager(params MemoryItemBuilder[] builders) => Add(builders);
41
44
}
@@ -0,0 +1,28 @@
1
using System.Collections;
2
using System.Diagnostics;
3
4
namespace XFEExtension.NetCore.MemoryEditor.Manager;
5
6
/// <summary>
7
/// 内存管理器
8
/// </summary>
9
public interface IMemoryManager : IEnumerable, IDisposable
10
{
11
/// <summary>
12
/// 当前目标进程
13
/// </summary>
14
Process? CurrentProcess { get; set; }
15
/// <summary>
16
/// 内存编辑器
17
/// </summary>
18
MemoryEditor Editor { get; }
19
/// <summary>
20
/// 进程句柄
21
/// </summary>
22
nint ProcessHandler { get; set; }
23
/// <summary>
24
/// 移除指定标识名的地址
25
/// </summary>
26
/// <param name="addressName"></param>
27
void Remove(string addressName);
28
}
@@ -3,34 +3,82 @@
3
3
/// <summary>
4
4
/// 内存条目
5
5
/// </summary>
6
/// <typeparam name="T">地址类型</typeparam>
7
6
/// <param name="name">名称</param>
8
/// <param name="memoryListener">监听器</param>
9
public abstract class MemoryItem<T>(string name, MemoryListenerManager memoryListener)
7
/// <param name="memoryItemType">内存地址数据类型</param>
8
/// <param name="memoryEditor">修改器</param>
9
public abstract class MemoryItem(string name, Type memoryItemType, MemoryEditor memoryEditor)
10
10
{
11
private protected MemoryListenerManager memoryListener = memoryListener;
11
private protected MemoryEditor memoryEditor = memoryEditor;
12
/// <summary>
13
/// 内存地址数据类型
14
/// </summary>
15
public Type MemoryItemType { get; set; } = memoryItemType;
12
16
/// <summary>
13
17
/// 内存地址标识名
14
18
/// </summary>
15
19
public string Name { get; init; } = name;
16
20
/// <summary>
17
/// 内存地址
21
/// 该地址是否被监听
22
/// </summary>
23
public bool IsListening { get; protected set; }
24
/// <summary>
25
/// 是否有监听器
18
26
/// </summary>
19
public nint? MemoryAddress { get; internal set; }
27
public abstract bool HasListener { get; }
20
28
/// <summary>
21
/// 内存地址动态获取方法
29
/// 开始监听该地址
22
30
/// </summary>
23
public Func<nint?>? AddressGetFunc { get; internal set; }
31
/// <param name="frequency">监听频率，单位为毫秒</param>
32
public async Task StartListen(int frequency = 1) => await StartListen(TimeSpan.FromMilliseconds(frequency));
24
33
/// <summary>
25
/// 该地址是否存在监听器
34
/// 开始监听该地址
26
35
/// </summary>
27
public bool HasListener { get; protected set; }
36
/// <param name="frequency">监听频率</param>
37
/// <exception cref="InvalidOperationException"></exception>
38
public async Task StartListen(TimeSpan? frequency = null)
39
{
40
if (IsListening)
41
throw new InvalidOperationException("正在监听中，无法重复监听");
42
IsListening = true;
43
await StartListen(memoryEditor.ProcessHandle, frequency);
44
}
45
internal abstract Task StartListen(nint processHandler, TimeSpan? frequency);
28
46
/// <summary>
29
/// 添加监听器
47
/// 为该地址添加监听器
30
48
/// </summary>
31
public abstract void AddListener();
49
/// <param name="frequency">监听频率</param>
50
/// <param name="startListen">是否在添加后启用监听</param>
51
public abstract void AddListener(TimeSpan? frequency = null, bool startListen = false);
32
52
/// <summary>
33
53
/// 移除监听器
34
54
/// </summary>
35
55
public abstract void RemoveListener();
56
/// <summary>
57
/// 停止监听
58
/// </summary>
59
public abstract Task StopListen();
60
/// <summary>
61
/// 写入该内存
62
/// </summary>
63
/// <typeparam name="T">数据类型</typeparam>
64
/// <param name="value">写入值</param>
65
/// <returns>是否写入成功</returns>
66
public abstract bool Write<T>(T value) where T : struct;
67
/// <summary>
68
/// 读取该内存的值
69
/// </summary>
70
/// <typeparam name="T">数据类型</typeparam>
71
/// <returns>返回结果</returns>
72
public T Read<T>() where T : struct
73
{
74
Read<T>(out T result);
75
return result;
76
}
77
/// <summary>
78
/// 读取该内存的值
79
/// </summary>
80
/// <typeparam name="T">数据类型</typeparam>
81
/// <param name="result">读取的值</param>
82
/// <returns>是否读取成功</returns>
83
public abstract bool Read<T>(out T result) where T : struct;
36
84
}
@@ -0,0 +1,106 @@
1
using XFEExtension.NetCore.ImplExtension;
2
3
namespace XFEExtension.NetCore.MemoryEditor.Manager;
4
5
/// <summary>
6
/// 内存条目构建器
7
/// </summary>
8
[CreateImpl]
9
public abstract class MemoryItemBuilder
10
{
11
/// <summary>
12
/// 内存地址标识名
13
/// </summary>
14
public required string Name { get; set; }
15
/// <summary>
16
/// 是否添加监听器
17
/// </summary>
18
public bool HasListener { get; set; }
19
/// <summary>
20
/// 是否立即开始监听（监听器会自动创建但是默认不会立即开始监听）
21
/// </summary>
22
public bool StartListen { get; set; }
23
/// <summary>
24
/// 内存地址类型
25
/// </summary>
26
public required Type MemoryAddressType { get; set; }
27
/// <summary>
28
/// 监听器监听频率
29
/// </summary>
30
public TimeSpan ListenerFrequency { get; set; }
31
/// <summary>
32
/// 内存地址
33
/// </summary>
34
public nint? StaticMemoryAddress { get; set; }
35
/// <summary>
36
/// 内存地址动态获取方法
37
/// </summary>
38
public Func<nint?>? DynamicMemoryAddress { get; set; }
39
/// <summary>
40
/// 可更新内存地址更新方法
41
/// </summary>
42
public Func<nint?>? UpdatableMemoryAddress { get; set; }
43
/// <summary>
44
/// 为该地址添加监听器
45
/// </summary>
46
/// <param name="frequency">监听频率</param>
47
/// <param name="startListen">是否立即开始监听（监听器会自动创建但是默认不会立即开始监听）</param>
48
/// <returns></returns>
49
public MemoryItemBuilder WithListener(TimeSpan frequency, bool startListen = false)
50
{
51
HasListener = true;
52
ListenerFrequency = frequency;
53
StartListen = startListen;
54
return this;
55
}
56
/// <summary>
57
/// 为该地址添加监听器
58
/// </summary>
59
/// <param name="frequency">监听频率，单位为毫秒</param>
60
/// <param name="startListen">是否立即开始监听（监听器会自动创建但是默认不会立即开始监听）</param>
61
/// <returns></returns>
62
public MemoryItemBuilder WithListener(int frequency = 1, bool startListen = false)
63
{
64
HasListener = true;
65
ListenerFrequency = TimeSpan.FromMilliseconds(frequency);
66
StartListen = startListen;
67
return this;
68
}
69
/// <summary>
70
/// 使用静态地址
71
/// </summary>
72
/// <param name="memoryAddress">静态地址</param>
73
/// <returns></returns>
74
public MemoryItemBuilder WithStaticMemoryAddress(nint memoryAddress)
75
{
76
StaticMemoryAddress = memoryAddress;
77
return this;
78
}
79
/// <summary>
80
/// 使用动态地址
81
/// </summary>
82
/// <param name="memoryAddressGetFunc">内存地址动态获取方法</param>
83
/// <returns></returns>
84
public MemoryItemBuilder WithDynamicMemoryAddress(Func<nint?> memoryAddressGetFunc)
85
{
86
DynamicMemoryAddress = memoryAddressGetFunc;
87
return this;
88
}
89
/// <summary>
90
/// 使用可更新内存地址
91
/// </summary>
92
/// <param name="memoryAddressUpdateFunc">内存地址更新方法</param>
93
/// <returns></returns>
94
public MemoryItemBuilder WithUpdatableMemoryAddress(Func<nint?> memoryAddressUpdateFunc)
95
{
96
UpdatableMemoryAddress = memoryAddressUpdateFunc;
97
return this;
98
}
99
/// <summary>
100
/// 构建静态地址
101
/// </summary>
102
/// <typeparam name="T">内存地址的数据类型</typeparam>
103
/// <param name="name">内存地址自定义标识名</param>
104
/// <returns></returns>
105
public static MemoryItemBuilder Create<T>(string name) => new MemoryItemBuilderImpl { Name = name, MemoryAddressType = typeof(T) };
106
}
@@ -7,7 +7,7 @@ namespace XFEExtension.NetCore.MemoryEditor.Manager;
7
7
/// <summary>
8
8
/// 内存监听器
9
9
/// </summary>
10
public class MemoryListenerManager : IDisposable, IEnumerable
10
public class MemoryListenerManager : MemoryListenerManagerBase, IDisposable, IEnumerable
11
11
{
12
12
private bool disposedValue;
13
13
private readonly Dictionary<string, MemoryListener> listenerDictionary = [];
@@ -20,40 +20,72 @@ public class MemoryListenerManager : IDisposable, IEnumerable
20
20
/// </summary>
21
21
public event EventHandler? CurrentProcessExit;
22
22
/// <summary>
23
/// 目标进程启动时触发
24
/// </summary>
25
public event EventHandler? CurrentProcessEntered;
26
/// <summary>
23
27
/// 进程句柄
24
28
/// </summary>
25
29
public nint ProcessHandler { get; set; }
30
private string processName = string.Empty;
31
/// <summary>
32
/// 目标进程名称
33
/// </summary>
34
public string ProcessName
35
{
36
get { return processName; }
37
set { processName = value; }
38
}
26
39
private Process? currentProcess;
27
40
/// <summary>
28
41
/// 当前监听内存的目标进程
29
42
/// </summary>
30
43
public Process? CurrentProcess
31
44
{
32
get { return currentProcess; }
45
get => currentProcess;
33
46
set
34
47
{
35
48
if (value is not null)
36
49
{
37
50
currentProcess?.Dispose();
38
51
currentProcess = value;
39
ProcessHandler = MemoryEditor.GetProcessHandle(value.Id, ProcessAccessFlags.All);
52
ProcessName = value.ProcessName;
53
ProcessHandler = MemoryEditor.GetProcessHandle(value.Id, ProcessAccessFlags);
40
54
currentProcess.Exited += CurrentProcess_Exited;
41
55
if (IsListening)
42
56
{
43
57
foreach (var listener in listenerDictionary.Values)
44
58
{
45
59
if (listener is UpdatableMemoryListener updatableMemoryListener)
46
updatableMemoryListener.UpdateAddress();
60
updatableMemoryListener.UpdateAddress(ProcessHandler);
47
61
if (!listener.IsListening)
62
{
63
listener.ProcessHandler = ProcessHandler;
48
64
_ = listener.StartListen(ProcessHandler, listener.Frequency);
65
}
49
66
}
50
67
}
68
CurrentProcessEntered?.Invoke(value, EventArgs.Empty);
51
69
}
52
70
}
53
71
}
54
72
private async void CurrentProcess_Exited(object? sender, EventArgs e)
55
73
{
56
74
CurrentProcessExit?.Invoke(sender, e);
75
if (AutoReacquireProcess)
76
_ = Task.Run(async () =>
77
{
78
while (currentProcess is null || currentProcess.HasExited)
79
{
80
var result = Process.GetProcessesByName(ProcessName);
81
if (result is not null && result.Length >= 1)
82
{
83
CurrentProcess = result[0];
84
return;
85
}
86
await Task.Delay(AutoReacquireProcessFrequency);
87
}
88
});
57
89
await StopListeners();
58
90
}
59
91
/// <summary>
@@ -61,6 +93,18 @@ public class MemoryListenerManager : IDisposable, IEnumerable
61
93
/// </summary>
62
94
public bool IsListening { get; set; }
63
95
/// <summary>
96
/// 当目标进程退出后，是否自动重新获取进程
97
/// </summary>
98
public bool AutoReacquireProcess { get; set; }
99
/// <summary>
100
/// 自动重新获取进程的检测频率（单位毫秒）
101
/// </summary>
102
public int AutoReacquireProcessFrequency { get; set; } = 500;
103
/// <summary>
104
/// 进程句柄权限
105
/// </summary>
106
public ProcessAccessFlags ProcessAccessFlags { get; set; } = ProcessAccessFlags.All;
107
/// <summary>
64
108
/// 索引器
65
109
/// </summary>
66
110
/// <param name="customName">监听器自定义标识名</param>
@@ -70,48 +114,35 @@ public class MemoryListenerManager : IDisposable, IEnumerable
70
114
get => listenerDictionary[customName];
71
115
set => listenerDictionary[customName] = value;
72
116
}
73
/// <summary>
74
/// 开始监听
75
/// </summary>
76
/// <typeparam name="T">待监听的内存的数据类型（int,float,long等）</typeparam>
77
/// <param name="customName">自定义监听器标识名</param>
78
/// <param name="memoryAddress">待监听的内存地址</param>
79
/// <param name="frequency">检测频率，以毫秒为单位</param>
80
/// <returns></returns>
81
public MemoryListener AddListener<T>(string customName, nint memoryAddress, int frequency = 1) where T : struct => AddListener<T>(customName
82
, memoryAddress, TimeSpan.FromMilliseconds(frequency));
83
/// <summary>
84
/// 开始监听
85
/// </summary>
86
/// <typeparam name="T">待监听的内存的数据类型（int,float,long等）</typeparam>
87
/// <param name="customName">自定义监听器标识名</param>
88
/// <param name="memoryAddress">待监听的内存地址</param>
89
/// <param name="frequency">检测频率</param>
90
/// <returns></returns>
91
public MemoryListener AddListener<T>(string customName, nint memoryAddress, TimeSpan frequency) where T : struct
92
{
93
94
}
95
internal StaticMemoryListener AddStaticListener(string customName, nint memoryAddress, TimeSpan frequency, Type type)
117
internal override StaticMemoryListener AddStaticListener(string customName, nint memoryAddress, TimeSpan? frequency, Type type, bool startListen)
96
118
{
97
119
if (!IsListening)
98
120
IsListening = true;
99
121
var staticMemoryListener = MemoryListener.CreateStaticListener(customName, memoryAddress, type);
100
_ = staticMemoryListener.StartListen(ProcessHandler, frequency);
122
if (startListen)
123
_ = staticMemoryListener.StartListen(ProcessHandler, frequency);
101
124
return staticMemoryListener;
102
125
}
103
internal DynamicMemoryListener AddDynamicListener(string customName, Func<nint?> memoryAddressGetFunc, TimeSpan frequency, Type type)
126
internal override DynamicMemoryListener AddDynamicListener(string customName, Func<nint?> memoryAddressGetFunc, TimeSpan? frequency, Type type, bool startListen)
104
127
{
105
128
if (!IsListening)
106
129
IsListening = true;
107
130
var dynamicMemoryListener = MemoryListener.CreateDynamicListener(customName, memoryAddressGetFunc, type);
108
_ = dynamicMemoryListener.StartListen(ProcessHandler, frequency);
131
if (startListen)
132
_ = dynamicMemoryListener.StartListen(ProcessHandler, frequency);
109
133
return dynamicMemoryListener;
110
134
}
111
/// <summary>
112
/// 停止所有监听
113
/// </summary>
114
public async Task StopListeners()
135
internal override UpdatableMemoryListener AddUpdatableListener(string customName, Func<nint?> memoryAddressUpdateFunc, TimeSpan? frequency, Type type, bool startListen)
136
{
137
if (!IsListening)
138
IsListening = true;
139
var updatableMemoryListener = MemoryListener.CreateUpdatableListener(customName, memoryAddressUpdateFunc, type);
140
if (startListen)
141
_ = updatableMemoryListener.StartListen(ProcessHandler, frequency);
142
return updatableMemoryListener;
143
}
144
/// <inheritdoc/>
145
public override async Task StopListeners()
115
146
{
116
147
IsListening = false;
117
148
var taskList = new List<Task>();
@@ -121,25 +152,17 @@ public class MemoryListenerManager : IDisposable, IEnumerable
121
152
}
122
153
await Task.WhenAll(taskList);
123
154
}
124
/// <summary>
125
/// 停止指定的监听器
126
/// </summary>
127
/// <param name="customName">自定义名称</param>
128
public async Task StopListener(string customName) => await listenerDictionary[customName].StopListen();
129
/// <summary>
130
/// 移除指定监听器
131
/// </summary>
132
/// <param name="customName"></param>
133
public void RemoveListener(string customName)
155
/// <inheritdoc/>
156
public override async Task StopListener(string customName) => await listenerDictionary[customName].StopListen();
157
/// <inheritdoc/>
158
public override void RemoveListener(string customName)
134
159
{
135
160
listenerDictionary.Remove(customName);
136
161
if (listenerDictionary.Count == 0)
137
162
IsListening = false;
138
163
}
139
/// <summary>
140
/// 清除所有监听器
141
/// </summary>
142
public void Clear()
164
/// <inheritdoc/>
165
public override void ClearListeners()
143
166
{
144
167
IsListening = false;
145
168
listenerDictionary.Clear();
@@ -0,0 +1,91 @@
1
2
namespace XFEExtension.NetCore.MemoryEditor.Manager;
3
4
/// <summary>
5
/// 监听器管理器基类
6
/// </summary>
7
public abstract class MemoryListenerManagerBase
8
{
9
/// <summary>
10
/// 开始静态监听
11
/// </summary>
12
/// <typeparam name="T">待监听的内存的数据类型（int,float,long等）</typeparam>
13
/// <param name="customName">自定义监听器标识名</param>
14
/// <param name="memoryAddress">待监听的内存地址</param>
15
/// <param name="frequency">检测频率，以毫秒为单位</param>
16
/// <param name="startListen">启用监听</param>
17
/// <returns></returns>
18
public StaticMemoryListener AddStaticListener<T>(string customName, nint memoryAddress, int frequency = 1, bool startListen = true) where T : struct => AddStaticListener<T>(customName
19
, memoryAddress, TimeSpan.FromMilliseconds(frequency), startListen);
20
/// <summary>
21
/// 开始静态监听
22
/// </summary>
23
/// <typeparam name="T">待监听的内存的数据类型（int,float,long等）</typeparam>
24
/// <param name="customName">自定义监听器标识名</param>
25
/// <param name="memoryAddress">待监听的内存地址</param>
26
/// <param name="frequency">检测频率</param>
27
/// <param name="startListen">启用监听</param>
28
/// <returns></returns>
29
public StaticMemoryListener AddStaticListener<T>(string customName, nint memoryAddress, TimeSpan frequency, bool startListen = true) where T : struct => AddStaticListener(customName, memoryAddress, frequency, typeof(T), startListen);
30
internal abstract StaticMemoryListener AddStaticListener(string customName, nint memoryAddress, TimeSpan? frequency, Type type, bool startListen);
31
/// <summary>
32
/// 开始动态监听
33
/// </summary>
34
/// <typeparam name="T">待监听的内存的数据类型（int,float,long等）</typeparam>
35
/// <param name="customName">自定义监听器标识名</param>
36
/// <param name="getAddressFunc">内存地址动态获取方法</param>
37
/// <param name="frequency">检测频率，以毫秒为单位</param>
38
/// <param name="startListen">启用监听</param>
39
/// <returns></returns>
40
public DynamicMemoryListener AddDynamicListener<T>(string customName, Func<nint?> getAddressFunc, int frequency = 1, bool startListen = true) where T : struct => AddDynamicListener<T>(customName, getAddressFunc, TimeSpan.FromMilliseconds(frequency), startListen);
41
/// <summary>
42
/// 开始动态监听
43
/// </summary>
44
/// <typeparam name="T">待监听的内存的数据类型（int,float,long等）</typeparam>
45
/// <param name="customName">自定义监听器标识名</param>
46
/// <param name="getAddressFunc">内存地址动态获取方法</param>
47
/// <param name="frequency">检测频率</param>
48
/// <param name="startListen">启用监听</param>
49
/// <returns></returns>
50
public DynamicMemoryListener AddDynamicListener<T>(string customName, Func<nint?> getAddressFunc, TimeSpan frequency, bool startListen = true) where T : struct => AddDynamicListener(customName, getAddressFunc, frequency, typeof(T), startListen);
51
internal abstract DynamicMemoryListener AddDynamicListener(string customName, Func<nint?> memoryAddressGetFunc, TimeSpan? frequency, Type type, bool startListen);
52
/// <summary>
53
/// 开始可更新监听（在目标程序集变化时更新）
54
/// </summary>
55
/// <typeparam name="T">待监听的内存的数据类型（int,float,long等）</typeparam>
56
/// <param name="customName">自定义监听器标识名</param>
57
/// <param name="memoryAddressUpdateFunc">内存地址动态更新方法</param>
58
/// <param name="frequency">检测频率，以毫秒为单位</param>
59
/// <param name="startListen">启用监听</param>
60
/// <returns></returns>
61
public UpdatableMemoryListener AddUpdatableListener<T>(string customName, Func<nint?> memoryAddressUpdateFunc, int frequency = 1, bool startListen = true) where T : struct => AddUpdatableListener<T>(customName, memoryAddressUpdateFunc, TimeSpan.FromMilliseconds(frequency), startListen);
62
/// <summary>
63
/// 开始可更新监听（在目标程序集变化时更新）
64
/// </summary>
65
/// <typeparam name="T">待监听的内存的数据类型（int,float,long等）</typeparam>
66
/// <param name="customName">自定义监听器标识名</param>
67
/// <param name="memoryAddressUpdateFunc">内存地址动态更新方法</param>
68
/// <param name="frequency">检测频率</param>
69
/// <param name="startListen">启用监听</param>
70
/// <returns></returns>
71
public UpdatableMemoryListener AddUpdatableListener<T>(string customName, Func<nint?> memoryAddressUpdateFunc, TimeSpan frequency, bool startListen = true) where T : struct => AddUpdatableListener(customName, memoryAddressUpdateFunc, frequency, typeof(T), startListen);
72
internal abstract UpdatableMemoryListener AddUpdatableListener(string customName, Func<nint?> memoryAddressUpdateFunc, TimeSpan? frequency, Type type, bool startListen);
73
/// <summary>
74
/// 清除所有监听器
75
/// </summary>
76
public abstract void ClearListeners();
77
/// <summary>
78
/// 移除指定监听器
79
/// </summary>
80
/// <param name="customName">监听器自定义表示名称</param>
81
public abstract void RemoveListener(string customName);
82
/// <summary>
83
/// 停止指定的监听器
84
/// </summary>
85
/// <param name="customName">监听器自定义表示名称</param>
86
public abstract Task StopListener(string customName);
87
/// <summary>
88
/// 停止所有监听
89
/// </summary>
90
public abstract Task StopListeners();
91
}
@@ -1,47 +1,41 @@
1
1
using System.Collections;
2
using System.Diagnostics;
2
3
3
4
namespace XFEExtension.NetCore.MemoryEditor.Manager;
4
5
5
6
/// <summary>
6
7
/// 内存地址管理器
7
8
/// </summary>
8
/// <param name="processHandler">目标进程句柄</param>
9
public abstract class MemoryManager(nint processHandler) : IDisposable, IEnumerable
9
public abstract class MemoryManager : IMemoryManager
10
10
{
11
11
private protected bool disposedValue;
12
private protected Dictionary<string, Func<nint?>> memoryAddressGetFuncDictionary = [];
13
12
/// <summary>
14
/// 监听器
13
/// 编辑器
15
14
/// </summary>
16
public MemoryListenerManager Listener { get; protected set; } = new(processHandler);
15
public MemoryEditor Editor { get; protected set; } = new();
17
16
/// <summary>
18
17
/// 现成句柄
19
18
/// </summary>
20
public nint ProcessHandler { get; set; } = processHandler;
19
public nint ProcessHandler { get => Editor.ProcessHandle; set => Editor.ProcessHandle = value; }
21
20
/// <summary>
22
/// 索引器
21
/// 当前目标进程
23
22
/// </summary>
24
/// <param name="addressName">地址标识名称</param>
25
/// <returns></returns>
26
public abstract nint? this[string addressName] { get; }
27
/// <summary>
28
/// 添加地址
29
/// </summary>
30
/// <param name="addressName">标识名称</param>
31
/// <param name="addressGetFunc">地址的获取方法</param>
32
public abstract void Add(string addressName, Func<nint?> addressGetFunc);
33
/// <summary>
34
/// 设置指定名称的地址的获取方法
35
/// </summary>
36
/// <param name="addressName">地址标识名称</param>
37
/// <param name="newAddressGetFun">新的获取方法</param>
38
public abstract void Set(string addressName, Func<nint?> newAddressGetFun);
39
public abstract void AddWithListener(s)
23
public Process? CurrentProcess { get => Editor.CurrentProcess; set => Editor.CurrentProcess = value; }
40
24
/// <summary>
41
25
/// 移除指定名称的地址
42
26
/// </summary>
43
27
/// <param name="addressName">地址名称</param>
44
28
public abstract void Remove(string addressName);
29
internal abstract void Add(MemoryItemBuilder builder);
30
/// <summary>
31
/// 添加地址
32
/// </summary>
33
/// <param name="builders">内存地址构建器组</param>
34
public void Add(params MemoryItemBuilder[] builders)
35
{
36
foreach (var builder in builders)
37
Add(builder);
38
}
45
39
/// <summary>
46
40
/// 释放资源
47
41
/// </summary>
@@ -52,7 +46,7 @@ public abstract class MemoryManager(nint processHandler) : IDisposable, IEnumera
52
46
{
53
47
if (disposing)
54
48
{
55
Listener.Dispose();
49
Editor.Dispose();
56
50
}
57
51
disposedValue = true;
58
52
}
@@ -1,21 +1,50 @@
1
namespace XFEExtension.NetCore.MemoryEditor.Manager;
1
using XFEExtension.NetCore.ImplExtension;
2
2
3
public abstract class StaticMemoryItem(string name) : MemoryItem(name)
3
namespace XFEExtension.NetCore.MemoryEditor.Manager;
4
5
/// <summary>
6
/// 静态内存
7
/// </summary>
8
/// <param name="name">地址自定义标识名称</param>
9
/// <param name="memoryAddress">内存地址</param>
10
/// <param name="memoryItemType">内存地址数据类型</param>
11
/// <param name="memoryEditor">内存修改器</param>
12
[CreateImpl]
13
public abstract class StaticMemoryItem(string name, nint memoryAddress, Type memoryItemType, MemoryEditor memoryEditor) : MemoryItem(name, memoryItemType, memoryEditor)
4
14
{
5
public override void AddListener()
15
/// <summary>
16
/// 监听器
17
/// </summary>
18
public StaticMemoryListener? Listener { get; protected set; }
19
/// <summary>
20
/// 内存地址
21
/// </summary>
22
public nint MemoryAddress { get; init; } = memoryAddress;
23
/// <inheritdoc/>
24
public override bool HasListener { get => Listener is not null; }
25
/// <inheritdoc/>
26
public override void AddListener(TimeSpan? frequency = null, bool startListen = false) => Listener = memoryEditor.AddStaticListener(Name, MemoryAddress, frequency, MemoryItemType, startListen);
27
/// <inheritdoc/>
28
public override bool Read<T>(out T result) => memoryEditor.ReadMemory(MemoryAddress, out result);
29
/// <inheritdoc/>
30
public override void RemoveListener()
6
31
{
7
if (HasListener)
8
throw new InvalidOperationException("已存在监听器，无法重复添加");
9
HasListener = true;
10
memoryListener.StartListen
32
memoryEditor.RemoveListener(Name);
33
Listener = null;
11
34
}
12
13
public override void RemoveListener()
35
/// <inheritdoc/>
36
public override async Task StopListen()
14
37
{
15
throw new NotImplementedException();
38
if (Listener is null)
39
throw new InvalidOperationException($"{nameof(Listener)} 监听器为空");
40
await Listener.StopListen();
16
41
}
17
public void UpdateStaticAddress()
42
/// <inheritdoc/>
43
public override bool Write<T>(T value) => memoryEditor.WriteMemory(MemoryAddress, value);
44
internal override async Task StartListen(nint processHandler, TimeSpan? frequency = null)
18
45
{
19
46
if (Listener is null)
47
throw new InvalidOperationException($"{nameof(Listener)} 监听器为空");
48
await Listener.StartListen(processHandler, frequency);
20
49
}
21
50
}
@@ -7,64 +7,38 @@ namespace XFEExtension.NetCore.MemoryEditor.Manager;
7
7
/// </summary>
8
8
public abstract class StaticMemoryManager : MemoryManager
9
9
{
10
internal StaticMemoryManager(nint processHandler) : base(processHandler)
11
{
12
}
13
14
10
/// <summary>
15
11
/// 地址值字典
16
12
/// </summary>
17
public Dictionary<string, nint?> AddressDictionary { get; set; } = [];
13
public Dictionary<string, StaticMemoryItem> ItemDictionary { get; set; } = [];
18
14
/// <summary>
19
15
/// 索引器
20
16
/// </summary>
21
17
/// <param name="addressName">地址标识名</param>
22
18
/// <returns></returns>
23
public override nint? this[string addressName] => AddressDictionary[addressName];
24
/// <summary>
25
/// 添加地址（使用动态获取）
26
/// </summary>
27
/// <param name="addressName">标识名称</param>
28
/// <param name="addressGetFunc">地址的获取方法</param>
29
public override void Add(string addressName, Func<nint?> addressGetFunc)
19
public StaticMemoryItem this[string addressName] => ItemDictionary[addressName];
20
internal override void Add(MemoryItemBuilder builder)
30
21
{
31
memoryAddressGetFuncDictionary.Add(addressName, addressGetFunc);
32
AddressDictionary.Add(addressName, addressGetFunc.Invoke());
22
if (builder.StaticMemoryAddress is null)
23
throw new ArgumentNullException(nameof(builder), "对于静态地址管理器，构建器的静态地址不可为空");
24
var staticMemoryItem = new StaticMemoryItemImpl(builder.Name, builder.StaticMemoryAddress.Value, builder.MemoryAddressType, Editor);
25
if (builder.HasListener)
26
staticMemoryItem.AddListener(builder.ListenerFrequency, builder.StartListen);
27
ItemDictionary.Add(builder.Name, staticMemoryItem);
33
28
}
34
29
/// <summary>
35
/// 添加地址
36
/// </summary>
37
/// <param name="addressName">标识名称</param>
38
/// <param name="address">地址</param>
39
public void Add(string addressName, nint? address) => AddressDictionary.Add(addressName, address);
40
/// <summary>
41
/// 设置指定名称的地址的获取方法
42
/// </summary>
43
/// <param name="addressName">地址标识名称</param>
44
/// <param name="newAddressGetFun">新的获取方法</param>
45
public override void Set(string addressName, Func<nint?> newAddressGetFun)
46
{
47
memoryAddressGetFuncDictionary[addressName] = newAddressGetFun;
48
AddressDictionary[addressName] = newAddressGetFun.Invoke();
49
}
50
/// <summary>
51
/// 设置指定名称的地址的获取方法
52
/// </summary>
53
/// <param name="addressName">地址标识名称</param>
54
/// <param name="newAddress">新的获取方法</param>
55
public void Set(string addressName, nint? newAddress) => AddressDictionary[addressName] = newAddress;
56
/// <summary>
57
30
/// 获取枚举器
58
31
/// </summary>
59
32
/// <returns></returns>
60
public override IEnumerator GetEnumerator() => AddressDictionary.GetEnumerator();
33
public override IEnumerator GetEnumerator() => ItemDictionary.GetEnumerator();
61
34
/// <summary>
62
35
/// 释放资源
63
36
/// </summary>
64
37
/// <param name="addressName">地址标识名称</param>
65
public override void Remove(string addressName)
66
{
67
AddressDictionary.Remove(addressName);
68
memoryAddressGetFuncDictionary.Remove(addressName);
69
}
70
}
38
public override void Remove(string addressName) => ItemDictionary.Remove(addressName);
39
/// <summary>
40
/// 静态内存管理器
41
/// </summary>
42
/// <param name="builders">内存构建器组</param>
43
protected StaticMemoryManager(params MemoryItemBuilder[] builders) => Add(builders);
44
}