System.InvalidOperationException: Collection was modified; enumeration operation may not execute.
.
.
.
at Program.<>c__DisplayClass8_0.<Method>b__0()

_logger.LogError(ex.Demystify(), "Invalid operation.");

options = new JsonSerializerOptions
{
    Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
    WriteIndented = true
};
jsonString = JsonSerializer.Serialize(weatherForecast, options);

var options = new JsonSerializerOptions
{
    Encoder = JavaScriptEncoder.Create(UnicodeRanges.All)
};

[*.cs]
generated_code = true

<PackageReference Include="SecurityCodeScan" Version="3.5.3">
  <PrivateAssets>all</PrivateAssets>
  <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>

using System;
using System.Data;
using System.Data.Common;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore.Diagnostics;
using Microsoft.Extensions.Logging;

namespace Utils
{
    public class EfExceptionsInterceptor : DbCommandInterceptor
    {
        private readonly ILogger<EfExceptionsInterceptor> _logger;

        public EfExceptionsInterceptor(ILogger<EfExceptionsInterceptor> logger)
        {
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }

        public override void CommandFailed(DbCommand command, CommandErrorEventData eventData)
        {
            logError(command, eventData);
        }

        public override Task CommandFailedAsync(DbCommand command, CommandErrorEventData eventData, CancellationToken cancellationToken = default)
        {
            logError(command, eventData);
            return Task.CompletedTask;
        }

        private void logError(DbCommand command, CommandErrorEventData eventData)
        {
            if (command == null || eventData == null)
            {
                return;
            }

            var ex = eventData.Exception;
            if (ex == null)
            {
                return;
            }

            var sqlData = logSqlAndParameters(command);
            var contextualMessage = $"{sqlData}{Environment.NewLine}OriginalException:{Environment.NewLine}{ex} {Environment.NewLine}";
            _logger.LogError(contextualMessage);
        }

        private static string logSqlAndParameters(DbCommand command)
        {
            // -- Name: [Value] (Type = {}, Direction = {}, IsNullable = {}, Size = {}, Precision = {} Scale = {})
            var builder = new StringBuilder();

            var commandText = command.CommandText ?? "<null>";
            builder.AppendFormat(CultureInfo.InvariantCulture, "{0}Command: {0}{1}", Environment.NewLine, commandText)
                .AppendLine();

            var parameters = command.Parameters.OfType<DbParameter>().ToList();

            if (parameters.Any())
            {
                builder.AppendFormat(CultureInfo.InvariantCulture, "{0}Parameters: ", Environment.NewLine)
                    .AppendLine();
            }

            foreach (var parameter in parameters)
            {
                builder.Append("-- ")
                    .Append(parameter.ParameterName)
                    .Append(": '")
                    .Append((parameter.Value == null || parameter.Value == DBNull.Value) ? "null" : parameter.Value)
                    .Append("' (Type = ")
                    .Append(parameter.DbType);

                if (parameter.Direction != ParameterDirection.Input)
                {
                    builder.Append(", Direction = ").Append(parameter.Direction);
                }

                if (!parameter.IsNullable)
                {
                    builder.Append(", IsNullable = false");
                }

                if (parameter.Size != 0)
                {
                    builder.Append(", Size = ").Append(parameter.Size);
                }

                if (((IDbDataParameter)parameter).Precision != 0)
                {
                    builder.Append(", Precision = ").Append(((IDbDataParameter)parameter).Precision);
                }

                if (((IDbDataParameter)parameter).Scale != 0)
                {
                    builder.Append(", Scale = ").Append(((IDbDataParameter)parameter).Scale);
                }

                builder.Append(')').Append(Environment.NewLine);
            }

            return builder.ToString();
        }
    }
}

services.AddScoped<EfExceptionsInterceptor>();

using static System.FormattableString;


var number = 11;
var text = Invariant($"{number}");

{ "Value": null }

    public class StringJsonConverter : JsonConverter<byte?>
    {
        public override byte? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return reader.TokenType switch
            {
                JsonTokenType.Number => reader.GetByte(),
                JsonTokenType.Null => null,
                JsonTokenType.String =>
                    byte.TryParse(reader.GetString(), NumberStyles.Number, CultureInfo.InvariantCulture, out var parsed) ? parsed : (byte?)null,
                _ => throw new ArgumentOutOfRangeException(nameof(reader), reader.TokenType, "Cannot parse unexpected JSON token type.")
            };
        }

        public override void Write(Utf8JsonWriter writer, byte? value, JsonSerializerOptions options)
        {
            if (value.HasValue)
            {
                writer.WriteNumberValue(value.Value);
            }
            else
            {
                writer.WriteNullValue();
            }
        }
    }