mirror of
https://github.com/JustArchiNET/ArchiSteamFarm
synced 2024-09-20 14:32:05 +00:00
b6805a94a3
This is some next-level race condition, so for those interested: - Concurrent collections are thread-safe in a way that each operation is atomic - Naturally if you call two atomic operations in a row, the result is no longer atomic, since there could be some changes between the first and the last - Certain LINQ operations such as OrderBy(), Reverse(), ToArray(), among more, use internal buffer for operation with certain optimization that checks if input is ICollection, if yes, it calls Count and CopyTo(), for OrderBy in this example - In result, such LINQ call is not guaranteed to be thread-safe, since it assumes those two calls to be atomic, while they're not in reality. This issue is quite hard to spot in real applications, since it's not that easy to trigger it (you need to call the operation on ICollection and then have another thread modifying it while enumerating). This is probably why we've never had any real problem until I've discovered this madness with @Aareksio in entirely different project. As a workaround, we'll explicitly convert some ICollection inputs to IEnumerable, in particular around OrderBy(), so the optimization is skipped and the result is not corrupted. I've added unit tests which ensure this workaround works properly, and you can easily reproduce the problem by removing AsLinqThreadSafeEnumerable() in them. See https://github.com/dotnet/runtime/discussions/50687 for more insight I have no clue who thought that ignoring this issue is a good idea, at the very least concurrent collections should have opt-out mechanism from those optimizations, there is no reason for them to not do that. |
||
|---|---|---|
| .. | ||
| ArchiCryptoHelper.cs | ||
| ArchiSteamFarm.Tests.csproj | ||
| AssemblyInfo.cs | ||
| Bot.cs | ||
| ConcurrentTests.cs | ||
| MobileAuthenticator.cs | ||
| SteamChatMessage.cs | ||
| Trading.cs | ||