Эффективная замена строк в потоке

Моя мысль:

1. Прочитайте несколько символов из входного потока и заполните буфер.
2. Найдите old[0] в буфере:
   • Если не найден, выведите весь буфер, затем перейдите к шагу 1.
   • Если они найдены, сравните оставшиеся символы в old:
     • Если найдена полная последовательность old, сначала выведите символы перед позицией old[0], затем выведите new. Вернитесь к шагу 2.
     • Если достигнут конец буфера, сначала выведите символы до позиции old[0], затем переместите оставшиеся символы в начало буфера. Перейдите к шагу 1.
     • Если символ не совпадает, вернитесь к шагу 2 и начните со следующего.

Если у вас есть бесконечный Stream, например NetworkStream, замена строковых токенов «на лету» имела бы большой смысл. Но поскольку вы обрабатываете ограниченный поток, для которого вам нужен полный контент, такая фильтрация не имеет смысла из-за влияния на производительность.

Мой аргумент заключается в том, что вам придется использовать буферизацию. Размер буфера, конечно, ограничивает количество символов, которые вы можете обработать. Предполагая, что вы используете кольцевой буфер или очередь, вам придется удалить один символ, чтобы добавить новый. Это приводит к множеству недостатков по сравнению с обработкой всего контента.

За и против

На этом я останавливаюсь, так как поиск и замена наиболее релевантных затрат на производительность лучше подходят для решения с полным содержанием. Для поиска и замены в реальном времени нам, по сути, придется реализовать наш собственный алгоритм, который должен конкурировать с алгоритмами поиска и замены .NET. Нет проблем, но, учитывая затраченные усилия и конечный вариант использования, я бы не стал тратить на это время.

Эффективным решением может быть реализация пользовательского TextReader, расширенного StreamReader, который работает на основе StringBuilder для поиска и замены символов. Хотя StringBuilder предлагает значительное преимущество в производительности по сравнению с поиском и заменой строк, он не позволяет использовать сложные шаблоны поиска, такие как границы слов. Например, границы слов возможны только в том случае, если шаблон явно включает ограничивающие символы.

Например, замена «int» во входных данных «внутренний int» на «pat» дает «отцовский pat». Если мы хотим заменить только «int» на «internal int», нам придется использовать регулярное выражение. Поскольку регулярное выражение работает только с string, нам приходится платить эффективностью.

В следующем примере реализуется StringReplaceStreamReader, который расширяет TextReader и действует как специализированный StreamReader. Для лучшей производительности токены заменяются после прочтения всего потока.
Для краткости он поддерживает только методы ReadToEndAsync, Read и Peak.
Он поддерживает простой поиск, при котором шаблон поиска просто сопоставляется с входными данными (так называемый простой поиск).
Кроме того, он также поддерживает два варианта поиска и замены по регулярным выражениям для более расширенных сценариев поиска и замены.
Первый вариант основан на наборе пар ключ-значение, а второй вариант использует шаблон регулярного выражения, предоставленный вызывающей стороной.

Поскольку простой поиск включает в себя итерацию записей исходного словаря + несколько проходов (по одному для каждой записи), ожидается, что этот режим поиска будет самым медленным алгоритмом, хотя замена с использованием самого StringBuilder на самом деле выполняется быстрее. В этих обстоятельствах ожидается, что поиск и замена Regex будут значительно быстрее, чем простой поиск и замена с использованием StringBuilder, поскольку он может обрабатывать входные данные за один проход.

Поведение поиска StringReplaceStreamReader настраивается через конструктор.

Пример использования

private Dictionary<string, string> replacementTable;

private async Task ReplaceInStream(Stream sourceStream)
{
  this.replacementTable = new Dictionary<string, string>
  {
    { "private", "internal" },
    { "int", "BUTTON" },
    { "Read", "Not-To-Read" }
  };

  // Search and replace using simple search 
  // (slowest).
  await using var streamReader = new StringReplaceStreamReader(sourceStream, Encoding.Default, this.replacementTable, StringComparison.OrdinalIgnoreCase);
  string text = await streamReader.ReadToEndAsync();

  // Search and replace variant #1 using regex with key-value pairs instead of a regular expression pattern
  // for advanced scenarios (fast)
  await using var streamReader2 = new StringReplaceStreamReader(sourceStream, Encoding.Default, this.replacementTable, SearchMode.Regex);
  string text2 = await streamReader2.ReadToEndAsync();

  // Search and replace variant #2 using regex and regular expression pattern 
  // for advanced scenarios (fast).
  // The matchEvaluator callback actually provides the replcement value for each match.

  // Creates the following regular expression:
  // "\bprivate\b|\bint\b|\bRead\b"
  string searchPattern = this.replacementTable.Keys
    .Select(key => $@"\b{key}\b")
    .Aggregate((current, newValue) => $"{current}|{newValue}");

  await using var streamReader3 = new StringReplaceStreamReader(sourceStream, Encoding.Default, searchPattern, Replace);
  string text3 = await streamReader.ReadToEndAsync();
}


private string Replace(Match match) 
  => this.replacementTable.TryGetValue(match.Value, out string replacement) 
    ? replacement 
    : match.Value;

Выполнение

Режим поиска

public enum SearchMode
{
  Default = 0,
  Simple,
  Regex
}

StringReplaceStreamReader.cs

public class StringReplaceStreamReader : TextReader, IDisposable, IAsyncDisposable
{
  public Stream BaseStream { get; }
  public long Length => this.BaseStream.Length;
  public bool EndOfStream => this.BaseStream.Position == this.BaseStream.Length;

  public SearchMode SearchMode { get; }

  private const int DefaultCapacity = 4096;
  private readonly IDictionary<string, string> stringReplaceTable;
  private readonly StringComparison stringComparison;
  private readonly Encoding encoding;
  private readonly Decoder decoder;
  private readonly MatchEvaluator? matchEvaluator;
  private readonly Regex? regularExpression;
  private readonly byte[] byteBuffer;
  private readonly char[] charBuffer;

  public StringReplaceStreamReader(Stream stream, Encoding encoding, IDictionary<string, string> stringReplaceTable)
    : this(stream, encoding, stringReplaceTable, StringComparison.OrdinalIgnoreCase, SearchMode.Simple)
  {
  }

  public StringReplaceStreamReader(Stream stream, Encoding encoding, IDictionary<string, string> stringReplaceTable, SearchMode searchMode)
    : this(stream, encoding, stringReplaceTable, StringComparison.OrdinalIgnoreCase, searchMode)
  {
  }

  public StringReplaceStreamReader(Stream stream, Encoding encoding, IDictionary<string, string> stringReplaceTable, StringComparison stringComparison)
    : this(stream, encoding, stringReplaceTable, stringComparison, SearchMode.Simple)
  {
  }

  public StringReplaceStreamReader(Stream stream, Encoding encoding, IDictionary<string, string> stringReplaceTable, StringComparison stringComparison, SearchMode searchMode)
  {
    ArgumentNullException.ThrowIfNull(stream, nameof(stream));
    ArgumentNullException.ThrowIfNull(stringReplaceTable, nameof(stringReplaceTable));

    this.BaseStream = stream;
    this.encoding = encoding ?? Encoding.Default;
    this.decoder = this.encoding.GetDecoder();
    this.stringReplaceTable = stringReplaceTable;
    this.stringComparison = stringComparison;
    this.SearchMode = searchMode;
    this.regularExpression = null;
    this.matchEvaluator = ReplaceMatch;

    if (searchMode is SearchMode.Regex)
    {
      RegexOptions regexOptions = CreateDefaultRegexOptions(stringComparison);

      var searchPatternBuilder = new StringBuilder();
      foreach (KeyValuePair<string, string> entry in stringReplaceTable)
      {
        // Creates the following regular expression:
        // "\b[search_key]\b|\b[search_key]\b"
        string pattern = @$"\b{entry.Key}\b";
        searchPatternBuilder.Append(pattern);
        searchPatternBuilder.Append('|');
      }

      string searchPattern = searchPatternBuilder.ToString().TrimEnd('|');
      this.regularExpression = new Regex(searchPattern, regexOptions);
    }

    this.byteBuffer = new byte[StringReplaceStreamReader.DefaultCapacity];
    int charBufferSize = this.encoding.GetMaxCharCount(this.byteBuffer.Length);
    this.charBuffer = new char[charBufferSize];
  }

  public StringReplaceStreamReader(Stream stream, Encoding encoding, string searchAndReplacePattern, MatchEvaluator matchEvaluator)
    : this(stream, encoding, searchAndReplacePattern, matchEvaluator, RegexOptions.None)
  {
  }

  public StringReplaceStreamReader(Stream stream, Encoding encoding, string searchAndReplacePattern, MatchEvaluator matchEvaluator, RegexOptions regexOptions)
  {
    ArgumentNullException.ThrowIfNull(stream, nameof(stream));
    ArgumentNullException.ThrowIfNullOrWhiteSpace(searchAndReplacePattern, nameof(searchAndReplacePattern));
    ArgumentNullException.ThrowIfNull(matchEvaluator, nameof(matchEvaluator));

    this.BaseStream = stream;
    this.encoding = encoding ?? Encoding.Default;
    this.decoder = this.encoding.GetDecoder();
    this.matchEvaluator = matchEvaluator;
    this.SearchMode = SearchMode.Regex;
    this.stringReplaceTable = new Dictionary<string, string>();
    this.stringComparison = StringComparison.OrdinalIgnoreCase;

    if (regexOptions is RegexOptions.None)
    {
      regexOptions = CreateDefaultRegexOptions(stringComparison);
    }
    else if ((regexOptions & RegexOptions.Compiled) == 0)
    {
      regexOptions |= RegexOptions.Compiled;
    }

    this.regularExpression = new Regex(searchAndReplacePattern, regexOptions);
    this.byteBuffer = new byte[StringReplaceStreamReader.DefaultCapacity];
    int charBufferSize = this.encoding.GetMaxCharCount(this.byteBuffer.Length);
    this.charBuffer = new char[charBufferSize];
  }

  public override int Peek()
  {
    int value = Read();
    this.BaseStream.Seek(this.BaseStream.Position - 1, SeekOrigin.Begin);

    return value;
  }

  public override int Read()
    => this.BaseStream.ReadByte();

  public override Task<string> ReadToEndAsync()
    => ReadToEndAsync(CancellationToken.None);

  public override async Task<string> ReadToEndAsync(CancellationToken cancellationToken)
  {
    if (!this.BaseStream.CanRead)
    {
      throw new InvalidOperationException("Source stream is not readable.");
    }

    var textBuilder = new StringBuilder(StringReplaceStreamReader.DefaultCapacity);

    while (!this.EndOfStream)
    {
      cancellationToken.ThrowIfCancellationRequested();

      int bytesRead = await this.BaseStream.ReadAsync(buffer, 0, buffer.Length);
      bool flush = this.EndOfStream;
      int charsRead = this.decoder.GetChars(this.byteBuffer, 0, bytesRead, this.charBuffer, 0, flush);
      textBuilder.Append(charBuffer, 0, charsRead);
    }

    cancellationToken.ThrowIfCancellationRequested();
    SearchAndReplace(textBuilder, cancellationToken, out string result);

    return result;
  }

  public ValueTask DisposeAsync()
    => ((IAsyncDisposable)this.BaseStream).DisposeAsync();

  private void SearchAndReplace(StringBuilder textBuilder, CancellationToken cancellationToken, out string result)
  {
    cancellationToken.ThrowIfCancellationRequested();

    if (this.SearchMode is SearchMode.Simple or SearchMode.Default)
    {
      foreach (KeyValuePair<string, string> entry in this.stringReplaceTable)
      {
        cancellationToken.ThrowIfCancellationRequested();

        textBuilder.Replace(entry.Key, entry.Value);
      }

      result = textBuilder.ToString();
    }
    else if (this.SearchMode is SearchMode.Regex)
    {
      string input = textBuilder.ToString();
      result = this.regularExpression!.Replace(input, this.matchEvaluator!);
    }
    else
    {
      throw new NotImplementedException($"Search mode {this.SearchMode} is not implemented.");
    }
  }

  private string ReplaceMatch(Match match)
    => this.stringReplaceTable.TryGetValue(match.Value, out string replacement)
      ? replacement
      : match.Value;

  private RegexOptions CreateDefaultRegexOptions(StringComparison stringComparison)
  {
    RegexOptions regexOptions = RegexOptions.Multiline | RegexOptions.Compiled;
    if (stringComparison is StringComparison.CurrentCultureIgnoreCase or StringComparison.InvariantCultureIgnoreCase or StringComparison.OrdinalIgnoreCase)
    {
      regexOptions |= RegexOptions.IgnoreCase;
    }

    return regexOptions;
  }
}