// 異步批量讀取（每次操作128KB）
async Task ProcessFileAsync(string filePath)
{
    await using var fs = new FileStream(
        filePath, 
        FileMode.Open, 
        FileAccess.Read,
        FileShare.Read,
        bufferSize: 131_072,  // 128KB緩沖區(qū)
        FileOptions.Asynchronous | FileOptions.SequentialScan  // 關(guān)鍵優(yōu)化選項
    );
 
    byte[] buffer = ArrayPool<byte>.Shared.Rent(131_072);
    try {
        int bytesRead;
        while ((bytesRead = await fs.ReadAsync(buffer.AsMemory(0, buffer.Length)) > 0) {
            ProcessChunk(buffer.AsSpan(0, bytesRead));  // 零拷貝處理
        }
    }
    finally {
        ArrayPool<byte>.Shared.Return(buffer);
    }
}

// 直接操作文件內(nèi)存視圖（適用于大型文件）
void SearchInLargeFile(string filePath, string pattern)
{
    using var mmf = MemoryMappedFile.CreateFromFile(filePath, FileMode.Open);
    using var view = mmf.CreateViewAccessor();
    unsafe {
        byte* ptr = (byte*)view.SafeMemoryMappedViewHandle.DangerousGetHandle();
        var span = new ReadOnlySpan<byte>(ptr, (int)view.Capacity);
        
        // 使用 Boyer-Moore 算法直接搜索（無內(nèi)存分配）
        int pos = span.IndexOf(Encoding.UTF8.GetBytes(pattern));
        if (pos >= 0) Console.WriteLine($"Found at offset {pos}");
    }
}

// 高性能隨機讀寫（減少系統(tǒng)調(diào)用）
async Task RandomAccessDemo()
{
    var handle = File.OpenHandle("data.bin", FileMode.Open);
    byte[] buffer = new byte[4096];
    
    // 直接定位并讀取（同步操作在異步代碼中）
    await RandomAccess.ReadAsync(handle, buffer, 1024);
    
    // 修改數(shù)據(jù)后寫入
    buffer[0] = 0xFF;
    await RandomAccess.WriteAsync(handle, buffer, 2048);
}

// 基于管道的網(wǎng)絡(luò)協(xié)議解析
async Task PipeServer(Socket socket)
{
    var pipe = new Pipe();
    Task writing = ReceiveDataAsync(socket, pipe.Writer);
    Task reading = ProcessDataAsync(pipe.Reader);
    await Task.WhenAll(writing, reading);
}
 
async Task ReceiveDataAsync(Socket socket, PipeWriter writer)
{
    while (true) {
        Memory<byte> memory = writer.GetMemory(1024);
        int bytesRead = await socket.ReceiveAsync(memory, SocketFlags.None);
        if (bytesRead == 0) break;
        
        writer.Advance(bytesRead);
        FlushResult result = await writer.FlushAsync();
        if (result.IsCompleted) break;
    }
    await writer.CompleteAsync();
}

// 高并發(fā)連接重用對象池
class SocketPool
{
    private ConcurrentQueue<SocketAsyncEventArgs> _pool = new();
    
    public SocketAsyncEventArgs Rent()
    {
        if (_pool.TryDequeue(out var args)) return args;
        
        args = new SocketAsyncEventArgs();
        args.Completed += OnIOCompleted;  // 重用事件處理器
        return args;
    }
    
    public void Return(SocketAsyncEventArgs args) 
    {
        args.AcceptSocket = null;
        args.SetBuffer(null, 0, 0);
        _pool.Enqueue(args);
    }
    
    private void OnIOCompleted(object? sender, SocketAsyncEventArgs e) 
    {
        // 異步回調(diào)處理...
    }
}

// 大文件分塊并行處理
async Task ParallelFileProcessing(string path)
{
    const int ChunkSize = 1_048_576;  // 1MB
    long fileSize = new FileInfo(path).Length;
    var chunks = Enumerable.Range(0, (int)(fileSize / ChunkSize + 1));
    
    await Parallel.ForEachAsync(chunks, async (chunk, ct) => 
    {
        long offset = chunk * ChunkSize;
        using var fs = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
        fs.Seek(offset, SeekOrigin.Begin);
        
        byte[] buffer = ArrayPool<byte>.Shared.Rent(ChunkSize);
        int read = await fs.ReadAsync(buffer, 0, ChunkSize, ct);
        ProcessChunk(buffer.AsMemory(0, read));
        ArrayPool<byte>.Shared.Return(buffer);
    });
}

[Benchmark]
public async Task AsyncFileRead()
{
    await using var fs = new FileStream("test.data", FileOptions.Asynchronous);
    byte[] buffer = new byte[131072];
    while (await fs.ReadAsync(buffer) > 0) {}
}

# Linux
dotnet-counters monitor --process-id PID System.Runtime FileSystem
 
# Windows
perfview /GCCollectOnly /BufferSizeMB=1024 collect

// 記錄異步操作實際耗時
var sw = Stopwatch.StartNew();
await ReadDataAsync();
var elapsed = sw.ElapsedMilliseconds;
_logger.LogInformation($"IO延遲: {elapsed}ms");