StateParserFactory.cs
7.73 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
using System.Collections.Concurrent;
using System.Reflection;
using System.Text.Json;
using Microsoft.Extensions.Logging;
using Rcs.Domain.Extensions;
using Rcs.Domain.Models.VDA5050;
namespace Rcs.Infrastructure.Mqtt.ParseFactory
{
/// <summary>
/// 状态解析器工厂实现
/// </summary>
public class StateParserFactory : IStateParserFactory
{
private readonly ILogger<StateParserFactory> _logger;
private readonly ConcurrentDictionary<string, Func<string, State?>> _parsers;
public StateParserFactory(ILogger<StateParserFactory> logger)
{
_logger = logger;
_parsers = new ConcurrentDictionary<string, Func<string, State?>>(StringComparer.OrdinalIgnoreCase);
// 注册默认支持的制造商解析器
RegisterDefaultParsers();
}
/// <summary>
/// 按制造商名称解析状态信息
/// </summary>
public State? ParseState(string manufacturer, string payload)
{
try
{
if (string.IsNullOrWhiteSpace(manufacturer))
{
_logger.LogWarning("制造商为空，使用默认VDA5050状态解析器");
return ParseDefaultState(payload);
}
if (_parsers.TryGetValue(manufacturer, out var parser))
{
return parser(payload);
}
else
{
_logger.LogInformation("未找到制造商 '{Manufacturer}' 的专用解析器，使用默认VDA5050解析器", manufacturer);
return ParseDefaultState(payload);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "解析制造商 '{Manufacturer}' 的状态信息时发生异常", manufacturer);
return null;
}
}
/// <summary>
/// 注册指定制造商的状态解析器
/// </summary>
public void RegisterStateParser(string manufacturer, Func<string, State?> parser)
{
if (string.IsNullOrWhiteSpace(manufacturer))
{
throw new ArgumentException("制造商名不能为空", nameof(manufacturer));
}
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
_parsers.AddOrUpdate(manufacturer, parser, (key, oldValue) => parser);
}
/// <summary>
/// 是否支持指定制造商
/// </summary>
public bool IsManufacturerSupported(string manufacturer)
{
return !string.IsNullOrWhiteSpace(manufacturer) && _parsers.ContainsKey(manufacturer);
}
/// <summary>
/// 获取所有已注册的制造商
/// </summary>
public IEnumerable<string> GetSupportedManufacturers()
{
return _parsers.Keys.ToList();
}
/// <summary>
/// 注册默认解析器 - 自动扫描带有ProtocolInfo属性的State类
/// </summary>
private void RegisterDefaultParsers()
{
try
{
// 获取HaHRCS.Core程序集
var coreAssembly = Assembly.GetAssembly(typeof(State));
if (coreAssembly == null)
{
_logger.LogWarning("无法获取HaHRCS.Core.Models.VDA5050程序集");
return;
}
// 扫描所有带有ProtocolInfo且Topic为"State"的类
var stateTypes = coreAssembly.GetTypes()
.Where(type => type.IsClass && !type.IsAbstract)
//.Where(type => typeof(State).IsAssignableFrom(type))
.Where(type =>
{
var protocolInfo = type.GetCustomAttribute<ProtocolInfoAttribute>();
return protocolInfo != null &&
string.Equals(protocolInfo.Topic, nameof(State), StringComparison.OrdinalIgnoreCase);
})
.ToList();
foreach (var stateType in stateTypes)
{
var protocolInfo = stateType.GetCustomAttribute<ProtocolInfoAttribute>();
if (protocolInfo != null)
{
// 注册解析器
var parser = CreateParserForType(stateType);
RegisterStateParser(protocolInfo.Manufacturer, parser);
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, "自动注册默认解析器时发生异常");
}
}
/// <summary>
/// 为指定类型创建解析器委托
/// </summary>
/// <param name="stateType">State类型</param>
/// <returns>解析器委托</returns>
private Func<string, State?> CreateParserForType(Type stateType)
{
return payload =>
{
try
{
var result = JsonSerializer.Deserialize(payload, stateType);
return result as State;
}
catch (Exception ex)
{
_logger.LogWarning(ex, "解析 {StateType} 类型时发生错误", stateType.Name);
return null;
}
};
}
/// <summary>
/// 解析默认VDA5050状态信息
/// </summary>
private static State? ParseDefaultState(string payload)
{
try
{
return JsonSerializer.Deserialize<State>(payload);
}
catch
{
return null;
}
}
/// <summary>
/// 手动刷新并重新注册解析器
/// </summary>
public void RefreshParsers()
{
_logger.LogInformation("开始手动刷新解析器");
_parsers.Clear();
RegisterDefaultParsers();
}
/// <summary>
/// 自动根据程序集扫描ProtocolInfo属性获取已注册解析器的详细信息
/// </summary>
public Dictionary<string, string> GetRegisteredParsersInfo()
{
var result = new Dictionary<string, string>();
try
{
var coreAssembly = Assembly.GetAssembly(typeof(State));
if (coreAssembly != null)
{
var stateTypes = coreAssembly.GetTypes()
.Where(type => type.IsClass && !type.IsAbstract)
.Where(type => typeof(State).IsAssignableFrom(type))
.Where(type =>
{
var protocolInfo = type.GetCustomAttribute<ProtocolInfoAttribute>();
return protocolInfo != null &&
protocolInfo.Topic.Equals(nameof(State), StringComparison.OrdinalIgnoreCase);
});
foreach (var stateType in stateTypes)
{
var protocolInfo = stateType.GetCustomAttribute<ProtocolInfoAttribute>();
if (protocolInfo != null)
{
result[protocolInfo.Manufacturer] = $"{stateType.Name} (v{protocolInfo.Version})";
}
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, "获取解析器信息时发生异常");
}
return result;
}
}
}