10个被低估的C#性能优化技巧分享

// 原始结构（占用64字节）
struct Particle {
    Vector3 position;   // 12B 
    Color32 color;      // 4B
    float size;         // 4B
    // 其他字段...
}

[StructLayout(LayoutKind.Sequential, Pack = 16)]
struct OptimizedParticle {
    Vector4 position;   // 16B (SIMD对齐)
    uint colorData;     // 4B (RGBA压缩存储)
    // 其他紧凑字段...
}

enum LogLevel { Debug, Info, Warn }
// 每次调用产生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>();  // 默认容量0
for (int i = 0; i < 100000; i++) {
    list.Add(i);  // 触发13次扩容
}

var list = new List<int>(100000);  // 预分配
Parallel.For(0, 100000, i => {
    lock(list) {  // 消除锁竞争
        list.Add(i); 
    }
});

// 传统方案
byte[] ProcessImage(byte[] data) {
    var temp = new byte[data.Length];
    Array.Copy(data, temp, data.Length);
    // 处理逻辑...
    return temp;
}
// Span优化方案
void ProcessImage(Span<byte> buffer) {
    // 直接操作内存
    for (int i = 0; i < buffer.Length; i += 4) {
        buffer[i+3] = 255; // Alpha通道
    }
}

// 动态编译访问器
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);
}

// 传统堆分配
byte[] buffer = new byte[256];
// 栈分配优化
Span<byte> buffer = stackalloc byte[256];

// 传统分段处理
async Task ProcessStream(NetworkStream stream) {
    byte[] buffer = new byte[1024];
    int bytesRead;
    while ((bytesRead = await stream.ReadAsync(buffer)) != 0) {
        ProcessData(buffer, bytesRead);
    }
}
// 管道优化
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) { }
}
// 复用任务源
private static readonly CustomValueTaskSource _sharedSource = new();
public ValueTask<int> OptimizedAsyncMethod()
{
    return new ValueTask<int>(_sharedSource, 0);
}

// 传统方案
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;
}

// 传统接口方式
interface IBehavior {
    void Update();
}
class MoveBehavior : IBehavior { /* 实现 */ }
// 结构体优化
struct MoveBehavior {
    public void Update() { /* 实现 */ }
}
// 调用方
void ProcessBehaviors(Span<MoveBehavior> behaviors) {
    foreach (ref var b in behaviors) {
        b.Update();  // 无虚方法表查找
    }
}