unsafe 与 dynamic：两个逃生舱

void M<T>(T t) where T : allows ref struct
{
    // T 可能是 ref struct，因此不能装箱、不能作为字段
}

using System;
using System.Runtime.InteropServices;

namespace AdvancedFeatures.Unsafe;

/// <summary>
/// 不安全代码示例：直接操作位图像素数据。
/// 演示 fixed、unsafe、指针算术、Span 与 unsafe 的结合。
/// </summary>
public unsafe static class ImageProcessor
{
    /// <summary>
    /// 将 32 位 BGRA 图像转换为灰度图（Rec. 601 luma 公式）。
    /// </summary>
    /// <param name="pixels">原始像素数据（4 字节/像素）</param>
    /// <remarks>
    /// 公式：Y = 0.299R + 0.587G + 0.114B
    /// 为避免浮点开销，使用整数近似：Y = (77*R + 150*G + 29*B) >> 8
    /// </remarks>
    public static void ToGrayscale(Span<byte> pixels)
    {
        // 使用 ref local 遍历 Span，避免边界检查
        ref byte ptr = ref MemoryMarshal.GetReference(pixels);
        int pixelCount = pixels.Length / 4;

        for (int i = 0; i < pixelCount; i++)
        {
            int offset = i * 4;
            byte b = Unsafe.Add(ref ptr, offset);
            byte g = Unsafe.Add(ref ptr, offset + 1);
            byte r = Unsafe.Add(ref ptr, offset + 2);

            // 整数近似灰度值
            byte gray = (byte)((77 * r + 150 * g + 29 * b) >> 8);

            // 写回 RGB 三通道，保留 Alpha
            Unsafe.Add(ref ptr, offset) = gray;
            Unsafe.Add(ref ptr, offset + 1) = gray;
            Unsafe.Add(ref ptr, offset + 2) = gray;
        }
    }

    /// <summary>
    /// 使用 stackalloc 在栈上分配小缓冲区，避免堆分配。
    /// </summary>
    public static int SumStackAlloc(int size)
    {
        // 栈分配（要求 unsafe 上下文）
        Span<int> buffer = stackalloc int[size];

        for (int i = 0; i < size; i++)
        {
            buffer[i] = i * i;
        }

        int sum = 0;
        foreach (int x in buffer) sum += x;
        return sum;
    }

    /// <summary>
    /// 使用 fixed 钉住托管数组，通过指针直接访问。
    /// </summary>
    public static void FillWithPointer(int[] array, int value)
    {
        // fixed 防止 GC 移动数组，p 为指向首元素的指针
        fixed (int* p = array)
        {
            // 指针算术遍历
            for (int i = 0; i < array.Length; i++)
            {
                p[i] = value;
            }
        } // 离开 fixed 块后，数组解除钉住
    }
}

// 引入 System.Runtime.CompilerServices.Unsafe
internal static class Unsafe
{
    public static ref T Add<T>(ref T source, int index) =>
        ref System.Runtime.CompilerServices.Unsafe.Add(ref source, index);
}

private static CallSite<Func<CallSite, object, int, object>> _site;
// 编译器生成的缓存字段
if (_site == null)
{
    _site = CallSite<Func<CallSite, object, int, object>>.Create(
        Binder.InvokeMember(...));
}
_site.Target(_site, d, x);

using System;
using System.Text.Json;

namespace AdvancedFeatures.Dynamic;

/// <summary>
/// dynamic 示例：动态访问 JSON 对象属性。
/// 适合脚本场景，生产环境推荐使用强类型反序列化。
/// </summary>
public static class JsonDynamic
{
    public static void Demo()
    {
        string json = """
            {
                "name": "Alice",
                "age": 30,
                "address": {
                    "city": "Beijing",
                    "zip": "100000"
                }
            }
            """;

        // 反序列化为 JsonElement，再通过 dynamic 访问
        using JsonDocument doc = JsonDocument.Parse(json);

        // dynamic 包装允许动态属性访问
        dynamic obj = ParseToDynamic(doc.RootElement);

        // 编译期不检查，运行期分发
        Console.WriteLine($"Name: {obj.name}");
        Console.WriteLine($"Age: {obj.age}");
        Console.WriteLine($"City: {obj.address.city}");
    }

    /// <summary>
    /// 将 JsonElement 转换为 dynamic，支持属性动态访问。
    /// </summary>
    private static dynamic ParseToDynamic(JsonElement element)
    {
        switch (element.ValueKind)
        {
            case JsonValueKind.Object:
                var dict = new System.Dynamic.ExpandoObject() as IDictionary<string, object>;
                foreach (var prop in element.EnumerateObject())
                {
                    dict[prop.Name] = ParseToDynamic(prop.Value);
                }
                return dict;
            case JsonValueKind.Array:
                return element.EnumerateArray().Select(ParseToDynamic).ToList();
            case JsonValueKind.String:
                return element.GetString()!;
            case JsonValueKind.Number:
                return element.GetDouble();
            case JsonValueKind.True:
                return true;
            case JsonValueKind.False:
                return false;
            default:
                return null!;
        }
    }
}

// 边界一：dynamic 不支持扩展方法——接收者是 dynamic 时，扩展方法解析失败
dynamic d = "hello";
// var x = d.MyExtension(); // 运行期 RuntimeBinderException

// 边界二：泛型约束在编译期检查，dynamic 绕不过
void M<T>(T t) where T : IEnumerable { }
dynamic d2 = new List<int>();
// M(d2); // 运行期错误：dynamic 的实际类型不满足约束时 RuntimeBinderException

// 错误：fixed 块外使用指针
int* p;
fixed (int* tmp = array) { p = tmp; }
*p = 10; // 危险：fixed 块已结束，数组可能已被 GC 移动

unsafe
{
    int* p = stackalloc int[10];
    // p 内容未定义（不是 0），需手动初始化
    for (int i = 0; i < 10; i++) p[i] = 0;
}

// 修复：使用 Span<T> + stackalloc 自动清零（C# 7.2+）
Span<int> s = stackalloc int[10]; // 自动清零

// 启用不安全代码块
unsafe
{
    int x = 10;
    int* p = &x;
}

// 声明不安全方法
unsafe void ProcessPointer(int* ptr)
{
    *ptr = 42;
}

// 声明并初始化指针
int x = 10;
int* ptr = &x;

// 解引用指针获取值
int value = *ptr;

// 固定托管对象防止 GC 移动
int[] array = { 1, 2, 3, 4, 5 };
fixed (int* p = array)
{
    Console.WriteLine(*p);
}

// 获取类型大小
int size = sizeof(int);