C# SoundPlayer.LoadAsync方法代码示例

 /// <summary>
 /// Plays a stream Asychronously using the System.Media.SoundPlayer Object.
 /// </summary>
 /// <param name="S">Any stream, ex: a wav sound resource.</param>
 public void QuickPlay(System.IO.Stream S)
 {
     SoundPlayer wavPlayer = new SoundPlayer();
     wavPlayer.Stream = S;
     wavPlayer.LoadCompleted += new AsyncCompletedEventHandler(wavPlayer_LoadCompleted);
     wavPlayer.LoadAsync();
 }

	    public Sound(Stream strm)
	    {
           sound = new SoundPlayer(strm);
           sound.LoadAsync();
           sound.LoadCompleted += sound_LoadCompleted;
           playing = false;
	    }

        // We want to control how depth data gets converted into false-color data
        // for more intuitive visualization, so we keep 32-bit color frame buffer versions of
        // these, to be updated whenever we receive and process a 16-bit frame.
        /*const int RED_IDX = 2;
        const int GREEN_IDX = 1;
        const int BLUE_IDX = 0;
        byte[] depthFrame32 = new byte[320 * 240 * 4];*/
        public ExerciseView(Exercise ex)
        {
            InitializeComponent();

            this.ex = ex;

            statusText.Text = ex.statusMessage;

            passSound = new SoundPlayer("Sounds/ExercisePass.wav");
            passSound.LoadAsync();
            failSound = new SoundPlayer("Sounds/ExerciseFail.wav");
            failSound.LoadAsync();

            #if DEBUG
            lastTime = DateTime.Now;

            fpsLabel = new Label();
            fpsLabel.Content = "FPS:";
            fpsLabel.FontSize = (double)Application.Current.Resources["SmallButtonFont"];
            fpsLabel.HorizontalContentAlignment = HorizontalAlignment.Center;
            fpsLabel.HorizontalAlignment = HorizontalAlignment.Left;
            bottomPanel.Children.Insert(0, fpsLabel);
            #endif

            #if AUDIOUI
            SharedContent.Sr.registerSpeechCommand(SharedContent.Commands.Stop, selectedResponse);
            #endif

            //SharedContent.Nui.DepthFrameReady += new EventHandler<ImageFrameReadyEventArgs>(nuiDepthFrameReady);
            SharedContent.Nui.SkeletonFrameReady += new EventHandler<SkeletonFrameReadyEventArgs>(nuiSkeletonFrameReady);
            SharedContent.Nui.VideoFrameReady += new EventHandler<ImageFrameReadyEventArgs>(nuiColorFrameReady);
        }

 internal MainWindow(Archive a)
 {
     InitializeComponent();
       archive = a;
       if(!string.IsNullOrWhiteSpace(archive.settings.sound.backgroundSoundLoc)) {
     main = new SoundPlayer();
     main.SoundLocation = archive.settings.sound.backgroundSoundLoc.RelativeTo(Program.ArchivePath(archive));
     main.PlayLooping();
       }
       if(!string.IsNullOrWhiteSpace(archive.settings.sound.correctSoundLoc)) {
     yes = new SoundPlayer();
     yes.SoundLocation = archive.settings.sound.correctSoundLoc.RelativeTo(Program.ArchivePath(archive));
     yes.LoadAsync();
       }
       if(!string.IsNullOrWhiteSpace(archive.settings.sound.wrongSoundLoc)) {
     no = new SoundPlayer();
     no.SoundLocation = archive.settings.sound.wrongSoundLoc.RelativeTo(Program.ArchivePath(archive));
     no.LoadAsync();
       }
       Text = a.name;
       BackColor = archive.settings.backgroundColor;
       if(!string.IsNullOrWhiteSpace(archive.settings.backgroundLoc)) {
     BackgroundImage = archive.settings.background ?? Extensions.LoadImage(Program.ArchivePath(archive), archive.settings.backgroundLoc);
       }
       Current = new ModeSelect();
 }

        /// <summary>
        /// Start the audio playback which will keep the SPDIF link alive.
        /// </summary>
        public void start()
        {

            sound = new SoundPlayer(Properties.Resources.silence);
            sound.LoadCompleted += new AsyncCompletedEventHandler(wavPlayer_LoadCompleted);
            sound.LoadAsync();
            isSoundStarted = true;
        }

        public AppTarget(UserModel userModel)
        {
            _UserModel = userModel;

            _KeyboardSimulator = new KeyboardSimulator();
            _MouseSimulator = new MouseSimulator();
            _InputDeviceState = new WindowsInputDeviceStateAdaptor();
            _MediaPlayer = new SoundPlayer("letter.wav");
            _MediaPlayer.LoadAsync();
        }

 public AudioPlayer(string SoundFileName)
 {
     var filePath = Directory.GetCurrentDirectory() + @"\Sounds" + SoundFileName;
             if (! File.Exists(filePath))
                 {
                     return;
                 }
             audiPlayer = new SoundPlayer {SoundLocation = filePath};
             audiPlayer.LoadAsync(); //async, because it could be a big file, and we dont want to lock up the system.
 }

        private void button1_Click(object sender, EventArgs e)
        {
            // Hook up the Elapsed event for the timer.
            int milli = (int)((217f / AV.spectralGraph.Length)* 1000);
            dispatcherTimer = new DispatcherTimer();
            dispatcherTimer.Tick += new EventHandler(dispatcherTimer_Tick);
            dispatcherTimer.Interval = new TimeSpan(0, 0, 0, 0, milli);

            wavPlayer = new SoundPlayer();
            wavPlayer.SoundLocation = audiofilename;
            wavPlayer.LoadCompleted += new AsyncCompletedEventHandler(wavPlayer_LoadCompleted);

            dispatcherTimer.Start();
            wavPlayer.LoadAsync();
        }

        public static void PreLoadSound(string fileName)
        {
            SoundPlayer sp;
            if (allSounds.TryGetValue(fileName, out sp)) return;

            try {
                allSounds[fileName] = null;
                sp = new SoundPlayer(fileName);
                sp.LoadCompleted += (s, e) => { if( !e.Cancelled && e.Error == null ) allSounds[fileName] = sp; };
                sp.LoadAsync();
            } catch (Exception ex) {
                MessageBox.Show("Error when loading " + fileName + ": " + ex.Message);
                Environment.Exit(0);
            }
        }

 public CLogic(MOptions option)
 {
     _SoundPlayer = new SoundPlayer();
     _CNote = new CNote(3);
     LeftShadow = new CShadow(250,150);
     RightShadow = new CShadow(450,150);
     _CMusicHit = new CMusicHit(option.MusicHitFilePath);
     _SoundPlayer.SoundLocation = @option.MusicMediaFilePath;
     //_SoundPlayer.SoundLocation = @"D:\Gangnam.wav";
     _SoundPlayer.LoadAsync();
     _CNote.Speed = _CMusicHit.Speed;
     _TotalTime = _CMusicHit.EndTime;
     Score = 0;
     Progress = 0;
     isStart = false;
 }

        // constructor
        public mainScreen(int gameId)
        {
            this.gameId = gameId;

            InitializeComponent();
            //territories = new List<Territory>();
            //pictureBox1.Image = Image.FromFile("images/map1.png");

            DrawArea = new Bitmap(Image.FromFile("images/map2.png"));
            //DrawArea = new Bitmap(pictureBox1.Size.Width, pictureBox1.Size.Height);
            pictureBox1.Image = DrawArea;

            yourTurn = false;

            string soundLocation = "sounds/explosion-01.wav";
            player = new SoundPlayer(soundLocation);

            // Load the .wav file.
            player.LoadAsync();
        }

      /// <summary>
      /// Adds or replaces a sound by name and file path.
      /// </summary>
      /// <param name="soundName">The name of the sound to load.</param>
      /// <param name="filePath">The path of the sound file.</param>
      /// <returns>True upon error, false otherwise.</returns>
      public static Status SetSound(SoundEffect soundName, string filePath)
      {
         // If the path is bad, 
         if (String.IsNullOrEmpty(filePath) == true || File.Exists(filePath) == false)
         {
            s_log.ErrorFormat("Bad path provided: {0}", filePath);
            return Status.Failure;
         }

         // Make the SoundPlayer and save the sound name as the Tag.
         SoundPlayer player = new SoundPlayer(filePath);
         player.Tag = soundName;

         // Start loading the file.
         s_log.DebugFormat("Starting load of sound {0}.", player.SoundLocation);
         player.LoadCompleted += SoundLoadComplete;
         player.LoadAsync();

         return Status.Success;
      }

        /// <summary>
        /// Adds a new wav file to the available sounds for tracking.
        /// </summary>
        /// <param name="soundPath">Full path of the new sound.</param>
        public static void Add(string soundPath)
        {
            var newSound = new FileInfo(soundPath);

            if (!newSound.Exists || !newSound.Extension.Equals(".wav")) return;

            var name = newSound.Name;
            var index = 0;

            while (Sounds.ContainsKey(name))
            {
                name = string.Format("{0}_{1:D3}.wav", name.Remove(-4), index++);
            }

            newSound = newSound.CopyTo(string.Format("{0}\\{1}", SOUND_DIRECTORY, name));
            var sound = new SoundPlayer(newSound.FullName);
            sound.LoadAsync();

            Sounds.Add(name, sound);
        }

        public static void Play(Button sender, string path)
        {
            var button = sender;

            if (!_playing)
            {
                _sp = new SoundPlayer();
                _sp.Stop();
                _sp.SoundLocation = path;
                _sp.LoadAsync();
                _sp.Play();
                _playing = true;
                button.Content = "Stop";
            }
            else
            {
                _sp.Stop();
                _playing = false;
                button.Content = "Play";
            }
        }

        /// <summary>
        /// Loads each of the sounds available for tracking use to memory.
        /// </summary>
        public static void Load()
        {
            // Only load if not yet loaded.
            if (Sounds != null)
                return;

            Sounds = new Dictionary<string, SoundPlayer>();

            var dir = new DirectoryInfo(SOUND_DIRECTORY);

            foreach (var fileInfo in dir.GetFiles("*.wav"))
            {
                var s = new SoundPlayer(fileInfo.FullName);
                s.LoadAsync();

                Sounds.Add(fileInfo.Name, s);
            }

            if (Sounds.Count > 0)
                Default = Sounds.First().Value;
        }