Исправление ошибки 'Stream was already consumed' в Azure Functions с YARP

app.Use(async (context, next) =>
{
    var originalBody = context.Request.Body;
    Log.Information("Поток тела запроса доступен в: {StackTrace}", Environment.StackTrace);
    
    try
    {
        await next();
    }
    finally
    {
        // Сброс позиции потока, если возможно
        if (originalBody.CanSeek)
        {
            originalBody.Position = 0;
        }
    }
});

app.Use(async (context, next) =>
{
    var canRead = context.Request.Body.CanRead;
    var canSeek = context.Request.Body.CanSeek;
    var position = context.Request.Body.Position;
    
    Log.Information("Состояние потока - CanRead: {CanRead}, CanSeek: {CanSeek}, Position: {Position}", 
        canRead, canSeek, position);
    
    await next();
});

app.Use(async (context, next) =>
{
    // Клонируем тело запроса
    var clonedBody = await CloneRequestBody(context.Request.Body);
    
    // Заменяем исходное тело на клон
    context.Request.Body = clonedBody;
    
    await next();
});

async Task<Stream> CloneRequestBody(Stream originalBody)
{
    var memoryStream = new MemoryStream();
    await originalBody.CopyToAsync(memoryStream);
    memoryStream.Position = 0;
    return memoryStream;
}

public class StreamBufferingMiddleware
{
    private readonly RequestDelegate _next;

    public StreamBufferingMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        // Буферизуем только POST/PUT запросы с содержимым
        if (context.Request.Method == "POST" || context.Request.Method == "PUT")
        {
            context.Request.EnableBuffering();
            
            // Сохраняем исходную позицию потока
            var originalPosition = context.Request.Body.Position;
            
            try
            {
                await _next(context);
            }
            finally
            {
                // Восстанавливаем исходную позицию
                context.Request.Body.Position = originalPosition;
            }
        }
        else
        {
            await _next(context);
        }
    }
}

app.Use(async (context, next) =>
{
    if (context.Request.Method == "POST")
    {
        var requestBody = await new StreamReader(context.Request.Body).ReadToEndAsync();
        context.Items["RequestBody"] = requestBody;
        
        // Сбрасываем поток для последующего потребления
        context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(requestBody));
        context.Request.Body.Position = 0;
    }
    
    await next();
});

// В вашей функции Azure
public class CreateLessonPlan
{
    [Function("CreateLessonPlan")]
    public HttpResponseData Run([HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
    {
        var requestBody = req.HttpContext.Items["RequestBody"]?.ToString();
        // Используем сохраненное тело запроса
    }
}

services.AddReverseProxy()
    .LoadFromConfig(Configuration.GetSection("ReverseProxy"))
    .AddTransforms(transformBuilderContext =>
    {
        transformBuilderContext.RequestTransforms.Add(transformContext =>
        {
            // Убеждаемся, что тело запроса доступно для проксирования
            if (transformContext.ProxyRequest.Content != null)
            {
                transformContext.ProxyRequest.Content = new StreamCopyHttpContent(transformContext.HttpContext.Request.Body);
            }
            return ValueTask.CompletedTask;
        });
    });

public class ReusableStream : Stream
{
    private readonly Stream _originalStream;
    private readonly MemoryStream _buffer;
    private bool _buffered = false;

    public ReusableStream(Stream originalStream)
    {
        _originalStream = originalStream;
        _buffer = new MemoryStream();
    }

    public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
    {
        if (!_buffered)
        {
            _buffered = true;
            await _originalStream.CopyToAsync(_buffer);
            _buffer.Position = 0;
        }

        return await _buffer.ReadAsync(buffer, offset, count, cancellationToken);
    }

    // Реализуйте другие методы Stream...
}

public class SafeStreamMiddleware
{
    private readonly RequestDelegate _next;

    public SafeStreamMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task Invoke(HttpContext context)
    {
        // Обрабатываем только POST/PUT запросы с JSON-содержимым
        if (ShouldBufferRequest(context))
        {
            await BufferAndProcessRequest(context);
        }
        else
        {
            await _next(context);
        }
    }

    private bool ShouldBufferRequest(HttpContext context)
    {
        return (context.Request.Method == "POST" || context.Request.Method == "PUT") &&
               context.Request.ContentType?.Contains("application/json") == true;
    }

    private async Task BufferAndProcessRequest(HttpContext context)
    {
        // Включаем буферизацию
        context.Request.EnableBuffering();
        
        // Читаем тело
        var requestBody = await new StreamReader(context.Request.Body).ReadToEndAsync();
        
        // Сохраняем в элементах контекста
        context.Items["RequestBody"] = requestBody;
        
        // Сбрасываем позицию потока
        context.Request.Body.Position = 0;
        
        try
        {
            await _next(context);
        }
        catch
        {
            // Очищаем ресурсы
            context.Request.Body.Dispose();
            throw;
        }
    }
}

// Регистрация в Program.cs
app.UseMiddleware<SafeStreamMiddleware>();

public class CreateLessonPlan
{
    [Function("CreateLessonPlan")]
    public HttpResponseData Run(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
    {
        try
        {
            // Получаем тело запроса из элементов контекста (установлено промежуточным ПО)
            var requestBody = req.HttpContext.Items["RequestBody"]?.ToString();
            
            if (string.IsNullOrEmpty(requestBody))
            {
                // Запасной вариант: чтение напрямую, если промежуточное ПО не выполнялось
                requestBody = new StreamReader(req.Body).ReadToEnd();
            }

            var lessonPlan = JsonSerializer.Deserialize<LessonPlan>(requestBody);
            
            // Обрабатываем план урока
            var result = ProcessLessonPlan(lessonPlan);
            
            var response = req.CreateResponse(HttpStatusCode.OK);
            response.Headers.Add("Content-Type", "application/json; charset=utf-8");
            response.WriteString(JsonSerializer.Serialize(result));
            
            return response;
        }
        catch (Exception ex)
        {
            var response = req.CreateResponse(HttpStatusCode.InternalServerError);
            response.WriteString($"Ошибка обработки плана урока: {ex.Message}");
            return response;
        }
    }

    private LessonPlanResult ProcessLessonPlan(LessonPlan plan)
    {
        // Ваша бизнес-логика здесь
        return new LessonPlanResult { 
            Id = Guid.NewGuid(),
            Success = true,
            Message = "План урока успешно создан"
        };
    }
}

public class LessonPlan
{
    public int SubjectId { get; set; }
    public string TeacherId { get; set; }
    public string School { get; set; }
    public string Class { get; set; }
    public string LessonTitle { get; set; }
    public string Time { get; set; }
}

public class LessonPlanResult
{
    public Guid Id { get; set; }
    public bool Success { get; set; }
    public string Message { get; set; }
}

{
  "ReverseProxy": {
    "Routes": {
      "lessonplan-route": {
        "ClusterId": "lessonplan-cluster",
        "Match": {
          "Path": "/api/lessonplans",
          "Methods": ["POST"]
        },
        "Transforms": [
          { "RequestHeaderRemove": "Content-Length" },
          { "RequestHeaderRemove": "Transfer-Encoding" }
        ]
      }
    },
    "Clusters": {
      "lessonplan-cluster": {
        "Destinations": {
          "destination1": {
            "Address": "https://localhost:7071/"
          }
        }
      }
    }
  }
}