public class Money
{
    public decimal Amount { get; }
    public string Currency { get; }

    public Money(decimal amount, string currency)
    {
        Amount = amount;
        Currency = currency ?? throw new ArgumentNullException(nameof(currency));
    }

    // Додавання грошей
    public static Money operator +(Money a, Money b)
    {
        if (a.Currency != b.Currency)
            throw new InvalidOperationException($"Cannot add {a.Currency} and {b.Currency}");

        return new Money(a.Amount + b.Amount, a.Currency);
    }

    // Віднімання грошей
    public static Money operator -(Money a, Money b)
    {
        if (a.Currency != b.Currency)
            throw new InvalidOperationException($"Cannot subtract {a.Currency} and {b.Currency}");

        return new Money(a.Amount - b.Amount, a.Currency);
    }

    // Множення на коефіцієнт
    public static Money operator *(Money money, decimal multiplier)
    {
        return new Money(money.Amount * multiplier, money.Currency);
    }

    // Ділення на коефіцієнт
    public static Money operator /(Money money, decimal divisor)
    {
        if (divisor == 0)
            throw new DivideByZeroException();

        return new Money(money.Amount / divisor, money.Currency);
    }

    public override string ToString() => $"{Amount:C} {Currency}";
}

// Використання
Money price = new Money(100, "UAH");
Money discount = new Money(20, "UAH");
Money finalPrice = price - discount; // 80 UAH

Money doubled = price * 2;            // 200 UAH
Money half = price / 2;               // 50 UAH

// Money usd = new Money(50, "USD");
// Money invalid = price + usd;       // ❌ Exception: Cannot add UAH and USD

public class Vector : IEquatable<Vector>
{
    public double X { get; }
    public double Y { get; }

    public Vector(double x, double y)
    {
        X = x;
        Y = y;
    }

    // Оператор рівності
    public static bool operator ==(Vector? a, Vector? b)
    {
        if (ReferenceEquals(a, b)) return true;
        if (a is null || b is null) return false;
        return a.X == b.X && a.Y == b.Y;
    }

    // Оператор нерівності (пара для ==)
    public static bool operator !=(Vector? a, Vector? b)
    {
        return !(a == b);
    }

    // Перевизначення Equals для узгодженості
    public override bool Equals(object? obj)
    {
        return Equals(obj as Vector);
    }

    public bool Equals(Vector? other)
    {
        return this == other;
    }

    // Перевизначення GetHashCode
    public override int GetHashCode()
    {
        return HashCode.Combine(X, Y);
    }
}

// Використання
Vector v1 = new Vector(1, 2);
Vector v2 = new Vector(1, 2);
Vector v3 = new Vector(3, 4);

Console.WriteLine(v1 == v2);  // True
Console.WriteLine(v1 != v3);  // True

public class Celsius
{
    public double Temperature { get; }

    public Celsius(double temperature)
    {
        Temperature = temperature;
    }

    // Неявне перетворення: Celsius → double
    public static implicit operator double(Celsius c)
    {
        return c.Temperature;
    }

    // Явне перетворення: double → Celsius
    public static explicit operator Celsius(double temp)
    {
        return new Celsius(temp);
    }

    public override string ToString() => $"{Temperature}°C";
}

public class Fahrenheit
{
    public double Temperature { get; }

    public Fahrenheit(double temperature)
    {
        Temperature = temperature;
    }

    // Явне перетворення: Celsius → Fahrenheit
    public static explicit operator Fahrenheit(Celsius c)
    {
        return new Fahrenheit(c.Temperature * 9 / 5 + 32);
    }

    public override string ToString() => $"{Temperature}°F";
}

// Використання
Celsius celsius = new Celsius(25);

// Неявне перетворення
double temp = celsius;  // ✅ OK, implicit
Console.WriteLine(temp); // 25

// Явне перетворення
Celsius c2 = (Celsius)30.0;  // ✅ OK, explicit cast required
Console.WriteLine(c2); // 30°C

// Перетворення між класами
Fahrenheit fahrenheit = (Fahrenheit)celsius;
Console.WriteLine(fahrenheit); // 77°F

public class Matrix
{
    private double[,] _data;
    public int Rows { get; }
    public int Cols { get; }

    public Matrix(int rows, int cols)
    {
        Rows = rows;
        Cols = cols;
        _data = new double[rows, cols];
    }

    // Індексатор для доступу до елементів
    public double this[int row, int col]
    {
        get
        {
            if (row < 0 || row >= Rows || col < 0 || col >= Cols)
                throw new IndexOutOfRangeException();
            return _data[row, col];
        }
        set
        {
            if (row < 0 || row >= Rows || col < 0 || col >= Cols)
                throw new IndexOutOfRangeException();
            _data[row, col] = value;
        }
    }

    // Додатковий індексатор для лінійного доступу
    public double this[int index]
    {
        get
        {
            int row = index / Cols;
            int col = index % Cols;
            return this[row, col];
        }
        set
        {
            int row = index / Cols;
            int col = index % Cols;
            this[row, col] = value;
        }
    }
}

// Використання
Matrix matrix = new Matrix(3, 3);
matrix[0, 0] = 1.0;  // Використання індексатора
matrix[1, 1] = 2.0;
Console.WriteLine(matrix[0, 0]); // 1.0

// Лінійний доступ
matrix[4] = 5.0;  // Рядок 1, колонка 1
Console.WriteLine(matrix[1, 1]); // 5.0

public class Counter
{
    private int _value;

    public Counter(int initialValue = 0)
    {
        _value = initialValue;
    }

    public int Value => _value;

    // Prefix increment: ++counter
    public static Counter operator ++(Counter c)
    {
        c._value++;
        return c;
    }

    // Prefix decrement: --counter
    public static Counter operator --(Counter c)
    {
        c._value--;
        return c;
    }

    public override string ToString() => _value.ToString();
}

// Використання
Counter counter = new Counter(5);

// Prefix increment
++counter;
Console.WriteLine(counter); // 6

// Postfix також працює (компілятор обробляє автоматично)
counter++;
Console.WriteLine(counter); // 7

--counter;
Console.WriteLine(counter); // 6

public class Result
{
    public bool IsSuccess { get; }
    public string Message { get; }

    public Result(bool isSuccess, string message)
    {
        IsSuccess = isSuccess;
        Message = message;
    }

    // Оператор true
    public static bool operator true(Result r)
    {
        return r.IsSuccess;
    }

    // Оператор false (має бути парою з true)
    public static bool operator false(Result r)
    {
        return !r.IsSuccess;
    }

    // Логічний AND для short-circuit evaluation
    public static Result operator &(Result a, Result b)
    {
        if (!a.IsSuccess) return a;
        if (!b.IsSuccess) return b;
        return new Result(true, $"{a.Message} and {b.Message}");
    }

    // Логічний OR для short-circuit evaluation
    public static Result operator |(Result a, Result b)
    {
        if (a.IsSuccess) return a;
        if (b.IsSuccess) return b;
        return new Result(false, $"{a.Message} or {b.Message}");
    }
}

// Використання
Result CheckAge(int age)
{
    return age >= 18
        ? new Result(true, "Age OK")
        : new Result(false, "Too young");
}

Result CheckLicense(bool hasLicense)
{
    return hasLicense
        ? new Result(true, "License OK")
        : new Result(false, "No license");
}

Result ageCheck = CheckAge(20);
Result licenseCheck = CheckLicense(true);

// Використання в умові!
if (ageCheck && licenseCheck)
{
    Console.WriteLine("Can drive!");
}

// З операторами & та | працює short-circuit
Result combined = ageCheck && licenseCheck;
Console.WriteLine(combined.Message); // "Age OK and License OK"

[Flags]
public enum Permission
{
    None = 0,
    Read = 1,
    Write = 2,
    Execute = 4,
    Delete = 8
}

public class PermissionSet
{
    private Permission _permissions;

    public PermissionSet(Permission permissions)
    {
        _permissions = permissions;
    }

    // Bitwise OR для додавання прав
    public static PermissionSet operator |(PermissionSet a, PermissionSet b)
    {
        return new PermissionSet(a._permissions | b._permissions);
    }

    // Bitwise AND для перевірки спільних прав
    public static PermissionSet operator &(PermissionSet a, PermissionSet b)
    {
        return new PermissionSet(a._permissions & b._permissions);
    }

    // Bitwise XOR для symmetric difference
    public static PermissionSet operator ^(PermissionSet a, PermissionSet b)
    {
        return new PermissionSet(a._permissions ^ b._permissions);
    }

    // Bitwise NOT для інверсії прав
    public static PermissionSet operator ~(PermissionSet p)
    {
        return new PermissionSet(~p._permissions);
    }

    public bool HasPermission(Permission permission)
    {
        return (_permissions & permission) == permission;
    }

    public override string ToString() => _permissions.ToString();
}

// Використання
var readWrite = new PermissionSet(Permission.Read | Permission.Write);
var writeExecute = new PermissionSet(Permission.Write | Permission.Execute);

// Об'єднання прав
var all = readWrite | writeExecute;
Console.WriteLine(all); // Read, Write, Execute

// Спільні права
var common = readWrite & writeExecute;
Console.WriteLine(common); // Write

// Перевірка прав
Console.WriteLine(all.HasPermission(Permission.Read)); // True
Console.WriteLine(readWrite.HasPermission(Permission.Execute)); // False

public class BitArray
{
    private uint _bits;

    public BitArray(uint bits)
    {
        _bits = bits;
    }

    // Left shift: битовий зсув вліво
    public static BitArray operator <<(BitArray array, int shift)
    {
        return new BitArray(array._bits << shift);
    }

    // Right shift: битовий зсув вправо
    public static BitArray operator >>(BitArray array, int shift)
    {
        return new BitArray(array._bits >> shift);
    }

    // Unsigned right shift (C# 11+)
    public static BitArray operator >>>(BitArray array, int shift)
    {
        return new BitArray(array._bits >>> shift);
    }

    public override string ToString()
    {
        return Convert.ToString(_bits, 2).PadLeft(32, '0');
    }
}

// Використання
BitArray bits = new BitArray(0b00001111); // 15

BitArray shiftedLeft = bits << 2;
Console.WriteLine(shiftedLeft);  // 00111100 (60)

BitArray shiftedRight = bits >> 2;
Console.WriteLine(shiftedRight); // 00000011 (3)

public static class StringExtensions
{
    public static string Reverse(this string str)
    {
        char[] chars = str.ToCharArray();
        Array.Reverse(chars);
        return new string(chars);
    }

    public static bool IsPalindrome(this string str)
    {
        string reversed = str.Reverse();
        return str.Equals(reversed, StringComparison.OrdinalIgnoreCase);
    }

    public static string Truncate(this string str, int maxLength)
    {
        if (string.IsNullOrEmpty(str) || str.Length <= maxLength)
            return str;

        return str.Substring(0, maxLength) + "...";
    }

    public static int ToInt(this string str, int defaultValue = 0)
    {
        return int.TryParse(str, out int result) ? result : defaultValue;
    }
}

// Використання
string text = "Hello";
Console.WriteLine(text.Reverse());      // olleH
Console.WriteLine("radar".IsPalindrome()); // True

string longText = "This is a very long text";
Console.WriteLine(longText.Truncate(10)); // This is a ...

string number = "42";
Console.WriteLine(number.ToInt()); // 42

public static class EnumerableExtensions
{
    public static IEnumerable<T> WhereNot<T>(
        this IEnumerable<T> source,
        Func<T, bool> predicate)
    {
        return source.Where(x => !predicate(x));
    }

    public static bool IsNullOrEmpty<T>(this IEnumerable<T>? source)
    {
        return source == null || !source.Any();
    }

    public static string JoinWith<T>(
        this IEnumerable<T> source,
        string separator)
    {
        return string.Join(separator, source);
    }

    public static void ForEach<T>(
        this IEnumerable<T> source,
        Action<T> action)
    {
        foreach (T item in source)
        {
            action(item);
        }
    }
}

// Використання
var numbers = new[] { 1, 2, 3, 4, 5 };

// Відфільтрувати все, що НЕ парне
var oddNumbers = numbers.WhereNot(x => x % 2 == 0);
Console.WriteLine(oddNumbers.JoinWith(", ")); // 1, 3, 5

// ForEach з лямбдою
numbers.ForEach(n => Console.WriteLine(n * 2));
// 2, 4, 6, 8, 10

public partial class Customer
{
    // Properties
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

public partial class Customer
{
    // Validation methods
    public bool IsValidEmail()
    {
        return Email.Contains('@');
    }

    public bool IsValidName()
    {
        return !string.IsNullOrWhiteSpace(Name);
    }
}

public partial class Customer
{
    // Database methods
    public void Save()
    {
        // Logic to save to database
    }

    public static Customer Load(int id)
    {
        // Logic to load from database
        return new Customer();
    }
}

using System.Runtime.CompilerServices;

namespace MyApp.Generated;

public static class CalculatorInterceptors
### Теоретичний аспект: Метапрограмування та Compile-Time магія

Source Generators є потужною формою **метапрограмування** — написання коду, який пише або маніпулює іншим кодом.

Традиційно, багато завдань, що вимагали метапрограмування в .NET, вирішувалися за допомогою **рефлексії (Reflection)** під час виконання (runtime). Рефлексія дозволяє аналізувати та викликати код динамічно, але має суттєві недоліки:
-   **Низька продуктивність**: аналіз метаданих та динамічні виклики є повільними.
-   **Відсутність безпеки типів**: помилки виявляються лише під час виконання.
-   **Складність для AOT-компіляції**: код, що використовує рефлексію, важко або неможливо компілювати в нативний код (Ahead-of-Time).

**Source Generators переносять метапрограмування з runtime у compile-time**:
-   **Максимальна продуктивність**: згенерований код є звичайним C# кодом, який компілюється напряму в IL. Немає жодних накладних витрат під час виконання.
-   **Повна безпека типів**: компілятор перевіряє згенерований код так само, як і написаний вручну. Будь-які помилки виявляються на етапі компіляції.
-   **Дружність до AOT**: оскільки вся "магія" відбувається до етапу виконання, згенерований код ідеально підходить для AOT-сценаріїв (мобільні додатки, Blazor WebAssembly).

Таким чином, Source Generators є еволюційним кроком, що дозволяє вирішувати ті ж самі проблеми, що й рефлексія, але у більш безпечний, продуктивний та сучасний спосіб.
{
    [InterceptsLocation("Program.cs", line: 10, column: 5)]
    public static int InterceptAdd(this Calculator calc, int a, int b)
    {
        Console.WriteLine($"[INTERCEPTED] Add({a}, {b})");
        return calc.Add(a, b); // Викликаємо оригінальний метод
    }
}

// Program.cs (line 10, column 5)
Calculator calculator = new Calculator();
int result = calculator.Add(5, 10); // ← Цей виклик буде перехоплено!
// Output: [INTERCEPTED] Add(5, 10)

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System.Collections.Immutable;
using System.Text;

[Generator]
public class AutoNotifyGenerator : IIncrementalGenerator
{
    public void Initialize(IncrementalGeneratorInitializationContext context)
    {
        // Знайти всі класи з атрибутом [AutoNotify]
        var classDeclarations = context.SyntaxProvider
            .CreateSyntaxProvider(
                predicate: static (s, _) => IsSyntaxTargetForGeneration(s),
                transform: static (ctx, _) => GetSemanticTargetForGeneration(ctx))
            .Where(static m => m is not null);

        // Згенерувати код для кожного класу
        context.RegisterSourceOutput(classDeclarations,
            static (spc, source) => Execute(source, spc));
    }

    static bool IsSyntaxTargetForGeneration(SyntaxNode node)
    {
        return node is ClassDeclarationSyntax c &&
               c.AttributeLists.Count > 0;
    }

    static ClassDeclarationSyntax? GetSemanticTargetForGeneration(
        GeneratorSyntaxContext context)
    {
        var classDeclaration = (ClassDeclarationSyntax)context.Node;

        foreach (var attributeList in classDeclaration.AttributeLists)
        {
            foreach (var attribute in attributeList.Attributes)
            {
                if (context.SemanticModel.GetSymbolInfo(attribute).Symbol is not IMethodSymbol attributeSymbol)
                    continue;

                string attributeName = attributeSymbol.ContainingType.ToDisplayString();

                if (attributeName == "AutoNotifyAttribute")
                {
                    return classDeclaration;
                }
            }
        }

        return null;
    }

    static void Execute(ClassDeclarationSyntax? classDeclaration, SourceProductionContext context)
    {
        if (classDeclaration is null)
            return;

        string namespaceName = "Generated";
        string className = classDeclaration.Identifier.Text;

        var source = $@"
using System.ComponentModel;

namespace {namespaceName}
{{
    public partial class {className} : INotifyPropertyChanged
    {{
        public event PropertyChangedEventHandler? PropertyChanged;

        protected void OnPropertyChanged(string propertyName)
        {{
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }}
    }}
}}";

        context.AddSource($"{className}.g.cs", source);
    }
}

[AutoNotify]
public partial class Person
{
    private string _name;
    public string Name
    {
        get => _name;
        set
        {
            _name = value;
            OnPropertyChanged(nameof(Name)); // Метод згенеровано!
        }
    }
}