mirror of
https://github.com/modernuo/ModernUO
synced 2026-08-11 22:23:06 -04:00
61e41df00c
## Summary
- **Add a self-referencing `InterpolationHandler` to `ValueStringBuilder`** that writes directly into the builder's buffer — zero intermediate allocation, works with `stackalloc`-backed builders
- **Replace all `System.Text.StringBuilder` usage** across the codebase with `ValueStringBuilder`
- **Convert `ValueStringBuilder.Create()` to `stackalloc`** at 10 sites where output length is provably bounded
- **Convert manual `Dispose()` to `using var`** where possible, and hoist loop-scoped builders outside loops with `Reset()`
- **Convert verbose `Append()` chains to `Append($"...")`** interpolation for readability
- **Add comprehensive documentation** for string handling patterns
## InterpolationHandler Design
`ValueStringBuilder` is a `ref struct`, which creates challenges for C#'s interpolated string handler pattern:
- **`ref` fields to ref structs are not allowed** (CS9050)
- **`[InterpolatedStringHandlerArgument("")]` passes struct receivers by value**, not by ref
- **`ISelfInterpolatedStringHandler` requires boxing** ref structs into interface fields
**Solution: Copy-and-reconcile pattern.** The handler receives a value copy of the builder. The copy shares the same underlying `char` buffer (`Span` points to the same `stackalloc`/pooled memory), so writes go to the original buffer. `Append()` reconciles by `this = handler._builder`, updating `_length` and any buffer references changed by `Grow()`.
This is safe because:
- The game loop is single-threaded — no concurrent access between handler construction and reconciliation
- If `Grow()` occurs in the copy, the original's stale buffer isn't accessed until `Append()` replaces it
- `Dispose()` correctly returns the reconciled buffer to the pool
## Changes by Category
### ValueStringBuilder (`Projects/Server/Buffers/ValueStringBuilder.cs`)
- Added nested `InterpolationHandler` ref struct with copy-and-reconcile pattern
- Added `Append([InterpolatedStringHandlerArgument("")] scoped ref InterpolationHandler)` method
- Removed `RawInterpolatedStringHandler` overloads (new handler replaces them)
- All `AppendFormatted` overloads delegate to existing `Append` methods (no code duplication)
- Alignment support via direct private field access (nested type privilege)
### StringBuilder → ValueStringBuilder (15 files)
Replaced all `new StringBuilder()` with `ValueStringBuilder.Create()` or `stackalloc`:
- ConPVP games: KingOfTheHill, DoubleDom, CTF, BombingRun, TourneyMatch
- ConPVP infrastructure: Tournament, Participant, TourneyParticipant
- ConPVP gumps: ArenaGump, TournamentBracketGump, AcceptTeamGump, ConfirmSignupGump
- Commands: Handlers, Logging, Add
- Other: TownCrier, SpeechLogGump, TestCenter
Key patterns:
- `sb = new StringBuilder()` reassignment → `sb.Reset()`
- `sb.AppendFormat("{0:N0}", value)` → `sb.Append($"{value:N0}")`
- `sb.Append(x).Append(y)` chains → separate statements (VSB returns void)
### Create() → stackalloc (10 files)
Converted heap-allocated builders to stackalloc where output is bounded:
- ClientVersion (32), MapSelection (160), HouseRaffleStone (48)
- HolySense (96), UnholySense (96), ClientVerification (192)
- AcceptTeamGump (64), ConfirmSignupGump (64)
- BaseWeapon (160), BaseArmor (128)
### Loop optimizations (2 files)
Hoisted `ValueStringBuilder` creation outside loops with `Reset()` per iteration:
- TourneyMatch.cs: `using var` inside for loop → stackalloc before loop
- ArenaGump.cs: `Create()` + `Dispose()` per iteration → stackalloc before loop
### Append chain → interpolation (5 files)
Converted multi-line `Append()` chains to `Append($"...")`:
- BountyMessage.cs: title switch (6 cases), paragraph (15→1 Append), description lines, closing
- AcceptTeamGump, ConfirmSignupGump, TournamentBracketGump: tournament type strings
- AdminGump: comment/tag formatting in loops
### Documentation
- `dev-docs/string-handling.md`: Full reference — construction, interpolation, disposal, decision guide
- `dev-docs/claude-skills/modernuo-string-handling.md`: Claude skill with quick reference
- `CLAUDE.md`: Added rule 17 (no StringBuilder), dev-docs table entry, skills table entry
- `dev-docs/code-standards.md`: Updated memory management section
## Test Plan
- [x] `dotnet build` — 0 errors, 0 warnings
- [x] `dotnet test` — 940/940 tests pass
- [x] 28 ValueStringBuilder tests covering all reconciliation scenarios:
- Stackalloc no-grow, stackalloc with grow (→pool transition)
- Heap no-grow, heap with grow, heap double grow
- Pre-existing content with and without grow
- Sequential multiple `Append($"...")` calls
- Mixed plain + interpolated Append
- Empty interpolation, literal-only, format specifiers
- Null string holes, ISpanFormattable types
- Dispose after stackalloc→pool grow
71 lines
3.4 KiB
C#
71 lines
3.4 KiB
C#
/*************************************************************************
|
|
* ModernUO *
|
|
* Copyright 2019-2026 - ModernUO Development Team *
|
|
* Email: hi@modernuo.com *
|
|
* File: ISelfInterpolatedStringHandler.cs *
|
|
* *
|
|
* This program is free software: you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation, either version 3 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
|
|
*************************************************************************/
|
|
|
|
using System;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
namespace Server.Text;
|
|
|
|
public interface ISelfInterpolatedStringHandler
|
|
{
|
|
void Add([InterpolatedStringHandlerArgument("")] ref InterpolatedStringHandler handler);
|
|
void InitializeInterpolation(int literalLength, int formattedCount);
|
|
void AppendLiteral(string value);
|
|
void AppendFormatted<T>(T value);
|
|
void AppendFormatted<T>(T value, string? format);
|
|
void AppendFormatted<T>(T value, int alignment);
|
|
void AppendFormatted<T>(T value, int alignment, string? format);
|
|
void AppendFormatted(ReadOnlySpan<char> value);
|
|
void AppendFormatted(ReadOnlySpan<char> value, int alignment, string? format = null);
|
|
void AppendFormatted(object? value, int alignment = 0, string? format = null);
|
|
void AppendFormatted(string? value);
|
|
void AppendFormatted(string? value, int alignment, string? format = null);
|
|
|
|
[InterpolatedStringHandler]
|
|
ref struct InterpolatedStringHandler
|
|
{
|
|
private ISelfInterpolatedStringHandler _parent;
|
|
|
|
public InterpolatedStringHandler(int literalLength, int formattedCount, ISelfInterpolatedStringHandler parent)
|
|
{
|
|
_parent = parent;
|
|
_parent.InitializeInterpolation(literalLength, formattedCount);
|
|
}
|
|
|
|
public void AppendLiteral(string value) => _parent.AppendLiteral(value);
|
|
|
|
public void AppendFormatted<T>(T value) => _parent.AppendFormatted(value);
|
|
|
|
public void AppendFormatted<T>(T value, string? format) => _parent.AppendFormatted(value, format);
|
|
|
|
public void AppendFormatted<T>(T value, int alignment) => _parent.AppendFormatted(value, alignment);
|
|
|
|
public void AppendFormatted<T>(T value, int alignment, string? format) =>
|
|
_parent.AppendFormatted(value, alignment, format);
|
|
|
|
public void AppendFormatted(ReadOnlySpan<char> value) => _parent.AppendFormatted(value);
|
|
|
|
public void AppendFormatted(ReadOnlySpan<char> value, int alignment, string? format = null) =>
|
|
_parent.AppendFormatted(value, alignment, format);
|
|
|
|
public void AppendFormatted(object? value, int alignment = 0, string? format = null) =>
|
|
_parent.AppendFormatted(value, alignment, format);
|
|
|
|
public void AppendFormatted(string? value) => _parent.AppendFormatted(value);
|
|
|
|
public void AppendFormatted(string? value, int alignment, string? format = null) =>
|
|
_parent.AppendFormatted(value, alignment, format);
|
|
}
|
|
}
|