// 原始結(jié)構(gòu)（占用64字節(jié)）
struct Particle {
    Vector3 position;   // 12B 
    Color32 color;      // 4B
    float size;         // 4B
    // 其他字段...
}

[StructLayout(LayoutKind.Sequential, Pack = 16)]
struct OptimizedParticle {
    Vector4 position;   // 16B (SIMD對(duì)齊)
    uint colorData;     // 4B (RGBA壓縮存儲(chǔ))
    // 其他緊湊字段...
}

enum LogLevel { Debug, Info, Warn }
// 每次調(diào)用產(chǎn)生24B裝箱分配
void Log(object message, LogLevel level) {
    if(level >= currentLevel) {
        //...
    }
}

// 零分配方案
void Log<T>(T message, LogLevel level) where T : IUtf8SpanFormattable
{
    if (level < currentLevel) return;
    
    const int BufferSize = 256;
    Span<byte> buffer = stackalloc byte[BufferSize];
    if (Utf8.TryWrite(buffer, message, out var bytesWritten))
    {
        WriteToLog(buffer.Slice(0, bytesWritten));
    }
}

var list = new List<int>();  // 默認(rèn)容量0
for (int i = 0; i < 100000; i++) {
    list.Add(i);  // 觸發(fā)13次擴(kuò)容
}

var list = new List<int>(100000);  // 預(yù)分配
Parallel.For(0, 100000, i => {
    lock(list) {  // 消除鎖競爭
        list.Add(i); 
    }
});

// 傳統(tǒng)方案
byte[] ProcessImage(byte[] data) {
    var temp = new byte[data.Length];
    Array.Copy(data, temp, data.Length);
    // 處理邏輯...
    return temp;
}
// Span優(yōu)化方案
void ProcessImage(Span<byte> buffer) {
    // 直接操作內(nèi)存
    for (int i = 0; i < buffer.Length; i += 4) {
        buffer[i+3] = 255; // Alpha通道
    }
}

// 動(dòng)態(tài)編譯訪問器
private static Func<T, object> CreateGetter<T>(PropertyInfo prop)
{
    var param = Expression.Parameter(typeof(T));
    var body = Expression.Convert(Expression.Property(param, prop), typeof(object));
    return Expression.Lambda<Func<T, object>>(body, param).Compile();
}
// 使用緩存
private static ConcurrentDictionary<PropertyInfo, Delegate> _cache = new();
public static object FastGetValue<T>(T obj, PropertyInfo prop)
{
    if (!_cache.TryGetValue(prop, out var func))
    {
        func = CreateGetter<T>(prop);
        _cache.TryAdd(prop, func);
    }
    return ((Func<T, object>)func)(obj);
}

// 傳統(tǒng)堆分配
byte[] buffer = new byte[256];
// 棧分配優(yōu)化
Span<byte> buffer = stackalloc byte[256];

// 傳統(tǒng)分段處理
async Task ProcessStream(NetworkStream stream) {
    byte[] buffer = new byte[1024];
    int bytesRead;
    while ((bytesRead = await stream.ReadAsync(buffer)) != 0) {
        ProcessData(buffer, bytesRead);
    }
}
// 管道優(yōu)化
var pipe = new Pipe();
Task writing = FillPipeAsync(stream, pipe.Writer);
Task reading = ReadPipeAsync(pipe.Reader);
async Task FillPipeAsync(NetworkStream stream, PipeWriter writer) {
    while (true) {
        Memory<byte> memory = writer.GetMemory(1024);
        int bytesRead = await stream.ReadAsync(memory);
        writer.Advance(bytesRead);
        await writer.FlushAsync();
    }
}

class CustomValueTaskSource : IValueTaskSource<int>
{
    public int GetResult(short token) => 0;
    public ValueTaskSourceStatus GetStatus(short token) => ValueTaskSourceStatus.Pending;
    public void OnCompleted(Action<object> continuation, object state, short token, ValueTaskSourceOnCompletedFlags flags) { }
}
// 復(fù)用任務(wù)源
private static readonly CustomValueTaskSource _sharedSource = new();
public ValueTask<int> OptimizedAsyncMethod()
{
    return new ValueTask<int>(_sharedSource, 0);
}

// 傳統(tǒng)方案
bool[] statusFlags = new bool[1000000];  // 占用1MB
// 位掩碼方案
int[] bitmask = new int[1000000 / 32];  // 僅占122KB
void SetFlag(int index) {
    bitmask[index >> 5] |= 1 << (index & 0x1F);
}
bool GetFlag(int index) {
    return (bitmask[index >> 5] & (1 << (index & 0x1F))) != 0;
}

// 傳統(tǒng)接口方式
interface IBehavior {
    void Update();
}
class MoveBehavior : IBehavior { /* 實(shí)現(xiàn) */ }
// 結(jié)構(gòu)體優(yōu)化
struct MoveBehavior {
    public void Update() { /* 實(shí)現(xiàn) */ }
}
// 調(diào)用方
void ProcessBehaviors(Span<MoveBehavior> behaviors) {
    foreach (ref var b in behaviors) {
        b.Update();  // 無虛方法表查找
    }
}