如何用NAudio加载音频至内存复用，解决高频播放内存过高问题

嘿，这两个问题其实是一脉相承的，我来给你捋清楚怎么解决！

核心思路是把音频文件的内容一次性读取到内存中保存，后续播放时直接从内存读取，而不是反复从磁盘加载。NAudio提供了几种实用的方式来实现：

方式1：用字节数组缓存音频数据 #

这种方式简单直接，把音频文件转成字节数组存在缓存里，每次播放时用这个数组创建内存流：

// 全局缓存字典，存储文件路径和对应的音频字节数据
private Dictionary<string, byte[]> _audioCache = new Dictionary<string, byte[]>();

// 预加载音频到内存
private void PreloadAudio(string filePath)
{
    if (_audioCache.ContainsKey(filePath)) return; // 已加载就跳过
    
    using (var audioReader = new AudioFileReader(filePath))
    {
        using (var memoryStream = new MemoryStream())
        {
            audioReader.CopyTo(memoryStream);
            _audioCache[filePath] = memoryStream.ToArray();
        }
    }
}

// 从内存缓存播放
private void PlayAudioFromCache(string filePath)
{
    if (!_audioCache.TryGetValue(filePath, out var audioBytes))
    {
        // 容错：如果没预加载，临时加载一次
        PreloadAudio(filePath);
        audioBytes = _audioCache[filePath];
    }

    // 每次播放都要创建新的内存流（因为流的位置会被读取指针改变）
    using (var memoryStream = new MemoryStream(audioBytes))
    using (var audioReader = new AudioFileReader(memoryStream))
    using (var outputDevice = new WaveOutEvent())
    {
        outputDevice.Init(audioReader);
        outputDevice.Play();
        
        // 等待播放完成（如果不需要阻塞可以去掉这段，或者用异步回调）
        while (outputDevice.PlaybackState == PlaybackState.Playing)
        {
            Thread.Sleep(100);
        }
    }
}

方式2：用CachedWaveProvider缓存音频流 #

NAudio的CachedWaveProvider专门用来缓存音频数据，它会把整个音频流加载到内存，并且支持重置播放位置，适合多次复用：

// 全局缓存字典，存储文件路径和对应的缓存WaveProvider
private Dictionary<string, CachedWaveProvider> _audioProviderCache = new Dictionary<string, CachedWaveProvider>();

// 预加载为CachedWaveProvider
private void PreloadAudioAsWaveProvider(string filePath)
{
    if (_audioProviderCache.ContainsKey(filePath)) return;
    
    var audioReader = new AudioFileReader(filePath);
    var cachedProvider = new CachedWaveProvider(audioReader);
    
    // 提前读取所有数据到缓存，避免第一次播放时的延迟
    cachedProvider.Read(new byte[audioReader.Length], 0, (int)audioReader.Length);
    
    _audioProviderCache[filePath] = cachedProvider;
}

// 从缓存的WaveProvider播放
private void PlayFromWaveProvider(string filePath)
{
    if (!_audioProviderCache.TryGetValue(filePath, out var cachedProvider))
    {
        PreloadAudioAsWaveProvider(filePath);
        cachedProvider = _audioProviderCache[filePath];
    }
    
    // 重置播放位置到开头，这样可以重复播放
    cachedProvider.Reset();
    
    using (var outputDevice = new WaveOutEvent())
    {
        outputDevice.Init(cachedProvider);
        outputDevice.Play();
        
        while (outputDevice.PlaybackState == PlaybackState.Playing)
        {
            Thread.Sleep(100);
        }
    }
}

你的问题根源在于每次播放都重新从磁盘加载音频文件，重复加载会导致内存里堆积大量重复的音频数据，而且GC可能来不及回收。解决办法就是先预加载所有需要随机播放的音频文件，然后每次播放直接从内存缓存读取。

具体改造步骤： #

1. 程序启动时预加载所有目标音频：比如把sounds/目录下的所有MP3都加载到缓存里
2. 随机播放时直接调用缓存的播放方法：不再每次创建AudioFileReader读取磁盘文件

改造后的示例代码： #

// 假设你有多个音频文件需要随机选择
private List<string> _audioFiles = new List<string> { "sounds/test.mp3", "sounds/another.mp3" };
private Dictionary<string, byte[]> _audioCache = new Dictionary<string, byte[]>();
private Random _random = new Random();

// 程序初始化时预加载所有音频
private void InitializeAudioCache()
{
    foreach (var filePath in _audioFiles)
    {
        PreloadAudio(filePath);
    }
}

// 随机播放音频（从内存缓存）
private void RandomPlayFromCache()
{
    var randomFilePath = _audioFiles[_random.Next(_audioFiles.Count)];
    
    if (!_audioCache.TryGetValue(randomFilePath, out var audioBytes))
    {
        PreloadAudio(randomFilePath);
        audioBytes = _audioCache[randomFilePath];
    }

    using (var memoryStream = new MemoryStream(audioBytes))
    using (var audioReader = new AudioFileReader(memoryStream))
    using (var outputDevice = new WaveOutEvent())
    {
        outputDevice.Init(audioReader);
        outputDevice.Play();
        
        // 如果你不想阻塞主线程，可以去掉while循环，改用PlaybackStopped事件
        // outputDevice.PlaybackStopped += (s, e) => { /* 播放完成后的逻辑 */ };
    }
}

额外优化建议： #

• 复用输出设备：如果频繁创建WaveOutEvent，可以考虑全局维护一个WaveOutEvent实例，每次播放前停止当前播放并重新初始化，减少对象创建开销（注意线程安全）
• 异步播放：避免用while循环阻塞线程，改用PlaybackStopped事件处理播放完成逻辑，提升程序响应性
• 内存监控：如果音频文件很多或者体积很大，要注意内存占用，避免预加载过多大文件导致内存不足

内容的提问来源于stack exchange，提问作者botiapa