using System.Net.Http;
using System.Text.Json.Nodes;
using Dpz.Core.Public.Entity.Steam;
using Dpz.Core.Public.ViewModel.Response.Steam;
using Microsoft.AspNetCore.WebUtilities;
namespace Dpz.Core.Service.RepositoryServiceImpl;
public class SteamGameService(
IRepository<SteamGame> repository,
IMapper mapper,
HttpClient httpClient,
IConfiguration configuration,
ILogger<SteamGameService> logger,
IFusionCache fusionCache
) : AbstractCacheService(fusionCache), ISteamGameService
{
protected override TimeSpan CacheDefaultExpiration => TimeSpan.FromDays(1);
private record SteamConfig(string AppKey = "", string SteamId = "");
private record CdnConfig
{
public string BaseUrl { get; init; } = "https://cdn.dpangzi.com";
public string LogoUrlTemplate { get; init; } =
"https://shared.akamai.steamstatic.com/store_item_assets/steam/apps/{0}/header.jpg";
}
private readonly SteamConfig _steamConfig =
configuration.GetSection("Steam").Get<SteamConfig>()
?? throw new InvalidConfigurationException(
"Steam 配置缺失：请检查 AppKey 和 SteamId 是否配置。"
);
private readonly CdnConfig _cdnConfig =
configuration.GetSection("Cdn").Get<CdnConfig>() ?? new CdnConfig();
private readonly Lazy<List<int>> _filterIgnoreGameIds = new(() =>
configuration.GetSection("Steam:IgnoreFilterIds").Get<List<int>>() ?? []
);
// API请求延迟时间，防止请求过于频繁
private const int ApiDelayMs = 500;
/// <summary>
/// 当前实例ID，用于区分不同的实例
/// </summary>
private readonly Lazy<string> _instanceId = new(() => Guid.NewGuid().ToString("D"));
private readonly IFusionCache _fusionCache = fusionCache;
/// <summary>
/// 当前实例ID的缓存键
/// </summary>
private const string RunningInstanceIdKey = "SteamGameService.Running.InstanceId";
public event LogoDownload? OnLogoDownloadComplete;
public event AchievementIconGrayDownload? OnAchievementIconGrayDownloadComplete;
public event AchievementIconDownload? OnAchievementIconDownloadComplete;
public async Task UpdateGamesAsync(CancellationToken cancellationToken = default)
{
var runningInstanceId = await _fusionCache.TryGetAsync<string>(
RunningInstanceIdKey,
token: cancellationToken
);
if (runningInstanceId.HasValue && runningInstanceId.Value != _instanceId.Value)
{
logger.LogInformation(
"当前已有实例正在运行，跳过此次更新，实例ID：{RunningInstanceId}，当前实例ID：{CurrentInstanceId}",
runningInstanceId.Value,
_instanceId.Value
);
return;
}
await _fusionCache.SetAsync(
RunningInstanceIdKey,
_instanceId.Value,
TimeSpan.FromHours(3),
token: cancellationToken
);
try
{
logger.LogInformation("开始更新Steam游戏数据，实例ID：{InstanceId}", _instanceId.Value);
var dbGames = await repository.SearchFor(x => true).ToListAsync(cancellationToken);
var games = await FetchGamesAsync(dbGames, cancellationToken);
// 安全检查：如果获取到空列表，直接返回，避免误删数据
if (games.Count == 0)
{
logger.LogWarning("获取到的Steam游戏数量为0，跳过此次更新以防止误删数据");
return;
}
// 新增游戏
var newGames = games.ExceptBy(dbGames.Select(x => x.Id), x => x.Id).ToList();
if (newGames.Count > 0)
{
logger.LogInformation("发现{Count}个新游戏，准备添加", newGames.Count);
await repository.InsertAsync(newGames, cancellationToken);
// var batchSize =
// newGames.Count % 10 > 0 ? newGames.Count / 10 + 1 : newGames.Count / 10;
//
// for (var i = 0; i < batchSize; i++)
// {
// var startIndex = i * 10;
// var count = Math.Min(10, newGames.Count - startIndex);
// var batch = newGames.GetRange(startIndex, count);
// logger.LogInformation(
// "批量添加游戏，开始索引：{StartIndex}，数量：{Count}",
// startIndex,
// count
// );
// await repository.InsertAsync(batch);
// await Task.Delay(1000);
// }
}
// DB已有游戏，待更新
var updateGames = games.IntersectBy(dbGames.Select(x => x.Id), x => x.Id).ToList();
if (updateGames.Count > 0)
{
logger.LogInformation("开始更新{Count}个已有游戏", updateGames.Count);
await Parallel.ForEachAsync(
updateGames,
cancellationToken,
async (game, _) => await UpdateGameAsync(dbGames, game)
);
}
// 删除已删除的游戏
var deletedGames = dbGames.ExceptBy(games.Select(x => x.Id), x => x.Id).ToList();
if (deletedGames.Count > 0)
{
logger.LogInformation("发现{Count}个已删除游戏，准备删除", deletedGames.Count);
var filter = Builders<SteamGame>.Filter.In(
x => x.Id,
deletedGames.Select(x => x.Id)
);
await repository.DeleteAsync(filter, cancellationToken);
}
await OnRemoveByPrefixAfterAsync(cancellationToken);
logger.LogInformation(
"Steam游戏数据更新完成，新增：{NewCount}，更新：{UpdateCount}，删除：{DeletedCount}，实例ID：{InstanceId}",
newGames.Count,
updateGames.Count,
deletedGames.Count,
_instanceId.Value
);
}
catch (Exception ex)
{
logger.LogError(
ex,
"更新Steam游戏数据时发生异常，实例ID：{InstanceId}",
_instanceId.Value
);
throw;
}
finally
{
// 确保在任何情况下都释放锁
try
{
await _fusionCache.RemoveAsync(RunningInstanceIdKey, token: cancellationToken);
logger.LogDebug("已释放Steam游戏更新锁，实例ID：{InstanceId}", _instanceId.Value);
}
catch (Exception ex)
{
logger.LogError(
ex,
"释放Steam游戏更新锁时发生异常，实例ID：{InstanceId}",
_instanceId.Value
);
}
}
}
private async Task UpdateGameAsync(List<SteamGame> dbGames, SteamGame updateGame)
{
var dbGame = dbGames.Find(x => x.Id == updateGame.Id);
if (dbGame != null)
{
var dic = dbGame.UpdateContent(updateGame);
if (dic.Count > 0)
{
logger.LogInformation(
"更新游戏 {GameId}/{GameName} 的数据，更新细节：{@UpdateContent}",
updateGame.Id,
updateGame.Name,
dic
);
}
}
await repository.UpdateAsync(updateGame);
}
private async Task<List<AchievementDetail>> FetchAchievementsAsync(
int id,
List<SteamGame> dbGames,
CancellationToken cancellationToken = default
)
{
var queryString = new Dictionary<string, string?>
{
{ "steamid", _steamConfig.SteamId },
{ "key", _steamConfig.AppKey },
{ "format", "json" },
{ "appid", id.ToString() },
{ "l", "schinese" },
};
// 添加API请求延迟
await Task.Delay(ApiDelayMs, cancellationToken);
logger.LogDebug("获取游戏 {GameId} 的成就数据", id);
var achievements =
await ExecuteHttpRequestAsync<List<AchievementDetail>>(
"/ISteamUserStats/GetSchemaForGame/v2/",
queryString,
root => root?["game"]?["availableGameStats"]?["achievements"]
) ?? [];
var unlockAchievements = await FetchUnlockAchievementAsync(queryString);
#if DEBUG
var options = new ParallelOptions { MaxDegreeOfParallelism = 1 };
#endif
await Parallel.ForEachAsync(
achievements,
#if DEBUG
options,
#endif
async (achievement, _) =>
{
if (
achievement.Name != null
&& unlockAchievements.TryGetValue(achievement.Name, out var unlockTime)
&& unlockTime > 0
)
{
achievement.UnlockTime = unlockTime.ToDateTime();
}
await DownloadAchievementAsync(dbGames, id, achievement);
await DownloadAchievementGrayAsync(dbGames, id, achievement);
}
);
logger.LogDebug("游戏 {GameId} 共获取到 {Count} 个成就", id, achievements.Count);
return achievements;
}
private async Task<Dictionary<string, long>> FetchUnlockAchievementAsync(
Dictionary<string, string?> queryString
)
{
logger.LogDebug("获取已解锁的成就数据");
// 添加API请求延迟
await Task.Delay(ApiDelayMs);
return await ExecuteHttpRequestAsync<Dictionary<string, long>>(
"/ISteamUserStats/GetPlayerAchievements/v0001/",
queryString,
root =>
{
var achievements = root
?["playerstats"]?["achievements"]?.AsArray()
.Select(x =>
{
var name = x?["apiname"]?.GetValue<string>();
if (name == null)
{
logger.LogError(
"Achievement name is null for {SteamId}",
_steamConfig.SteamId
);
return (KeyValuePair<string, long>?)null;
}
var unlockTime = x?["unlocktime"]?.GetValue<long>() ?? 0;
return x?["achieved"]?.GetValue<int>() == 1
? KeyValuePair.Create(name, unlockTime)
: KeyValuePair.Create(name, 0L);
})
.Where(x => x != null)
.Select(x => x!.Value)
.ToDictionary(x => x.Key, x => x.Value);
return JsonValue.Create(achievements);
}
) ?? [];
}
private async Task<List<SteamGame>> FetchGamesAsync(
List<SteamGame> dbGames,
CancellationToken cancellationToken = default
)
{
logger.LogInformation("开始获取Steam游戏列表");
var games = await ApplicationTools.RetryAsync(
async () =>
{
var queryString = new Dictionary<string, string?>
{
{ "steamid", _steamConfig.SteamId },
{ "key", _steamConfig.AppKey },
{ "include_appinfo", "1" },
{ "format", "json" },
};
// 添加API请求延迟
await Task.Delay(ApiDelayMs, cancellationToken);
var result = await ExecuteHttpRequestAsync<List<SteamGame>>(
"/IPlayerService/GetOwnedGames/v0001/",
queryString,
root => root?["response"]?["games"]?.AsArray()
);
// 如果返回null，抛出异常以触发重试
if (result == null)
{
throw new InvalidOperationException("Steam API返回null，触发重试");
}
return result
// 已失效的游戏，导致后续请求图标、成就失败
// 不知道为什么steam不移除它
// 屏蔽
//.Where(x => x.Id != 692850)
.Where(x => !_filterIgnoreGameIds.Value.Contains(x.Id))
.ToList();
},
retryInterval: TimeSpan.FromMilliseconds(ApiDelayMs),
maxAttemptCount: 3,
specificExceptionTypes: [typeof(JsonException)] // JSON错误不重试
);
logger.LogInformation("获取到 {Count} 个Steam游戏", games.Count);
#if DEBUG
var options = new ParallelOptions { MaxDegreeOfParallelism = 1 };
#endif
await Parallel.ForEachAsync(
games,
#if DEBUG
options,
#endif
async (game, ct) => await UpdateGame(dbGames, game, ct)
);
return games;
}
private async Task UpdateGame(
List<SteamGame> dbGames,
SteamGame game,
CancellationToken cancellationToken = default
)
{
logger.LogDebug("更新游戏 {GameId}/{GameName} 的基本信息", game.Id, game.Name);
var achievements = await FetchAchievementsAsync(game.Id, dbGames, cancellationToken);
var originGame = dbGames.Find(x => x.Id == game.Id);
if (achievements is { Count: > 0 })
{
game.Achievements = achievements;
game.LastUpdateTime = DateTime.Now;
}
else if (originGame != null)
{
game.Achievements = originGame.Achievements;
}
else
{
game.Achievements = [];
game.LastUpdateTime = DateTime.Now;
}
if (!AreAssetsDownloaded(originGame))
{
logger.LogDebug("下载游戏 {GameId} 的Logo", game.Id);
// 添加API请求延迟
await Task.Delay(ApiDelayMs, cancellationToken);
await using var stream = await HttpDownloadAsync(
string.Format(_cdnConfig.LogoUrlTemplate, game.Id)
);
if (stream != null && OnLogoDownloadComplete != null)
{
var url = await OnLogoDownloadComplete(stream, game.Id);
if (!string.IsNullOrWhiteSpace(url))
{
game.ImageLogo = url;
game.ImageIcon = url;
game.LastUpdateTime = DateTime.Now;
}
}
}
else
{
game.ImageLogo = originGame?.ImageLogo;
game.ImageIcon = originGame?.ImageIcon;
logger.LogDebug("游戏 {GameId} Logo 无需更新", game.Id);
}
}
private async Task<Stream?> HttpDownloadAsync(string uri)
{
try
{
var response = await httpClient.GetAsync(uri);
response.EnsureSuccessStatusCode();
var memoryStream = new MemoryStream();
await response.Content.CopyToAsync(memoryStream);
memoryStream.Position = 0;
return memoryStream;
}
catch (Exception e)
{
logger.LogError(e, "Download failed for {Uri}", uri);
return null;
}
}
private bool AreAssetsDownloaded(SteamGame? originGame)
{
return originGame != null
&& originGame.ImageIcon?.StartsWith(
_cdnConfig.BaseUrl,
StringComparison.OrdinalIgnoreCase
) == true
&& originGame.ImageLogo?.StartsWith(
_cdnConfig.BaseUrl,
StringComparison.OrdinalIgnoreCase
) == true;
}
private async Task DownloadAchievementAsync(
List<SteamGame> dbGames,
int id,
AchievementDetail achievement
)
{
var dbAchievement = dbGames
.FirstOrDefault(x => x.Id == id)
?.Achievements.Find(x => x.Name == achievement.Name);
if (
dbAchievement?.Icon?.StartsWith(_cdnConfig.BaseUrl, StringComparison.OrdinalIgnoreCase)
== true
)
{
achievement.Icon = dbAchievement.Icon;
return;
}
if (
string.IsNullOrWhiteSpace(achievement.Icon)
|| string.IsNullOrWhiteSpace(achievement.Name)
)
{
return;
}
logger.LogDebug("下载游戏 {GameId} 成就 {AchievementName} 的图标", id, achievement.Name);
// 添加API请求延迟
await Task.Delay(ApiDelayMs);
await using var icon = await HttpDownloadAsync(achievement.Icon);
var handler = OnAchievementIconDownloadComplete;
if (icon != null && handler != null)
{
var url = await handler.Invoke(icon, id, achievement.Name);
if (!string.IsNullOrWhiteSpace(url))
{
achievement.Icon = url;
}
}
}
private async Task DownloadAchievementGrayAsync(
IEnumerable<SteamGame> dbGames,
int id,
AchievementDetail achievement
)
{
var dbAchievement = dbGames
.FirstOrDefault(x => x.Id == id)
?.Achievements.Find(x => x.Name == achievement.Name);
if (
dbAchievement?.IconGray?.StartsWith(
_cdnConfig.BaseUrl,
StringComparison.OrdinalIgnoreCase
) == true
)
{
achievement.IconGray = dbAchievement.IconGray;
return;
}
if (
string.IsNullOrWhiteSpace(achievement.IconGray)
|| string.IsNullOrWhiteSpace(achievement.Name)
)
{
return;
}
logger.LogDebug(
"下载游戏 {GameId} 成就 {AchievementName} 的灰色图标",
id,
achievement.Name
);
// 添加API请求延迟
await Task.Delay(ApiDelayMs);
await using var icon = await HttpDownloadAsync(achievement.IconGray);
var handler = OnAchievementIconGrayDownloadComplete;
if (icon != null && handler != null)
{
var url = await handler.Invoke(icon, id, achievement.Name);
if (!string.IsNullOrWhiteSpace(url))
{
achievement.IconGray = url;
}
}
}
public async Task<List<SteamGameResponse>> GetGamesAsync(
CancellationToken cancellationToken = default
)
{
return await GetOrSetCacheAsync<List<SteamGameResponse>>(
nameof(GetGamesAsync),
async (_, ct) =>
{
var list = await repository.SearchFor(x => true).ToListAsync(ct);
var result = mapper.Map<List<SteamGameResponse>>(list);
return result;
},
cancellationToken: cancellationToken
);
}
public async Task<SteamGameResponse?> GetGameAsync(
int id,
CancellationToken cancellationToken = default
)
{
return await GetOrSetCacheAsync<SteamGameResponse?>(
nameof(GetGameAsync),
async (_, ct) =>
{
var game = await repository.SearchFor(x => x.Id == id).FirstOrDefaultAsync(ct);
if (game == null)
{
logger.LogWarning("未找到游戏 {GameId} 的信息", id);
return null;
}
var result = mapper.Map<SteamGameResponse>(game);
return result;
},
new { id },
cancellationToken: cancellationToken
);
}
private async Task<T?> ExecuteHttpRequestAsync<T>(
string endpoint,
Dictionary<string, string?> queryParams,
Func<JsonNode?, JsonNode?>? dataSelector = null
)
{
var requestUri = QueryHelpers.AddQueryString(endpoint, queryParams);
var jsonContent = "";
try
{
var response = await httpClient.GetAsync(requestUri);
response.EnsureSuccessStatusCode();
jsonContent = await response.Content.ReadAsStringAsync();
if (string.IsNullOrWhiteSpace(jsonContent))
{
logger.LogWarning("Steam API返回空内容，请求地址：{RequestUri}", requestUri);
return default;
}
var jsonNode = JsonNode.Parse(jsonContent);
if (jsonNode == null)
{
logger.LogWarning(
"Steam API返回的JSON无法解析，请求地址：{RequestUri}，内容：{Content}",
requestUri,
jsonContent
);
return default;
}
var data = dataSelector?.Invoke(jsonNode) ?? jsonNode;
var result = data.Deserialize<T>();
if (result == null)
{
logger.LogWarning(
"Steam API数据反序列化失败，请求地址：{RequestUri}，数据：{Data}",
requestUri,
data.ToString()
);
}
return result;
}
catch (JsonException e)
{
logger.LogError(
e,
"Steam API数据解析失败，请求地址：{RequestUri}，内容：{Content}",
requestUri,
jsonContent
);
return default;
}
catch (Exception e)
{
logger.LogError(e, "Steam API请求失败，请求地址：{RequestUri}", requestUri);
return default;
}
}
}
⚠⚠ 以下内容为AI分析的结果，请根据实际情况进行判断。
这是一个Steam游戏服务类的完整实现，主要负责从Steam API获取游戏数据并进行管理。让我详细解释一下这个代码的结构和功能：
类概述
SteamGameService 是一个依赖注入的服务类，继承自 AbstractCacheService 并实现 ISteamGameService 接口，用于管理Steam游戏数据的获取、存储和更新。
主要功能
1. 配置管理
private record SteamConfig(string AppKey = "", string SteamId = "");
private record CdnConfig { ... }
- SteamConfig: 存储Steam API的密钥和用户ID
- CdnConfig: 配置CDN基础URL和图片模板路径
2. 核心方法
UpdateGamesAsync() - 游戏数据更新
这是核心方法，负责：
- 分布式锁机制: 使用实例ID和缓存确保同时只有一个实例在执行更新
- 数据同步:
- 获取Steam API的游戏列表
- 与数据库现有数据对比
- 新增新游戏、更新已有游戏、删除已删除的游戏
- 安全检查: 如果API返回空列表，跳过更新防止误删数据
FetchGamesAsync() - 获取游戏列表
- 调用Steam API获取用户拥有的游戏
- 过滤掉配置中指定忽略的游戏ID
- 使用重试机制处理API请求失败
FetchAchievementsAsync() - 获取成就数据
- 获取游戏的成就信息
- 获取用户已解锁的成就状态
- 并行下载成就图标（普通和灰度版本）
3. 资源下载功能
- 游戏Logo下载:
UpdateGame()方法中处理 - 成就图标下载: 包括彩色和灰度两种版本
- 缓存机制: 避免重复下载已存在的资源
4. HTTP请求处理
ExecuteHttpRequestAsync<T>() - 通用HTTP请求方法
- 构建查询参数
- 发送HTTP请求
- JSON解析和反序列化
- 错误处理和日志记录
5. 数据访问方法
GetGamesAsync(): 获取所有游戏列表（带缓存）GetGameAsync(): 获取单个游戏信息（带缓存）
设计特点
1. 防止API过频繁调用
private const int ApiDelayMs = 500;
await Task.Delay(ApiDelayMs, cancellationToken);
在每个API调用间添加500ms延迟
2. 并发控制
- 使用实例ID和分布式缓存实现分布式锁
- 防止多个实例同时执行数据更新
3. 错误处理
- 全面的异常处理和日志记录
- API请求失败时的重试机制
- 资源下载失败的优雅降级
4. 性能优化
- 并行处理游戏和成就数据
- 缓存机制减少重复查询
- 条件性资源下载（仅在需要时下载）
5. 事件机制
public event LogoDownload? OnLogoDownloadComplete;
public event AchievementIconGrayDownload? OnAchievementIconGrayDownloadComplete;
public event AchievementIconDownload? OnAchievementIconDownloadComplete;
通过事件通知外部系统处理下载完成的资源
使用场景
这个服务适用于需要：
- 同步Steam游戏库数据
- 管理游戏成就信息
- 下载和缓存游戏相关图片资源
- 提供Steam游戏数据的API接口
整体来说，这是一个设计良好的企业级服务，具有完善的错误处理、缓存机制和并发控制。
评论加载中...