返回提交历史
Modified
XFEExtension.NetCore.MemoryEditor.sln
+14
-7
Modified
XFEExtension.NetCore.MemoryEditor/Manager/DynamicMemoryManager.cs
+15
-4
Modified
XFEExtension.NetCore.MemoryEditor/Manager/MemoryItem.cs
+1
-1
Modified
XFEExtension.NetCore.MemoryEditor/Manager/MemoryItemBuilder.cs
+31
-0
Modified
XFEExtension.NetCore.MemoryEditor/Manager/MemoryListenerManager.cs
+32
-16
Modified
XFEExtension.NetCore.MemoryEditor/Manager/MemoryManager.cs
+53
-4
Added
XFEExtension.NetCore.MemoryEditor/Manager/MemoryManagerBuilder.cs
+102
-0
Modified
XFEExtension.NetCore.MemoryEditor/Manager/StaticMemoryManager.cs
+3
-1
Modified
XFEExtension.NetCore.MemoryEditor/Manager/UpdatableMemoryManager.cs
+14
-3
Modified
XFEExtension.NetCore.MemoryEditor/MemoryEditor.cs
+19
-26
XFEstudio/XFEExtension.NetCore.MemoryEditor
撤销对抽象类的取消，现在统一使用优化后的构建器 优化内存条目构建器，现在可以直接添加基址指针动态表达式
ff62546
代码差异
10 个文件
+284
-62
@@ -2,9 +2,7 @@ Microsoft Visual Studio Solution File, Format Version 12.00
2
2
# Visual Studio Version 17
3
3
VisualStudioVersion = 17.9.34728.123
4
4
MinimumVisualStudioVersion = 10.0.40219.1
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}"
5
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "XFEExtension.NetCore.MemoryEditor", "XFEExtension.NetCore.MemoryEditor\XFEExtension.NetCore.MemoryEditor.csproj", "{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}"
8
6
EndProject
9
7
Global
10
8
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -12,10 +10,19 @@ Global
12
10
Release|Any CPU = Release|Any CPU
13
11
EndGlobalSection
14
12
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
13
{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
14
{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}.Debug|Any CPU.Build.0 = Debug|Any CPU
15
{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}.Release|Any CPU.ActiveCfg = Release|Any CPU
16
{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}.Release|Any CPU.Build.0 = Release|Any CPU
17
EndGlobalSection
18
GlobalSection(SolutionProperties) = preSolution
19
HideSolutionNode = FALSE
20
EndGlobalSection
21
GlobalSection(ExtensibilityGlobals) = postSolution
22
SolutionGuid = {5652406C-CF19-4708-BA94-E51808552081}
23
EndGlobalSection
24
EndGlobal
25
{7D09E8EC-562E-496F-8362-5BEBD541238D}.Release|Any CPU.Build.0 = Release|Any CPU
19
26
{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
20
27
{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}.Debug|Any CPU.Build.0 = Debug|Any CPU
21
28
{DBFE2E7A-C727-4E8D-AD9E-83E7EA36F937}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -1,11 +1,13 @@
1
1
using System.Collections;
2
using XFEExtension.NetCore.ImplExtension;
2
3
3
4
namespace XFEExtension.NetCore.MemoryEditor.Manager;
4
5
5
6
/// <summary>
6
7
/// 动态内存管理器
7
8
/// </summary>
8
public class DynamicMemoryManager : MemoryManager
9
[CreateImpl]
10
public abstract class DynamicMemoryManager : MemoryManager
9
11
{
10
12
/// <summary>
11
13
/// 地址值字典
@@ -19,8 +21,17 @@ public class DynamicMemoryManager : MemoryManager
19
21
public DynamicMemoryItem this[string addressName] => ItemDictionary[addressName];
20
22
internal override void Add(MemoryItemBuilder builder)
21
23
{
22
if (builder.DynamicMemoryAddress is null)
23
throw new ArgumentNullException(nameof(builder), "对于动态地址管理器，构建器的动态地址不可为空");
24
if (builder.UseResolvePointer)
25
{
26
if (builder.ModuleName is null)
27
throw new ArgumentNullException(nameof(builder), "对于使用基址指针表达式的构建器，模块名称是必须的");
28
builder.DynamicMemoryAddress = new(() => Editor.ResolvePointerAddress(builder.ModuleName, builder.BaseAddress, builder.Offsets));
29
}
30
else
31
{
32
if (builder.DynamicMemoryAddress is null)
33
throw new ArgumentNullException(nameof(builder), "对于动态地址管理器，构建器的动态地址不可为空");
34
}
24
35
var dynamicMemoryItem = new DynamicMemoryItemImpl(builder.Name, builder.DynamicMemoryAddress, builder.MemoryAddressType, Editor);
25
36
if (builder.HasListener)
26
37
dynamicMemoryItem.AddListener(builder.ListenerFrequency, builder.StartListen);
@@ -40,5 +51,5 @@ public class DynamicMemoryManager : MemoryManager
40
51
/// 动态内存管理器
41
52
/// </summary>
42
53
/// <param name="builders">内存构建器组</param>
43
public DynamicMemoryManager(params MemoryItemBuilder[] builders) => Add(builders);
54
internal DynamicMemoryManager(params MemoryItemBuilder[] builders) => Add(builders);
44
55
}
@@ -40,7 +40,7 @@ public abstract class MemoryItem(string name, Type memoryItemType, MemoryEditor
40
40
if (IsListening)
41
41
throw new InvalidOperationException("正在监听中，无法重复监听");
42
42
IsListening = true;
43
await StartListen(memoryEditor.ProcessHandle, frequency);
43
await StartListen(memoryEditor.ProcessHandler, frequency);
44
44
}
45
45
internal abstract Task StartListen(nint processHandler, TimeSpan? frequency);
46
46
/// <summary>
@@ -21,6 +21,10 @@ public abstract class MemoryItemBuilder
21
21
/// </summary>
22
22
public bool StartListen { get; set; }
23
23
/// <summary>
24
/// 使用基址指针表达式
25
/// </summary>
26
public bool UseResolvePointer { get; private set; }
27
/// <summary>
24
28
/// 内存地址类型
25
29
/// </summary>
26
30
public required Type MemoryAddressType { get; set; }
@@ -41,6 +45,18 @@ public abstract class MemoryItemBuilder
41
45
/// </summary>
42
46
public Func<nint?>? UpdatableMemoryAddress { get; set; }
43
47
/// <summary>
48
/// 模块名称
49
/// </summary>
50
public string? ModuleName { get; set; }
51
/// <summary>
52
/// 模块的地址部分
53
/// </summary>
54
public nint BaseAddress { get; set; }
55
/// <summary>
56
/// 基址偏移部分
57
/// </summary>
58
public nint[] Offsets { get; set; } = [];
59
/// <summary>
44
60
/// 为该地址添加监听器
45
61
/// </summary>
46
62
/// <param name="frequency">监听频率</param>
@@ -87,6 +103,21 @@ public abstract class MemoryItemBuilder
87
103
return this;
88
104
}
89
105
/// <summary>
106
/// 使用基址指针动态表达式
107
/// </summary>
108
/// <param name="moduleName">模块名称</param>
109
/// <param name="baseAddress">模块的地址部分</param>
110
/// <param name="offsets">基址指针偏移部分</param>
111
/// <returns></returns>
112
public MemoryItemBuilder WithResolvePointer(string moduleName, nint baseAddress, params nint[] offsets)
113
{
114
UseResolvePointer = true;
115
ModuleName = moduleName;
116
BaseAddress = baseAddress;
117
Offsets = offsets;
118
return this;
119
}
120
/// <summary>
90
121
/// 使用可更新内存地址
91
122
/// </summary>
92
123
/// <param name="memoryAddressUpdateFunc">内存地址更新方法</param>
@@ -73,19 +73,7 @@ public class MemoryListenerManager : MemoryListenerManagerBase, IDisposable, IEn
73
73
{
74
74
CurrentProcessExit?.Invoke(sender, e);
75
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
});
76
_ = WaitProcessEnter();
89
77
await StopListeners();
90
78
}
91
79
/// <summary>
@@ -97,9 +85,9 @@ public class MemoryListenerManager : MemoryListenerManagerBase, IDisposable, IEn
97
85
/// </summary>
98
86
public bool AutoReacquireProcess { get; set; }
99
87
/// <summary>
100
/// 自动重新获取进程的检测频率（单位毫秒）
88
/// 重新获取进程的检测频率（单位毫秒）
101
89
/// </summary>
102
public int AutoReacquireProcessFrequency { get; set; } = 500;
90
public int ReacquireProcessFrequency { get; set; } = 500;
103
91
/// <summary>
104
92
/// 进程句柄权限
105
93
/// </summary>
@@ -119,6 +107,7 @@ public class MemoryListenerManager : MemoryListenerManagerBase, IDisposable, IEn
119
107
if (!IsListening)
120
108
IsListening = true;
121
109
var staticMemoryListener = MemoryListener.CreateStaticListener(customName, memoryAddress, type);
110
staticMemoryListener.ValueChanged += (sender, e) => ValueChanged?.Invoke(sender, e);
122
111
if (startListen)
123
112
_ = staticMemoryListener.StartListen(ProcessHandler, frequency);
124
113
return staticMemoryListener;
@@ -128,6 +117,7 @@ public class MemoryListenerManager : MemoryListenerManagerBase, IDisposable, IEn
128
117
if (!IsListening)
129
118
IsListening = true;
130
119
var dynamicMemoryListener = MemoryListener.CreateDynamicListener(customName, memoryAddressGetFunc, type);
120
dynamicMemoryListener.ValueChanged += (sender, e) => ValueChanged?.Invoke(sender, e);
131
121
if (startListen)
132
122
_ = dynamicMemoryListener.StartListen(ProcessHandler, frequency);
133
123
return dynamicMemoryListener;
@@ -137,10 +127,36 @@ public class MemoryListenerManager : MemoryListenerManagerBase, IDisposable, IEn
137
127
if (!IsListening)
138
128
IsListening = true;
139
129
var updatableMemoryListener = MemoryListener.CreateUpdatableListener(customName, memoryAddressUpdateFunc, type);
130
updatableMemoryListener.ValueChanged += (sender, e) => ValueChanged?.Invoke(sender, e);
140
131
if (startListen)
141
132
_ = updatableMemoryListener.StartListen(ProcessHandler, frequency);
142
133
return updatableMemoryListener;
143
134
}
135
/// <summary>
136
/// 等待目标进程出现
137
/// </summary>
138
/// <param name="processName">进程名称</param>
139
/// <param name="frequency">检测频率</param>
140
/// <returns></returns>
141
public async Task WaitProcessEnter(string? processName = null, int frequency = 500)
142
{
143
if (processName is not null)
144
ProcessName = processName;
145
ReacquireProcessFrequency = frequency;
146
await Task.Run(async () =>
147
{
148
while (currentProcess is null || currentProcess.HasExited)
149
{
150
var result = Process.GetProcessesByName(ProcessName);
151
if (result is not null && result.Length >= 1)
152
{
153
CurrentProcess = result[0];
154
return;
155
}
156
await Task.Delay(ReacquireProcessFrequency);
157
}
158
});
159
}
144
160
/// <inheritdoc/>
145
161
public override async Task StopListeners()
146
162
{
@@ -217,4 +233,4 @@ public class MemoryListenerManager : MemoryListenerManagerBase, IDisposable, IEn
217
233
/// </summary>
218
234
/// <returns></returns>
219
235
public IEnumerator GetEnumerator() => listenerDictionary.GetEnumerator();
220
}
236
}
@@ -1,5 +1,6 @@
1
1
using System.Collections;
2
2
using System.Diagnostics;
3
using XFEExtension.NetCore.DelegateExtension;
3
4
4
5
namespace XFEExtension.NetCore.MemoryEditor.Manager;
5
6
@@ -10,18 +11,53 @@ public abstract class MemoryManager : IMemoryManager
10
11
{
11
12
private protected bool disposedValue;
12
13
/// <summary>
13
/// 编辑器
14
/// 当指定地址的内存值变化时触发
14
15
/// </summary>
15
public MemoryEditor Editor { get; protected set; } = new();
16
public event XFEEventHandler<MemoryItem, MemoryValue>? ValueChanged;
17
/// <summary>
18
/// 当前进程结束时触发
19
/// </summary>
20
public event EventHandler? CurrentProcessExit;
16
21
/// <summary>
17
/// 现成句柄
22
/// 目标进程启动时触发
18
23
/// </summary>
19
public nint ProcessHandler { get => Editor.ProcessHandle; set => Editor.ProcessHandle = value; }
24
public event EventHandler? CurrentProcessEntered;
20
25
/// <summary>
21
26
/// 当前目标进程
22
27
/// </summary>
23
28
public Process? CurrentProcess { get => Editor.CurrentProcess; set => Editor.CurrentProcess = value; }
24
29
/// <summary>
30
/// 进程句柄
31
/// </summary>
32
public nint ProcessHandler { get => Editor.ProcessHandler; set => Editor.ProcessHandler = value; }
33
/// <summary>
34
/// 当目标进程退出后，是否自动重新获取进程
35
/// </summary>
36
public bool AutoReacquireProcess { get => Editor.AutoReacquireProcess; set => Editor.AutoReacquireProcess = value; }
37
/// <summary>
38
/// 重新获取进程的检测频率（单位毫秒）
39
/// </summary>
40
public int ReacquireProcessFrequency { get => Editor.AutoReacquireProcessFrequency; set => Editor.AutoReacquireProcessFrequency = value; }
41
/// <summary>
42
/// 进程句柄权限（不懂勿填）
43
/// </summary>
44
public ProcessAccessFlags ProcessAccessFlags { get => Editor.ProcessAccessFlags; set => Editor.ProcessAccessFlags = value; }
45
/// <summary>
46
/// 进程位数类型（32/64）
47
/// </summary>
48
public ProcessType ProcessBiteType { get => Editor.ProcessBiteType; set => Editor.ProcessBiteType = value; }
49
/// <summary>
50
/// 编辑器
51
/// </summary>
52
public MemoryEditor Editor { get; protected set; } = new();
53
/// <summary>
54
/// 等待目标进程出现
55
/// </summary>
56
/// <param name="processName">进程名称</param>
57
/// <param name="frequency">检测频率</param>
58
/// <returns></returns>
59
public async Task WaitProcessEnter(string? processName = null, int frequency = 500) => await Editor.WaitProcessEnter(processName, frequency);
60
/// <summary>
25
61
/// 移除指定名称的地址
26
62
/// </summary>
27
63
/// <param name="addressName">地址名称</param>
@@ -64,4 +100,17 @@ public abstract class MemoryManager : IMemoryManager
64
100
/// </summary>
65
101
/// <returns></returns>
66
102
public abstract IEnumerator GetEnumerator();
103
/// <summary>
104
/// 内存管理器
105
/// </summary>
106
protected MemoryManager()
107
{
108
Editor.CurrentProcessEntered += (sender, e) => CurrentProcessEntered?.Invoke(sender, e);
109
Editor.CurrentProcessExit += (sender, e) => CurrentProcessExit?.Invoke(sender, e);
110
}
111
/// <summary>
112
/// 创建内存管理器构建器
113
/// </summary>
114
/// <returns></returns>
115
public static MemoryManagerBuilder CreateBuilder() => MemoryManagerBuilder.CreateBuilder();
67
116
}
@@ -0,0 +1,102 @@
1
using XFEExtension.NetCore.ImplExtension;
2
3
namespace XFEExtension.NetCore.MemoryEditor.Manager;
4
5
/// <summary>
6
/// 内存管理器构建器
7
/// </summary>
8
[CreateImpl]
9
public abstract class MemoryManagerBuilder()
10
{
11
/// <summary>
12
/// 进程名称
13
/// </summary>
14
public string ProcessName { get; set; } = string.Empty;
15
/// <summary>
16
/// 当目标进程退出后，是否自动重新获取进程
17
/// </summary>
18
public bool AutoReacquireProcess { get; set; }
19
/// <summary>
20
/// 重新获取进程的检测频率（单位毫秒）
21
/// </summary>
22
public int ReacquireProcessFrequency { get; set; }
23
/// <summary>
24
/// 是否在创建后自动开始寻找目标进程
25
/// </summary>
26
public bool FindProcessWhenCreate { get; set; }
27
/// <summary>
28
/// 创建内存地址管理器构建器
29
/// </summary>
30
/// <returns></returns>
31
public static MemoryManagerBuilder CreateBuilder() => new MemoryManagerBuilderImpl();
32
/// <summary>
33
/// 使用自动重新获取进程
34
/// </summary>
35
/// <param name="reacquireProcessFrequency">重新获取进程的检测频率（单位毫秒）</param>
36
/// <returns></returns>
37
public MemoryManagerBuilder WithAutoReacquireProcess(int reacquireProcessFrequency = 500)
38
{
39
AutoReacquireProcess = true;
40
ReacquireProcessFrequency = reacquireProcessFrequency;
41
return this;
42
}
43
/// <summary>
44
/// 在创建后自动开始寻找目标进程
45
/// </summary>
46
/// <param name="processName">进程名称</param>
47
/// <returns></returns>
48
public MemoryManagerBuilder WithFindProcessWhenCreate(string processName)
49
{
50
ProcessName = processName;
51
FindProcessWhenCreate = true;
52
return this;
53
}
54
/// <summary>
55
/// 构建静态内存地址管理器
56
/// </summary>
57
/// <param name="builders">内存构建器组</param>
58
/// <returns></returns>
59
public StaticMemoryManager BuildStaticManager(params MemoryItemBuilder[] builders)
60
{
61
var manager = new StaticMemoryManagerImpl(builders)
62
{
63
AutoReacquireProcess = AutoReacquireProcess,
64
ReacquireProcessFrequency = ReacquireProcessFrequency
65
};
66
if (FindProcessWhenCreate)
67
_ = manager.WaitProcessEnter(ProcessName);
68
return manager;
69
}
70
/// <summary>
71
/// 构建动态内存地址管理器
72
/// </summary>
73
/// <param name="builders">内存构建器组</param>
74
/// <returns></returns>
75
public DynamicMemoryManager BuildDynamicManager(params MemoryItemBuilder[] builders)
76
{
77
var manager = new DynamicMemoryManagerImpl(builders)
78
{
79
AutoReacquireProcess = AutoReacquireProcess,
80
ReacquireProcessFrequency = ReacquireProcessFrequency
81
};
82
if (FindProcessWhenCreate)
83
_ = manager.WaitProcessEnter(ProcessName);
84
return manager;
85
}
86
/// <summary>
87
/// 构建可更新内存地址管理器
88
/// </summary>
89
/// <param name="builders">内存构建器组</param>
90
/// <returns></returns>
91
public UpdatableMemoryManager BuildUpdatableManager(params MemoryItemBuilder[] builders)
92
{
93
var manager = new UpdatableMemoryManager(builders)
94
{
95
AutoReacquireProcess = AutoReacquireProcess,
96
ReacquireProcessFrequency = ReacquireProcessFrequency
97
};
98
if (FindProcessWhenCreate)
99
_ = manager.WaitProcessEnter(ProcessName);
100
return manager;
101
}
102
}
@@ -1,10 +1,12 @@
1
1
using System.Collections;
2
using XFEExtension.NetCore.ImplExtension;
2
3
3
4
namespace XFEExtension.NetCore.MemoryEditor.Manager;
4
5
5
6
/// <summary>
6
7
/// 静态内存管理器
7
8
/// </summary>
9
[CreateImpl]
8
10
public class StaticMemoryManager : MemoryManager
9
11
{
10
12
/// <summary>
@@ -40,5 +42,5 @@ public class StaticMemoryManager : MemoryManager
40
42
/// 静态内存管理器
41
43
/// </summary>
42
44
/// <param name="builders">内存构建器组</param>
43
public StaticMemoryManager(params MemoryItemBuilder[] builders) => Add(builders);
45
internal StaticMemoryManager(params MemoryItemBuilder[] builders) => Add(builders);
44
46
}
@@ -1,10 +1,12 @@
1
1
using System.Collections;
2
using XFEExtension.NetCore.ImplExtension;
2
3
3
4
namespace XFEExtension.NetCore.MemoryEditor.Manager;
4
5
5
6
/// <summary>
6
7
/// 可更新内存管理器
7
8
/// </summary>
9
[CreateImpl]
8
10
public class UpdatableMemoryManager : MemoryManager
9
11
{
10
12
/// <summary>
@@ -19,8 +21,17 @@ public class UpdatableMemoryManager : MemoryManager
19
21
public UpdatableMemoryItem this[string addressName] => ItemDictionary[addressName];
20
22
internal override void Add(MemoryItemBuilder builder)
21
23
{
22
if (builder.UpdatableMemoryAddress is null)
23
throw new ArgumentNullException(nameof(builder), "对于可更新内存管理器，构建器更新地址的方法不可为空");
24
if (builder.UseResolvePointer)
25
{
26
if (builder.ModuleName is null)
27
throw new ArgumentNullException(nameof(builder), "对于使用基址指针表达式的构建器，模块名称是必须的");
28
builder.UpdatableMemoryAddress = new(() => Editor.ResolvePointerAddress(builder.ModuleName, builder.BaseAddress, builder.Offsets));
29
}
30
else
31
{
32
if (builder.UpdatableMemoryAddress is null)
33
throw new ArgumentNullException(nameof(builder), "对于可更新内存管理器，构建器更新地址的方法不可为空");
34
}
24
35
var updatableMemoryItem = new UpdatableMemoryItemImpl(builder.Name, builder.UpdatableMemoryAddress, builder.MemoryAddressType, Editor);
25
36
if (builder.HasListener)
26
37
updatableMemoryItem.AddListener(builder.ListenerFrequency, builder.StartListen);
@@ -40,5 +51,5 @@ public class UpdatableMemoryManager : MemoryManager
40
51
/// 可更新内存管理器
41
52
/// </summary>
42
53
/// <param name="builders">内存构建器组</param>
43
public UpdatableMemoryManager(params MemoryItemBuilder[] builders) => Add(builders);
54
internal UpdatableMemoryManager(params MemoryItemBuilder[] builders) => Add(builders);
44
55
}
@@ -27,22 +27,11 @@ public partial class MemoryEditor : MemoryListenerManagerBase, IDisposable
27
27
/// <summary>
28
28
/// 当前目标进程
29
29
/// </summary>
30
public Process? CurrentProcess
31
{
32
get => listenerManager.CurrentProcess;
33
set
34
{
35
if (value is not null)
36
{
37
listenerManager.CurrentProcess = value;
38
39
}
40
}
41
}
30
public Process? CurrentProcess { get => listenerManager.CurrentProcess; set => listenerManager.CurrentProcess = value; }
42
31
/// <summary>
43
32
/// 进程句柄
44
33
/// </summary>
45
public nint ProcessHandle { get => listenerManager.ProcessHandler; set => listenerManager.ProcessHandler = value; }
34
public nint ProcessHandler { get => listenerManager.ProcessHandler; set => listenerManager.ProcessHandler = value; }
46
35
/// <summary>
47
36
/// 内存监听器
48
37
/// </summary>
@@ -58,7 +47,7 @@ public partial class MemoryEditor : MemoryListenerManagerBase, IDisposable
58
47
/// <summary>
59
48
/// 自动重新获取进程的检测频率（单位毫秒）
60
49
/// </summary>
61
public int AutoReacquireProcessFrequency { get => listenerManager.AutoReacquireProcessFrequency; set => listenerManager.AutoReacquireProcessFrequency = value; }
50
public int AutoReacquireProcessFrequency { get => listenerManager.ReacquireProcessFrequency; set => listenerManager.ReacquireProcessFrequency = value; }
62
51
/// <summary>
63
52
/// 进程句柄权限（不懂勿填）
64
53
/// </summary>
@@ -68,13 +57,20 @@ public partial class MemoryEditor : MemoryListenerManagerBase, IDisposable
68
57
/// </summary>
69
58
public ProcessType ProcessBiteType { get; set; }
70
59
/// <summary>
60
/// 等待目标进程出现
61
/// </summary>
62
/// <param name="processName">进程名称</param>
63
/// <param name="frequency">检测频率</param>
64
/// <returns></returns>
65
public async Task WaitProcessEnter(string? processName = null, int frequency = 500) => await listenerManager.WaitProcessEnter(processName, frequency);
66
/// <summary>
71
67
/// 读取指定地址的内存
72
68
/// </summary>
73
69
/// <typeparam name="T">目标类型（int,float,long等）</typeparam>
74
70
/// <param name="address">指定地址</param>
75
71
/// <param name="result">读取结果</param>
76
72
/// <returns>是否读取成功</returns>
77
public bool ReadMemory<T>(nint address, out T result) where T : struct => ReadMemory<T>(ProcessHandle, address, out result);
73
public bool ReadMemory<T>(nint address, out T result) where T : struct => ReadMemory(ProcessHandler, address, out result);
78
74
/// <summary>
79
75
/// 在指定内存地址中写入数据
80
76
/// </summary>
@@ -82,7 +78,7 @@ public partial class MemoryEditor : MemoryListenerManagerBase, IDisposable
82
78
/// <param name="address">目标地址</param>
83
79
/// <param name="source">待写入值</param>
84
80
/// <returns>是否写入成功</returns>
85
public bool WriteMemory<T>(nint address, T source) where T : struct => WriteMemory<T>(ProcessHandle, address, source);
81
public bool WriteMemory<T>(nint address, T source) where T : struct => WriteMemory(ProcessHandler, address, source);
86
82
/// <summary>
87
83
/// 解析基址对应的实际地址
88
84
/// </summary>
@@ -90,7 +86,7 @@ public partial class MemoryEditor : MemoryListenerManagerBase, IDisposable
90
86
/// <param name="baseAddress">基址的地址部分</param>
91
87
/// <param name="offsets">基址的偏移组</param>
92
88
/// <returns>实际地址</returns>
93
public nint ResolvePointerAddress(string moduleName, int baseAddress, params nint[] offsets) => CurrentProcess is null ? default : ResolvePointerAddress(CurrentProcess, moduleName, baseAddress, ProcessBiteType, offsets);
89
public nint ResolvePointerAddress(string moduleName, nint baseAddress, params nint[] offsets) => CurrentProcess is null ? default : ResolvePointerAddress(CurrentProcess, moduleName, baseAddress, ProcessBiteType, offsets);
94
90
/// <summary>
95
91
/// 解析基址对应的实际地址
96
92
/// </summary>
@@ -126,8 +122,7 @@ public partial class MemoryEditor : MemoryListenerManagerBase, IDisposable
126
122
/// </summary>
127
123
/// <param name="process">进程</param>
128
124
/// <param name="processType">进程位数类型（32/64）</param>
129
/// <param name="processAccessFlags">进程访问权限</param>
130
public MemoryEditor(Process process, ProcessType processType = ProcessType.Bit64, ProcessAccessFlags processAccessFlags = ProcessAccessFlags.All)
125
public MemoryEditor(Process process, ProcessType processType = ProcessType.Bit64)
131
126
{
132
127
CurrentProcess = process;
133
128
ProcessBiteType = processType;
@@ -140,8 +135,7 @@ public partial class MemoryEditor : MemoryListenerManagerBase, IDisposable
140
135
/// </summary>
141
136
/// <param name="processName">进程名称</param>
142
137
/// <param name="processType">进程位数类型（32/64）</param>
143
/// <param name="processAccessFlags">进程访问权限</param>
144
public MemoryEditor(string processName, ProcessType processType = ProcessType.Bit64, ProcessAccessFlags processAccessFlags = ProcessAccessFlags.All)
138
public MemoryEditor(string processName, ProcessType processType = ProcessType.Bit64)
145
139
{
146
140
CurrentProcess = Process.GetProcessesByName(processName).First();
147
141
ProcessBiteType = processType;
@@ -154,8 +148,7 @@ public partial class MemoryEditor : MemoryListenerManagerBase, IDisposable
154
148
/// </summary>
155
149
/// <param name="processId">进程PID</param>
156
150
/// <param name="processType">进程位数类型（32/64）</param>
157
/// <param name="processAccessFlags">进程访问权限</param>
158
public MemoryEditor(int processId, ProcessType processType = ProcessType.Bit64, ProcessAccessFlags processAccessFlags = ProcessAccessFlags.All)
151
public MemoryEditor(int processId, ProcessType processType = ProcessType.Bit64)
159
152
{
160
153
CurrentProcess = Process.GetProcessById(processId);
161
154
ProcessBiteType = processType;
@@ -277,7 +270,7 @@ public partial class MemoryEditor : MemoryListenerManagerBase, IDisposable
277
270
/// <param name="processType">目标进程类型</param>
278
271
/// <param name="offsets">基址的偏移组</param>
279
272
/// <returns>实际地址</returns>
280
public static nint ResolvePointerAddress(Process process, string moduleName, int baseAddress, ProcessType processType, params nint[] offsets) => ResolvePointerAddress(process, GetModuleBaseAddress(process, moduleName), baseAddress, processType, offsets);
273
public static nint ResolvePointerAddress(Process process, string moduleName, nint baseAddress, ProcessType processType, params nint[] offsets) => ResolvePointerAddress(process, GetModuleBaseAddress(process, moduleName), baseAddress, processType, offsets);
281
274
/// <summary>
282
275
/// 解析基址对应的实际地址
283
276
/// </summary>
@@ -287,9 +280,9 @@ public partial class MemoryEditor : MemoryListenerManagerBase, IDisposable
287
280
/// <param name="processType">目标进程类型</param>
288
281
/// <param name="offsets">基址的偏移组</param>
289
282
/// <returns>实际地址</returns>
290
public static nint ResolvePointerAddress(Process process, nint moduleBaseAddress, int baseAddress, ProcessType processType, params nint[] offsets)
283
public static nint ResolvePointerAddress(Process process, nint moduleBaseAddress, nint baseAddress, ProcessType processType, params nint[] offsets)
291
284
{
292
var resolvedAddress = nint.Add(moduleBaseAddress, baseAddress);
285
var resolvedAddress = moduleBaseAddress + baseAddress;
293
286
if (processType == ProcessType.Bit32)
294
287
{
295
288
foreach (nint offset in offsets)