在C＃中播放声音 - 使用哪种方法？

Question

我想写一点C＃.net - 应用程序，当点击特定的按钮时，从文件夹中随机播放声音。

所以我花了一些时间找到正确的方法来实现这一点。在我的脑海里，“只是发声”似乎并不复杂，但有很多方法可以做到这一点。

请纠正我的每一件事情，我现在要说：

• PlaySound是很老的方式，如音量没有控件，多个声音或循环
• mciSendString，发送文本注释的MCI，播放不同的格式，支持音量控制，甚至可以同时发出多个声音，不是很舒适的发送字符串命令而不是使用类，可能需要格式良好的包装类（任何人？：D）
• class，support async ，没有真正的更薄克，没有体积没有循环
• MediaPlayer类，支持非音频，.NET 4.0，体积甚至更多，但是需要一些“特殊待遇”的同时
• DirectSound有多种声音的工作，似乎支持你的一切可以有声音想象，代码看起来太复杂了“简单地播放声音”

好吧，这是方法，也许我缺少一个，但一般...我不是一个相信然而。

我想要开始，停止，暂停自定义.wav .mp3声音不只是在彼此之后，但有时甚至在同一时间，它们在运行期间改变音量，也许一些静音功能停止所有声音。听起来很容易，但是它？

感谢提前任何提示，

哈利

Answer 1

我要说的是MediaPlayer类是功能最强大，也是最简单的一个使用。我已经做了一些音频/视频播放，你几乎可以做任何事情。既然你需要播放多个文件，SoundPlayer是一个明显的选择，所以你可以混合使用这两种文件。 但是，您可以有多个MediaPlayer实例并播放不同的声音。

这似乎也像你已经完成的研究，可以最好地回答你的问题。

Answer 2

对于需要启动加载了指定声音文件的新Windows Media播放器流程，这会更有意义吗？ 你可以得到这个工作使用的System.Diagnostics.Process类

Process.Start("wmplayer.exe", "C:\\myPath\\mySound.mp3"); 

Answer 3

您可以使用WPF媒体播放器控制，是很容易使用和定制您的需求。

如果你只是使用Windows窗体，你可以使用Windows Media Player ActiveX控件和定制它一点有自己的播放/暂停/前进UI /快退等

DirectX的将是有点困难的一个与以上两种选择相比较。

Answer 4

我扩展了我在这里找到的一个类：Playing MP3s using MCI http://www.codeproject.com 并使其易于使用，保持可控的多种声音。

它几乎不言自明，但也许有人利用这段代码somewhen发现这个线程保险箱一段时间，或可能有一些重要的事情来改善它：

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Runtime.InteropServices; 
using System.IO; 

namespace someNameHere 
{ 
    public class MP3Player 
    { 
     private string Pcommand, FName,alias; 
     private bool Opened, Playing, Paused, Loop, 
        MutedAll, MutedLeft, MutedRight; 
     private int rVolume, lVolume, aVolume, 
        tVolume, bVolume, VolBalance; 
     private ulong Lng; 
     private long Err; 
     private static int counter = 0; 
     public static List<MP3Player> currentlyActive = new List<MP3Player>(); 
     public static List<MP3Player> lastFiveActive = new List<MP3Player>(); 

     [DllImport("winmm.dll")] 
     private static extern long mciSendString(string strCommand, 
       StringBuilder strReturn, int iReturnLength, 
       IntPtr hwndCallback); 

     public MP3Player() 
     { 
      Opened = false; 
      Pcommand = ""; 
      FName = ""; 
      Playing = false; 
      Paused = false; 
      Loop = false; 
      MutedAll = MutedLeft = MutedRight = false; 
      rVolume = lVolume = aVolume = 
         tVolume = bVolume = 1000; 
      Lng = 0; 
      VolBalance = 0; 
      Err = 0; 
      counter++; 
      alias = "alias" + counter.ToString(); 
      currentlyActive = cleanUpActive(); 
      currentlyActive.Add(this); 
     } 

     ~MP3Player() 
     { 
      currentlyActive.Remove(this); 
     } 


     private List<MP3Player> cleanUpActive() 
     { 
      List<MP3Player> cachedList = new List<MP3Player>(currentlyActive); 
      cachedList = (from c in cachedList where c.AudioLength == c.CurrentPosition select c).ToList(); 

      foreach (MP3Player eachSound in cachedList) 
      { 
       eachSound.Stop(); 
       eachSound.Close(); 
      } 

      return (from c in currentlyActive where c.AudioLength != c.CurrentPosition select c).ToList(); 
     } 

     public static void playRandomFromFolder(string relpath, bool checkIfInLast) 
     { 
      try 
      { 
       string currentdir = Environment.CurrentDirectory; 
       string[] Files = Directory.GetFiles(currentdir + relpath); 
       Random randNum = new Random(); 
       List<string> list_paths = (from c in lastFiveActive select c.FileName).ToList(); 

       string randomFile = ""; 
       int i = 0; 
       while (true) 
       { 
        int zufall = randNum.Next(0, Files.Length); 
        if (!list_paths.Contains(Files[zufall]) || i > 10) 
        { 
         randomFile = Files[zufall]; 
         break; 
        } 

       } 

       MP3Player playIt = new MP3Player(); 
       playIt.Open(randomFile); 
       playIt.Play(); 
      } 
      catch (Exception err) 
      { 
       // MessageBox.Show(err.Message); 
      } 

     } 



     #region AllActiveFunctions 

     public static void stopAllActive() 
     { 
      List<MP3Player> cachedList = new List<MP3Player>(currentlyActive); 
      foreach (MP3Player eachSound in cachedList) 
      { 
       eachSound.Stop(); 
      } 

     } 
     public static void pauseAllActive() 
     { 
      foreach (MP3Player eachSound in currentlyActive) 
      { 
       eachSound.Pause(); 
      } 

     } 
     public static void playAllActive() 
     { 
      List<MP3Player> cachedList = new List<MP3Player>(currentlyActive); 
      foreach (MP3Player eachSound in cachedList) 
      { 
       eachSound.Play(); 
      } 

     } 
     public static void setVolumeAllActive(int i) 
     { 
      List<MP3Player> cachedList = new List<MP3Player>(currentlyActive); 
      foreach (MP3Player eachSound in cachedList) 
      { 
       eachSound.VolumeAll = i; 
      } 

     } 
     public static void setVolumeLeft(int i) 
     { 
      List<MP3Player> cachedList = new List<MP3Player>(currentlyActive); 
      foreach (MP3Player eachSound in cachedList) 
      { 
       eachSound.VolumeLeft = i; 
      } 

     } 
     public static void setVolumeRight(int i) 
     { 
      List<MP3Player> cachedList = new List<MP3Player>(currentlyActive); 
      foreach (MP3Player eachSound in cachedList) 
      { 
       eachSound.VolumeRight = i; 
      } 

     } 
     public static void setVolumeTreble(int i) 
     { 
      List<MP3Player> cachedList = new List<MP3Player>(currentlyActive); 
      foreach (MP3Player eachSound in cachedList) 
      { 
       eachSound.VolumeTreble = i; 
      } 

     } 
     public static void setVolumeBass(int i) 
     { 
      List<MP3Player> cachedList = new List<MP3Player>(currentlyActive); 
      foreach (MP3Player eachSound in cachedList) 
      { 
       eachSound.VolumeBass = i; 
      } 

     } 

     public static void setBalance(int i) 
     { 
      List<MP3Player> cachedList = new List<MP3Player>(currentlyActive); 
      foreach (MP3Player eachSound in cachedList) 
      { 
       eachSound.Balance = i; 
      } 

     } 

     public static void stopLast() 
     { 
      List<MP3Player> cachedList = new List<MP3Player>(currentlyActive); 
      cachedList.Last().Stop(); 
     } 
     #endregion 

     #region Volume 
     public bool MuteAll 
     { 
      get 
      { 
       return MutedAll; 
      } 
      set 
      { 
       MutedAll = value; 
       if (MutedAll) 
       { 
        Pcommand = "setaudio " + alias + " off"; 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
       } 
       else 
       { 
        Pcommand = "setaudio " + alias + " on"; 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
       } 
      } 

     } 

     public bool MuteLeft 
     { 
      get 
      { 
       return MutedLeft; 
      } 
      set 
      { 
       MutedLeft = value; 
       if (MutedLeft) 
       { 
        Pcommand = "setaudio " + alias + " left off"; 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
       } 
       else 
       { 
        Pcommand = "setaudio " + alias + " left on"; 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
       } 
      } 

     } 

     public bool MuteRight 
     { 
      get 
      { 
       return MutedRight; 
      } 
      set 
      { 
       MutedRight = value; 
       if (MutedRight) 
       { 
        Pcommand = "setaudio " + alias + " right off"; 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
       } 
       else 
       { 
        Pcommand = "setaudio " + alias + " right on"; 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
       } 
      } 

     } 

     public int VolumeAll 
     { 
      get 
      { 
       return aVolume; 
      } 
      set 
      { 
       if (Opened && (value >= 0 && value <= 1000)) 
       { 
        aVolume = value; 
        Pcommand = String.Format("setaudio " + alias + "" + 
           " volume to {0}", aVolume); 
        if ((Err = mciSendString(Pcommand, null, 0, 
              IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
       } 
      } 
     } 

     public int VolumeLeft 
     { 
      get 
      { 
       return lVolume; 
      } 
      set 
      { 
       if (Opened && (value >= 0 && value <= 1000)) 
       { 
        lVolume = value; 
        Pcommand = String.Format("setaudio " + alias + "" + 
           " left volume to {0}", lVolume); 
        if ((Err = mciSendString(Pcommand, null, 0, 
              IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
       } 
      } 
     } 

     public int VolumeRight 
     { 
      get 
      { 
       return rVolume; 
      } 
      set 
      { 
       if (Opened && (value >= 0 && value <= 1000)) 
       { 
        rVolume = value; 
        Pcommand = String.Format("setaudio" + 
           " " + alias + " right volume to {0}", rVolume); 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
       } 
      } 
     } 

     public int VolumeTreble 
     { 
      get 
      { 
       return tVolume; 
      } 
      set 
      { 
       if (Opened && (value >= 0 && value <= 1000)) 
       { 
        tVolume = value; 
        Pcommand = String.Format("setaudio " + alias + "" + 
              " treble to {0}", tVolume); 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
       } 
      } 
     } 

     public int VolumeBass 
     { 
      get 
      { 
       return bVolume; 
      } 
      set 
      { 
       if (Opened && (value >= 0 && value <= 1000)) 
       { 
        bVolume = value; 
        Pcommand = String.Format("setaudio " + alias + " bass to {0}", 
              bVolume); 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
       } 
      } 
     } 

     public int Balance 
     { 
      get 
      { 
       return VolBalance; 
      } 
      set 
      { 
       if (Opened && (value >= -1000 && value <= 1000)) 
       { 
        VolBalance = value; 
        if (value < 0) 
        { 
         Pcommand = "setaudio " + alias + " left volume to 1000"; 
         if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
          OnError(new ErrorEventArgs(Err)); 
         Pcommand = String.Format("setaudio " + alias + " right" + 
               " volume to {0}", 1000 + value); 
         if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
          OnError(new ErrorEventArgs(Err)); 
        } 
        else 
        { 
         Pcommand = "setaudio " + alias + " right volume to 1000"; 
         if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
          OnError(new ErrorEventArgs(Err)); 
         Pcommand = String.Format("setaudio " + alias + "" + 
            " left volume to {0}", 1000 - value); 
         if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
          OnError(new ErrorEventArgs(Err)); 
        } 
       } 
      } 
     } 
     #endregion 

     #region Main Functions 

     public string FileName 
     { 
      get 
      { 
       return FName; 
      } 
     } 

     public bool Looping 
     { 
      get 
      { 
       return Loop; 
      } 
      set 
      { 
       Loop = value; 
      } 
     } 

     public void Seek(ulong Millisecs) 
     { 
      if (Opened && Millisecs <= Lng) 
      { 
       if (Playing) 
       { 
        if (Paused) 
        { 
         Pcommand = String.Format("seek " + alias + " to {0}", Millisecs); 
         if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
          OnError(new ErrorEventArgs(Err)); 
        } 
        else 
        { 
         Pcommand = String.Format("seek " + alias + " to {0}", Millisecs); 
         if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
          OnError(new ErrorEventArgs(Err)); 
         Pcommand = "play " + alias + ""; 
         if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
          OnError(new ErrorEventArgs(Err)); 
        } 
       } 
      } 
     } 

     private void CalculateLength() 
     { 
      StringBuilder str = new StringBuilder(128); 
      mciSendString("status " + alias + " length", str, 128, IntPtr.Zero); 
      Lng = Convert.ToUInt64(str.ToString()); 
     } 

     public ulong AudioLength 
     { 
      get 
      { 
       if (Opened) return Lng; 
       else return 0; 
      } 
     } 

     public void Close() 
     { 
      if (Opened) 
      { 
       Pcommand = "close " + alias + ""; 
       if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
        OnError(new ErrorEventArgs(Err)); 
       Opened = false; 
       Playing = false; 
       Paused = false; 
       OnCloseFile(new CloseFileEventArgs()); 
      } 
     } 

     public void Open(string sFileName) 
     { 
      if (!Opened) 
      { 
       Pcommand = "open \"" + sFileName + 
          "\" type mpegvideo alias " + alias + ""; 
       if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
        OnError(new ErrorEventArgs(Err)); 
       FName = sFileName; 
       Opened = true; 
       Playing = false; 
       Paused = false; 
       Pcommand = "set " + alias + " time format milliseconds"; 
       if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
        OnError(new ErrorEventArgs(Err)); 
       Pcommand = "set " + alias + " seek exactly on"; 
       if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
        OnError(new ErrorEventArgs(Err)); 
       CalculateLength(); 
       OnOpenFile(new OpenFileEventArgs(sFileName)); 
      } 
      else 
      { 
       this.Close(); 
       this.Open(sFileName); 
      } 
     } 

     private void stackLastFive(MP3Player latest) 
     { 
      if (lastFiveActive.Count() > 5) 
      { 
       lastFiveActive.Reverse(); 
       lastFiveActive = lastFiveActive.Take(4).ToList(); 
      } 
      lastFiveActive.Add(latest); 

     } 

     public void Play() 
     { 
      if (Opened) 
      { 
       if (!Playing) 
       { 
        Playing = true; 
        Pcommand = "play " + alias + ""; 
        if (Loop) Pcommand += " REPEAT"; 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
        OnPlayFile(new PlayFileEventArgs()); 
       } 
       else 
       { 
        if (!Paused) 
        { 
         Pcommand = "seek " + alias + " to start"; 
         if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
          OnError(new ErrorEventArgs(Err)); 
         Pcommand = "play " + alias + ""; 
         if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
          OnError(new ErrorEventArgs(Err)); 
         OnPlayFile(new PlayFileEventArgs()); 
        } 
        else 
        { 
         Paused = false; 
         Pcommand = "play " + alias + ""; 
         if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
          OnError(new ErrorEventArgs(Err)); 
         OnPlayFile(new PlayFileEventArgs()); 
        } 
       } 
       stackLastFive(this); 
      } 
     } 

     public void Pause() 
     { 
      if (Opened) 
      { 
       if (!Paused) 
       { 
        Paused = true; 
        Pcommand = "pause " + alias + ""; 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
        OnPauseFile(new PauseFileEventArgs()); 
       } 
       else 
       { 
        Paused = false; 
        Pcommand = "play " + alias + ""; 
        if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
        OnPlayFile(new PlayFileEventArgs()); 
       } 
      } 
     } 

     public void Stop() 
     { 
      if (Opened && Playing) 
      { 
       Playing = false; 
       Paused = false; 
       Pcommand = "seek " + alias + " to start"; 
       if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
        OnError(new ErrorEventArgs(Err)); 
       Pcommand = "stop " + alias + ""; 
       if ((Err = mciSendString(Pcommand, null, 0, IntPtr.Zero)) != 0) 
        OnError(new ErrorEventArgs(Err)); 
       currentlyActive.Remove(this); 
       OnStopFile(new StopFileEventArgs()); 
      } 
     } 

     public ulong CurrentPosition 
     { 
      get 
      { 
       if (Opened && Playing) 
       { 
        StringBuilder s = new StringBuilder(128); 
        Pcommand = "status " + alias + " position"; 
        if ((Err = mciSendString(Pcommand, s, 128, IntPtr.Zero)) != 0) 
         OnError(new ErrorEventArgs(Err)); 
        return Convert.ToUInt64(s.ToString()); 
       } 
       else return 0; 
      } 
     } 

     #endregion 

     #region Event Handling 

     public delegate void OpenFileEventHandler(Object sender, 
          OpenFileEventArgs oea); 

     public delegate void PlayFileEventHandler(Object sender, 
          PlayFileEventArgs pea); 

     public delegate void PauseFileEventHandler(Object sender, 
          PauseFileEventArgs paea); 

     public delegate void StopFileEventHandler(Object sender, 
             StopFileEventArgs sea); 

     public delegate void CloseFileEventHandler(Object sender, 
             CloseFileEventArgs cea); 

     public delegate void ErrorEventHandler(Object sender, 
             ErrorEventArgs eea); 

     public event OpenFileEventHandler OpenFile; 

     public event PlayFileEventHandler PlayFile; 

     public event PauseFileEventHandler PauseFile; 

     public event StopFileEventHandler StopFile; 

     public event CloseFileEventHandler CloseFile; 

     public event ErrorEventHandler Error; 

     protected virtual void OnOpenFile(OpenFileEventArgs oea) 
     { 
      if (OpenFile != null) OpenFile(this, oea); 
     } 

     protected virtual void OnPlayFile(PlayFileEventArgs pea) 
     { 
      if (PlayFile != null) PlayFile(this, pea); 
     } 

     protected virtual void OnPauseFile(PauseFileEventArgs paea) 
     { 
      if (PauseFile != null) PauseFile(this, paea); 
     } 

     protected virtual void OnStopFile(StopFileEventArgs sea) 
     { 
      if (StopFile != null) StopFile(this, sea); 
     } 

     protected virtual void OnCloseFile(CloseFileEventArgs cea) 
     { 
      if (CloseFile != null) CloseFile(this, cea); 
      if (currentlyActive.Contains(this)) 
      { 
       currentlyActive.Remove(this); 
      } 
     } 

     protected virtual void OnError(ErrorEventArgs eea) 
     { 
      if (Error != null) Error(this, eea); 
     } 


    } 

    public class OpenFileEventArgs : EventArgs 
    { 
     public OpenFileEventArgs(string filename) 
     { 
      this.FileName = filename; 
     } 
     public readonly string FileName; 
    } 

    public class PlayFileEventArgs : EventArgs 
    { 
     public PlayFileEventArgs() 
     { 

     } 
    } 

    public class PauseFileEventArgs : EventArgs 
    { 
     public PauseFileEventArgs() 
     { 
     } 
    } 

    public class StopFileEventArgs : EventArgs 
    { 
     public StopFileEventArgs() 
     { 
     } 
    } 

    public class CloseFileEventArgs : EventArgs 
    { 
     public CloseFileEventArgs() 
     { 
     } 
    } 

    public class ErrorEventArgs : EventArgs 
    { 
     public ErrorEventArgs(long Err) 
     { 
      this.ErrNum = Err; 
     } 

     public readonly long ErrNum; 
    } 
    #endregion 
}