Response.cs

using System.IO;
using System.Text;
using System.Text.Json;

namespace Webtech3;
/// <summary>
/// Struct for Response
/// </summary>
public readonly struct Response(HttpListenerResponse response) {
    readonly HttpListenerResponse res = response;
    /// <summary>
    /// Property fot get/set status code
    /// </summary>
    /// <value>Int of status</value>
    public int Status {
        get => res.StatusCode;
        set => res.StatusCode = value;
    }
    /// <summary>
    /// Property for get/set status description
    /// </summary>
    /// <value>String description</value>
    public string Description {
        get => res.StatusDescription;
        set => res.StatusDescription = value;
    }
    /// <summary>
    /// Property for get/set content length
    /// </summary>
    /// <value>Ulong</value>
    public long Length {
        get => res.ContentLength64;
        set => res.ContentLength64 = value;
    }
    /// <summary>
    /// Property for get/set content mime-type
    /// </summary>
    /// <value>String if specified, otherwise - null</value>
    public string? MimeType {
        get => res.ContentType;
        set => res.ContentType = value;
    }
    /// <summary>
    /// Property for get/set content encoding
    /// </summary>
    /// <value>Encoding obj if specified, otherwise - null</value>
    public Encoding? Encoding {
        get => res.ContentEncoding;
        set => res.ContentEncoding = value;
    }
    /// <summary>
    /// Property for getting access to response body
    /// </summary>
    /// <value>Response body as stream</value>
    public Stream Body {
        get => Body;
    }
    /// <summary>
    /// Closes the response (same as send)
    /// </summary>
    public readonly void Send() => res.Close();
    /// <summary>
    /// Async writes string to response and send him
    /// </summary>
    /// <param name="content">String for response</param>
    /// <returns>Task obj</returns>
    public async readonly Task ResponseText(string content) {
        var buffer = Encoding.UTF8.GetBytes(content);
        Length = buffer.Length;
        MimeType = "text/plain";
        Status = HTTP.Statuses.Success.OK;
        using (Stream answer = Body) {
            await answer.WriteAsync(buffer);
            await answer.FlushAsync();
        }
        Send();
    }
    /// <summary>
    /// Async serialize any type obj array to json and write it to response.
    /// Than send him
    /// </summary>
    /// <param name="data">Any type object</param>
    /// <typeparam name="T">Generic type for supporting any type</typeparam>
    /// <returns>Task obj</returns>
    public async readonly Task ResponseJson<T>(params T[] data) {
        using(var answer = Body) {
            await JsonSerializer.SerializeAsync(answer, data);
            await answer.FlushAsync();
        }
        Send();
    }
    /// <summary>
    /// Async serialize any type single obj to json and write it to response.
    /// Than send him
    /// </summary>
    /// <param name="data">Any type object</param>
    /// <typeparam name="T">Generic type for supporting any type</typeparam>
    /// <returns>Task obj</returns>
    public async readonly Task ResponseJson<T>(T data) {
        using(var answer = Body) {
            await JsonSerializer.SerializeAsync(answer, data);
            await answer.FlushAsync();
        }
        Send();
    }
    /// <summary>
    /// Writes response with current error code, description &amp; message.
    /// Sends response.
    /// </summary>
    /// <param name="code">Int code for response.</param>
    /// <param name="desc">String description for status</param>
    /// <param name="mes">String, that writes to response body.
    /// By default is null (than is code &amp; description combination)
    /// </param>
    /// <returns></returns>
    public async readonly Task ResponseError(int code, string desc, string? mes = null) {
        Status = code;
        Description = desc;
        mes ??= $"{code} {desc}";
        using(Stream answer = Body) {
            await answer.WriteAsync(Encoding.UTF8.GetBytes(mes));
            await answer.FlushAsync();
        }
        Send();
    }
    /// <summary>
    /// Async writes file to response and send him
    /// </summary>
    /// <param name="path">Path to file.
    /// If contains ".." - response error 400.
    /// If file isn't exists - response error 404.
    /// </param>
    /// <returns>Task obj</returns>
    public async Task ResponseFile(string path) {
        if(path.Contains("..")) {
            await ResponseError(HTTP.Statuses.Errors.Client.Bad_Request, "Bad request");
            return;
        }
        var info = new FileInfo(path);
        if(info.Exists) {
            Status = HTTP.Statuses.Success.OK;
            var buffer = await File.ReadAllBytesAsync(path);
            Length = buffer.Length;
            MimeType = info.MimeType;
            using (Stream answer = Body) {
                await answer.WriteAsync(buffer);
                await answer.FlushAsync();
            }
            Send();
        } else {
            await ResponseError(HTTP.Statuses.Errors.Client.Not_Found, "Not found", "Requested file wasn't found.");
        }
    }
}