전략 패턴

main.pgy:12: E001: 이름을 찾을 수 없습니다

{
  "file": "main.pgy",
  "line": 12,
  "code": "E001",
  "message": "이름을 찾을 수 없습니다"
}

Report(diagnostic, format, output)
    ├─ human → 사람이 읽을 문자열 생성
    └─ json  → JSON 문자열 생성
                 ↓
              output에 기록

시작 코드 또는 요청 처리 코드
  -> 형식 이름을 검사하고 포매터를 선택
  -> DiagnosticReporter에 포매터를 전달

DiagnosticReporter.Report(diagnostic, output)
  -> IDiagnosticFormatter.Format(diagnostic)
     -> HumanDiagnosticFormatter 또는 JsonDiagnosticFormatter
  -> 반환된 문자열을 output에 기록

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

public sealed record Diagnostic(string File, int Line, string Code, string Message);

public interface IDiagnosticFormatter
{
    string Format(Diagnostic diagnostic);
}

public sealed class HumanDiagnosticFormatter : IDiagnosticFormatter
{
    public string Format(Diagnostic diagnostic) =>
        $"{diagnostic.File}:{diagnostic.Line}: {diagnostic.Code}: {diagnostic.Message}";
}

public sealed class JsonDiagnosticFormatter : IDiagnosticFormatter
{
    public string Format(Diagnostic diagnostic) =>
        JsonSerializer.Serialize(new
        {
            schemaVersion = 1,
            file = diagnostic.File,
            line = diagnostic.Line,
            code = diagnostic.Code,
            message = diagnostic.Message
        });
}

public sealed class DiagnosticReporter
{
    private readonly IDiagnosticFormatter formatter;

    public DiagnosticReporter(IDiagnosticFormatter formatter) =>
        this.formatter = formatter;

    public void Report(Diagnostic diagnostic, TextWriter output) =>
        output.WriteLine(formatter.Format(diagnostic));
}

public static class Program
{
    public static void Main()
    {
        var diagnostic = new Diagnostic(
            "main.pgy", 12, "E001", "이름을 찾을 수 없습니다");

        var human = new DiagnosticReporter(new HumanDiagnosticFormatter());
        var json = new DiagnosticReporter(new JsonDiagnosticFormatter());

        human.Report(diagnostic, Console.Out);
        json.Report(diagnostic, Console.Out);
    }
}

using System;
using System.Text.Json;

var diagnostic = new Diagnostic("main.pgy", 12, "E001", "이름을 찾을 수 없습니다");

string Human(Diagnostic item) =>
    $"{item.File}:{item.Line}: {item.Code}: {item.Message}";

string Json(Diagnostic item) => JsonSerializer.Serialize(new
{
    schemaVersion = 1,
    file = item.File,
    line = item.Line,
    code = item.Code,
    message = item.Message
});

void Report(Diagnostic item, Func<Diagnostic, string> format) =>
    Console.WriteLine(format(item));

Report(diagnostic, Human);
Report(diagnostic, Json);

public sealed record Diagnostic(string File, int Line, string Code, string Message);

using System;
using System.Collections.Generic;
using System.Linq;

var products = new[]
{
    new Product(3, 2000m),
    new Product(2, 1000m),
    new Product(1, 1000m)
};

Func<IEnumerable<Product>, IOrderedEnumerable<Product>> cheapestFirst =
    items => items.OrderBy(item => item.PriceWon).ThenBy(item => item.Id);

Func<IEnumerable<Product>, IOrderedEnumerable<Product>> expensiveFirst =
    items => items.OrderByDescending(item => item.PriceWon).ThenBy(item => item.Id);

void Print(Func<IEnumerable<Product>, IOrderedEnumerable<Product>> order) =>
    Console.WriteLine(string.Join(",", order(products).Select(item => item.Id)));

Print(cheapestFirst);  // 1,2,3
Print(expensiveFirst); // 3,1,2
Console.WriteLine(string.Join(",", products.Select(item => item.Id))); // 3,2,1

public sealed record Product(int Id, decimal PriceWon);

type Product = Readonly<{ id: number; priceWon: number }>;
type ProductComparison = (left: Product, right: Product) => number;

// 비교 함수는 입력을 수정하지 않고 음수, 0, 양수로 순서를 표현한다.
const byPriceAscending: ProductComparison = (left, right) =>
  left.priceWon - right.priceWon || left.id - right.id;

const byPriceDescending: ProductComparison = (left, right) =>
  right.priceWon - left.priceWon || left.id - right.id;

function sortProducts(
  products: readonly Product[],
  compare: ProductComparison,
): Product[] {
  // sort는 배열을 변경하므로 배열을 복사한 뒤 정렬한다.
  // 상품 객체 자체를 깊게 복사하는 것은 아니다.
  return [...products].sort(compare);
}

const products: readonly Product[] = [
  { id: 3, priceWon: 2000 },
  { id: 2, priceWon: 1000 },
  { id: 1, priceWon: 1000 },
];

const cheapFirst = sortProducts(products, byPriceAscending);
const expensiveFirst = sortProducts(products, byPriceDescending);

console.log(cheapFirst.map((product) => product.id)); // [1, 2, 3]
console.log(expensiveFirst.map((product) => product.id)); // [3, 1, 2]
console.log(products.map((product) => product.id)); // [3, 2, 1]

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text.Json;

public sealed class BranchingDiagnosticReporter
{
    public void Report(Diagnostic diagnostic, string format, TextWriter output)
    {
        ArgumentNullException.ThrowIfNull(diagnostic);
        ArgumentNullException.ThrowIfNull(format);
        ArgumentNullException.ThrowIfNull(output);

        string rendered;
        switch (format)
        {
            case "human":
                var line = diagnostic.Line.ToString(CultureInfo.InvariantCulture);
                var message = diagnostic.Message.Replace("\r", "\\r").Replace("\n", "\\n");
                rendered = $"{diagnostic.File}:{line}: {diagnostic.Code}: {message}";
                break;
            case "json":
                rendered = JsonSerializer.Serialize(new
                {
                    schemaVersion = 1,
                    file = diagnostic.File,
                    line = diagnostic.Line,
                    code = diagnostic.Code,
                    message = diagnostic.Message
                });
                break;
            default:
                throw new ArgumentException("지원하지 않는 출력 형식입니다.", nameof(format));
        }

        output.WriteLine(rendered);
    }
}

public sealed class Diagnostic
{
    public string File { get; }
    public int Line { get; }
    public string Code { get; }
    public string Message { get; }

    public Diagnostic(string file, int line, string code, string message)
    {
        File = RequireSingleLine(file, nameof(file));
        Code = RequireSingleLine(code, nameof(code));

        if (line <= 0)
            throw new ArgumentOutOfRangeException(nameof(line));
        if (string.IsNullOrWhiteSpace(message))
            throw new ArgumentException("진단 메시지가 필요합니다.", nameof(message));

        Line = line;
        Message = message;
    }

    private static string RequireSingleLine(string value, string parameterName)
    {
        if (string.IsNullOrWhiteSpace(value) || value.Contains('\r') || value.Contains('\n'))
            throw new ArgumentException("비어 있지 않은 한 줄 값이 필요합니다.", parameterName);

        return value;
    }
}

public interface IDiagnosticFormatter
{
    // 문자열 변환만 수행한다. 출력이나 입력 변경은 하지 않는다.
    // 같은 입력과 고정된 설정에는 같은 결과를 반환한다.
    // 반환값은 비어 있지 않아야 하며 실제 CR/LF를 포함하지 않는다.
    string Format(Diagnostic diagnostic);
}

public sealed class HumanDiagnosticFormatter : IDiagnosticFormatter
{
    public string Format(Diagnostic diagnostic)
    {
        ArgumentNullException.ThrowIfNull(diagnostic);

        var line = diagnostic.Line.ToString(CultureInfo.InvariantCulture);
        var message = diagnostic.Message
            .Replace("\r", "\\r")
            .Replace("\n", "\\n");

        return $"{diagnostic.File}:{line}: {diagnostic.Code}: {message}";
    }
}

public sealed class JsonDiagnosticFormatter : IDiagnosticFormatter
{
    public string Format(Diagnostic diagnostic)
    {
        ArgumentNullException.ThrowIfNull(diagnostic);

        // JSON 문자열을 직접 이어 붙이지 않는다.
        // 따옴표와 줄바꿈의 이스케이프는 직렬화기에 맡긴다.
        return JsonSerializer.Serialize(new
        {
            schemaVersion = 1,
            file = diagnostic.File,
            line = diagnostic.Line,
            code = diagnostic.Code,
            message = diagnostic.Message
        });
    }
}

public sealed class DiagnosticReporter
{
    private readonly IDiagnosticFormatter formatter;

    public DiagnosticReporter(IDiagnosticFormatter formatter)
    {
        ArgumentNullException.ThrowIfNull(formatter);
        this.formatter = formatter;
    }

    public void Report(Diagnostic diagnostic, TextWriter output)
    {
        ArgumentNullException.ThrowIfNull(diagnostic);
        ArgumentNullException.ThrowIfNull(output);

        var rendered = formatter.Format(diagnostic);

        // 인터페이스 구현만으로는 행동 계약을 강제할 수 없다.
        // 본체가 즉시 확인할 수 있는 출력 형태를 검사한다.
        if (string.IsNullOrEmpty(rendered) || rendered.Contains('\r') || rendered.Contains('\n'))
            throw new InvalidOperationException("포매터가 비어 있지 않은 CR/LF 없는 출력 계약을 어겼습니다.");

        output.WriteLine(rendered);
        // 호출자가 넘긴 writer를 여기서 닫지 않는다.
    }
}

public static class DiagnosticFormatterFactory
{
    public static IDiagnosticFormatter Create(string format)
    {
        ArgumentNullException.ThrowIfNull(format);

        return format switch
        {
            "human" => new HumanDiagnosticFormatter(),
            "json" => new JsonDiagnosticFormatter(),
            _ => throw new ArgumentException(
                "지원하지 않는 출력 형식입니다.", nameof(format))
        };
    }
}

public static class DiagnosticFunctions
{
    public static string Render(Diagnostic diagnostic, Func<Diagnostic, string> format)
    {
        ArgumentNullException.ThrowIfNull(diagnostic);
        ArgumentNullException.ThrowIfNull(format);

        var rendered = format(diagnostic);
        if (string.IsNullOrEmpty(rendered) || rendered.Contains('\r') || rendered.Contains('\n'))
            throw new InvalidOperationException("포매팅 함수가 비어 있지 않은 CR/LF 없는 출력 계약을 어겼습니다.");

        return rendered;
    }

    public static string[] RenderAll(
        IEnumerable<Diagnostic> diagnostics,
        Func<Diagnostic, string> format)
    {
        ArgumentNullException.ThrowIfNull(diagnostics);
        ArgumentNullException.ThrowIfNull(format);

        // Select로 각 진단을 변환하고, ToArray에서 결과를 확정한다.
        return diagnostics.Select(item => Render(item, format)).ToArray();
    }
}

public sealed record CatalogProduct(int Id, decimal PriceWon);

public static class ProductOrdering
{
    public static IOrderedEnumerable<CatalogProduct> CheapestFirst(
        IEnumerable<CatalogProduct> products) =>
        products.OrderBy(product => product.PriceWon).ThenBy(product => product.Id);

    // 같은 규칙을 LINQ 질의 구문으로 표현한 변형이다.
    public static IOrderedEnumerable<CatalogProduct> CheapestFirstQuery(
        IEnumerable<CatalogProduct> products) =>
        from product in products
        orderby product.PriceWon, product.Id
        select product;

    public static IOrderedEnumerable<CatalogProduct> ExpensiveFirst(
        IEnumerable<CatalogProduct> products) =>
        products.OrderByDescending(product => product.PriceWon).ThenBy(product => product.Id);

    public static CatalogProduct[] Sort(
        IEnumerable<CatalogProduct> products,
        Func<IEnumerable<CatalogProduct>, IOrderedEnumerable<CatalogProduct>> order)
    {
        ArgumentNullException.ThrowIfNull(products);
        ArgumentNullException.ThrowIfNull(order);

        // 원본 열거를 한 번 마친 뒤 검증과 정렬에 같은 입력을 사용한다.
        var snapshot = products.ToArray();
        foreach (var product in snapshot)
        {
            ArgumentNullException.ThrowIfNull(product);
            if (product.Id <= 0 || product.PriceWon < 0)
                throw new ArgumentOutOfRangeException(nameof(products), "ID는 양수, 가격은 0 이상이어야 합니다.");
        }

        // 전략은 원소를 추가하거나 누락하지 않고 순서만 바꾼다는 계약이다.
        return order(snapshot).ToArray();
    }

    public static Func<IEnumerable<CatalogProduct>, IOrderedEnumerable<CatalogProduct>>
        PriorityFirst(int productId)
    {
        if (productId <= 0)
            throw new ArgumentOutOfRangeException(nameof(productId));

        // productId는 반환된 함수가 사용할 고정 설정이다.
        return products => products
            .OrderBy(product => product.Id == productId ? 0 : 1)
            .ThenBy(product => product.PriceWon)
            .ThenBy(product => product.Id);
    }
}

type Product = Readonly<{ id: number; priceWon: number }>;
type ProductComparison = (left: Product, right: Product) => number;

// 비교 함수는 입력을 수정하지 않고 음수, 0, 양수로 순서를 표현한다.
const byPriceAscending: ProductComparison = (left, right) =>
  left.priceWon - right.priceWon || left.id - right.id;

const byPriceDescending: ProductComparison = (left, right) =>
  right.priceWon - left.priceWon || left.id - right.id;

function sortProducts(
  products: readonly Product[],
  compare: ProductComparison,
): Product[] {
  for (const product of products) {
    if (!Number.isSafeInteger(product.priceWon) || product.priceWon < 0) {
      throw new RangeError("가격은 0 이상의 안전한 정수여야 합니다.");
    }
    if (!Number.isSafeInteger(product.id) || product.id <= 0) {
      throw new RangeError("ID는 양의 안전한 정수여야 합니다.");
    }
  }

  // sort는 배열을 변경하므로 배열을 복사한 뒤 정렬한다.
  // 상품 객체 자체를 깊게 복사하는 것은 아니다.
  return [...products].sort(compare);
}

const products: readonly Product[] = [
  { id: 3, priceWon: 2000 },
  { id: 2, priceWon: 1000 },
  { id: 1, priceWon: 1000 },
];

const cheapFirst = sortProducts(products, byPriceAscending);
const expensiveFirst = sortProducts(products, byPriceDescending);

console.log(cheapFirst.map((product) => product.id)); // [1, 2, 3]
console.log(expensiveFirst.map((product) => product.id)); // [3, 1, 2]
console.log(products.map((product) => product.id)); // [3, 2, 1]

public static class Program
{
    private static int checks;

    public static void Main()
    {
        var diagnostic = new Diagnostic("main.pgy", 12, "E001", "이름을 찾을 수 없습니다");
        var multiline = new Diagnostic("main.pgy", 12, "E001", "첫 줄\r\n둘째 줄 \"x\"");
        var human = DiagnosticFormatterFactory.Create("human");
        var json = DiagnosticFormatterFactory.Create("json");

        // 전후 모두 같은 진단을 같은 출력 장치에 기록하는 동작이다.
        foreach (var format in new[] { "human", "json" })
        {
            foreach (var item in new[] { diagnostic, multiline })
            {
                using var before = new StringWriter(CultureInfo.InvariantCulture);
                using var after = new StringWriter(CultureInfo.InvariantCulture);
                new BranchingDiagnosticReporter().Report(item, format, before);
                new DiagnosticReporter(DiagnosticFormatterFactory.Create(format)).Report(item, after);
                Equal(before.ToString(), after.ToString());
            }
        }

        Equal("main.pgy:12: E001: 이름을 찾을 수 없습니다", human.Format(diagnostic));
        Equal(true, human is HumanDiagnosticFormatter);
        Equal(true, json is JsonDiagnosticFormatter);

        foreach (var formatter in new[] { human, json })
        {
            var rendered = formatter.Format(multiline);
            Equal(false, string.IsNullOrEmpty(rendered));
            Equal(false, rendered.Contains('\r') || rendered.Contains('\n'));
            Equal(rendered, formatter.Format(multiline));
        }

        using (var parsed = JsonDocument.Parse(json.Format(multiline)))
        {
            var root = parsed.RootElement;
            Equal(1, root.GetProperty("schemaVersion").GetInt32());
            Equal(multiline.File, root.GetProperty("file").GetString());
            Equal(multiline.Line, root.GetProperty("line").GetInt32());
            Equal(multiline.Code, root.GetProperty("code").GetString());
            Equal(multiline.Message, root.GetProperty("message").GetString());
        }

        // 기본 인코더의 표기와 파싱 후의 값을 별도로 확인한다.
        // 이 표기를 모든 JSON 포매터의 공통 계약으로 요구하는 것은 아니다.
        var encodingProbe = new Diagnostic("main.pgy", 1, "E001", "한글<>&'\"");
        using (var parsed = JsonDocument.Parse(json.Format(encodingProbe)))
        {
            var message = parsed.RootElement.GetProperty("message");
            Equal("\"\\uD55C\\uAE00\\u003C\\u003E\\u0026\\u0027\\u0022\"", message.GetRawText());
            Equal(encodingProbe.Message, message.GetString());
        }

        using var output = new StringWriter(CultureInfo.InvariantCulture);
        var reporter = new DiagnosticReporter(human);
        reporter.Report(diagnostic, output);
        // 줄 구분자를 하드코딩하지 않고 이 writer에 설정된 NewLine을 따른다.
        Equal(human.Format(diagnostic) + output.NewLine, output.ToString());
        output.Write("still open"); // 호출자 소유 writer가 열려 있는지 확인한다.
        Equal(true, output.ToString().EndsWith("still open", StringComparison.Ordinal));

        Expect<ArgumentOutOfRangeException>(() => new Diagnostic("main.pgy", 0, "E001", "오류"));
        Expect<ArgumentException>(() => new Diagnostic("main.pgy", 1, "E001", " "));
        Expect<ArgumentException>(() => new Diagnostic("main\n.pgy", 1, "E001", "오류"));
        Expect<ArgumentException>(() => DiagnosticFormatterFactory.Create("jsno"));
        Expect<ArgumentNullException>(() => new DiagnosticReporter(null!));

        using var rejectedOutput = new StringWriter(CultureInfo.InvariantCulture);
        Expect<InvalidOperationException>(() =>
            new DiagnosticReporter(new BrokenFormatter()).Report(diagnostic, rejectedOutput));
        Equal("", rejectedOutput.ToString());

        using var failingOutput = new FailingWriter();
        Expect<IOException>(() => reporter.Report(diagnostic, failingOutput));

        // 메서드 그룹과 람다는 같은 함수 계약으로 전달할 수 있다.
        Func<Diagnostic, string> formatFunction = human.Format;
        Equal(human.Format(diagnostic), DiagnosticFunctions.Render(diagnostic, formatFunction));
        var jsonLines = DiagnosticFunctions.RenderAll(
            new[] { diagnostic, multiline }, item => json.Format(item));
        Equal(2, jsonLines.Length);
        Equal(json.Format(multiline), jsonLines[1]);

        var catalog = new[]
        {
            new CatalogProduct(3, 2000m),
            new CatalogProduct(2, 1000m),
            new CatalogProduct(1, 1000m)
        };
        var cheap = ProductOrdering.Sort(catalog, ProductOrdering.CheapestFirst);
        var cheapQuery = ProductOrdering.Sort(catalog, ProductOrdering.CheapestFirstQuery);
        var expensive = ProductOrdering.Sort(catalog, ProductOrdering.ExpensiveFirst);
        var priority = ProductOrdering.Sort(catalog, ProductOrdering.PriorityFirst(3));
        Equal("1,2,3", string.Join(",", cheap.Select(product => product.Id)));
        Equal("1,2,3", string.Join(",", cheapQuery.Select(product => product.Id)));
        Equal("3,1,2", string.Join(",", expensive.Select(product => product.Id)));
        Equal("3,1,2", string.Join(",", priority.Select(product => product.Id)));
        Equal("3,2,1", string.Join(",", catalog.Select(product => product.Id)));

        Console.WriteLine($"C# checks: {checks}");
    }

    private static void Equal<T>(T expected, T actual)
    {
        if (!System.Collections.Generic.EqualityComparer<T>.Default.Equals(expected, actual))
            throw new Exception($"기댓값: {expected}, 실제값: {actual}");
        checks++;
    }

    private static void Expect<TException>(Action action) where TException : Exception
    {
        try { action(); }
        catch (Exception error)
        {
            // 파생 예외까지 허용하는 catch (TException)과 구별한다.
            if (error.GetType() == typeof(TException)) { checks++; return; }
            throw new InvalidOperationException(
                $"예외 형식 불일치: 기댓값 {typeof(TException).Name}, 실제값 {error.GetType().Name}", error);
        }
        throw new InvalidOperationException($"{typeof(TException).Name} 예외가 필요합니다.");
    }

    private sealed class BrokenFormatter : IDiagnosticFormatter
    {
        public string Format(Diagnostic diagnostic) => "first\nsecond";
    }

    private sealed class FailingWriter : StringWriter
    {
        public override void WriteLine(string? value) =>
            throw new IOException("테스트용 출력 실패");
    }
}