C#

private const int WMGraphNotify = 0x0400 + 13;
        private const int VolumeFull = 0;
        private const int VolumeSilence = -10000;

        private IGraphBuilder graphBuilder = null;
        private IMediaControl mediaControl = null;
        private IMediaEventEx mediaEventEx = null;
        private IVideoWindow videoWindow = null;
        private IBasicAudio basicAudio = null;
        private IBasicVideo basicVideo = null;
        private IMediaSeeking mediaSeeking = null;
        private IMediaPosition mediaPosition = null;
        private IVideoFrameStep frameStep = null;
        private string filename = string.Empty;
        private bool isAudioOnly = false;
        private bool isFullScreen = false;
        private int currentVolume = VolumeFull;
        private PlayState currentState = PlayState.Stopped;
        private double currentPlaybackRate = 1.0;
        private bool m_bTracking;
        private IntPtr hDrain = IntPtr.Zero;
        private AMSeekingSeekingCapabilities seek;
        private double tDuration;

public void OpenPlayFile(string filename)
        {
            StopClip();
            CloseInterfaces();

            int hr = 0;

            if (filename == string.Empty)
                return;

            this.graphBuilder = (IGraphBuilder)new FilterGraph();

            // Have the graph builder construct its the appropriate graph automatically
            hr = this.graphBuilder.RenderFile(filename, null);
            DsError.ThrowExceptionForHR(hr);

            // QueryInterface for DirectShow interfaces
            this.mediaControl = (IMediaControl)this.graphBuilder;
            this.mediaEventEx = (IMediaEventEx)this.graphBuilder;
            this.mediaSeeking = (IMediaSeeking)this.graphBuilder;
            this.mediaPosition = (IMediaPosition)this.graphBuilder;
            
            // Query for video interfaces, which may not be relevant for audio files
            this.videoWindow = this.graphBuilder as IVideoWindow;
            this.basicVideo = this.graphBuilder as IBasicVideo;

            // Query for audio interfaces, which may not be relevant for video-only files
            this.basicAudio = this.graphBuilder as IBasicAudio;

            // Is this an audio-only file (no video component)?
            CheckVisibility();

            // Have the graph signal event via window callbacks for performance
            hr = this.mediaEventEx.SetNotifyWindow(this.Handle, WMGraphNotify, IntPtr.Zero);
            DsError.ThrowExceptionForHR(hr);

            if (!this.isAudioOnly)
            {
                // Setup the video window
                hr = this.videoWindow.put_Owner(this.Handle);
                DsError.ThrowExceptionForHR(hr);

                hr = this.videoWindow.put_WindowStyle(WindowStyle.Child | WindowStyle.ClipSiblings | WindowStyle.ClipChildren);
                DsError.ThrowExceptionForHR(hr);

                hr = InitVideoWindow(1, 1);
                DsError.ThrowExceptionForHR(hr);

                GetFrameStepInterface();
            }
            else
            {
                // Initialize the default player size and enable playback menu items
                hr = InitPlayerWindow();
                DsError.ThrowExceptionForHR(hr);
            }

            // Complete window initialization
            this.isFullScreen = false;
            this.currentPlaybackRate = 1.0;

            this.Focus();

            // Run the graph to play the media file
            hr = this.mediaControl.Run();
            DsError.ThrowExceptionForHR(hr);

            this.currentState = PlayState.Running;

            hr = this.mediaSeeking.GetCapabilities(out seek);
            DsError.ThrowExceptionForHR(hr);

            if (seek != AMSeekingSeekingCapabilities.None)
            {
                hr = mediaPosition.get_Duration(out tDuration);
                DsError.ThrowExceptionForHR(hr);

                tbSeekBar.Enabled = true;
                btnRewind.Enabled = true;
                btnForward.Enabled = true;
                timer.Enabled = true;
            }
            else
            {
                tbSeekBar.Enabled = false;
                btnRewind.Enabled = false;
                btnForward.Enabled = false;
                timer.Enabled = false;
            }
        }

[DllImport("winmm.dll",CharSet=CharSet.Auto)]
        private static extern uint mciSendString([MarshalAs(UnmanagedType.LPTStr)] string command,
                                                 StringBuilder returnValue,
                                                 int returnLength,
                                                 IntPtr winHandle);

        [DllImport("winmm.dll", CharSet = CharSet.Auto)]
        private static extern int mciGetErrorString(uint errorCode, StringBuilder errorText, int errorTextSize);

[DllImport("Kernel32.dll", CharSet=CharSet.Auto)]
        private static extern int GetShortPathName([MarshalAs(UnmanagedType.LPTStr)] string longPath,
                                                   [MarshalAs(UnmanagedType.LPTStr)] StringBuilder shortPath,
                                                    int length);

 // Stop recording
        private void StopRecording()
        {
            // Save recorded voice
            string shortPath = this.shortPathName();
            string formatShortPath = string.Format("save recsound \"{0}\"", shortPath);
            uint result = 0;
            StringBuilder errorTest = new StringBuilder(256);

            // C:\DOCUME~1\Steve\APPLIC~1\Test.wav
            // Fails
            result = mciSendString(string.Format("{0}", formatShortPath), null, 0, IntPtr.Zero);
            mciGetErrorString(result, errorTest, errorTest.Length);

            // command line convention - fails
            result = mciSendString("save recsound \"C:\\DOCUME~1\\Steve\\APPLIC~1\\Test.wav\"", null, 0, IntPtr.Zero);
            mciGetErrorString(result, errorTest, errorTest.Length);

            // 8.3 short format - fails
            result = mciSendString(@"save recsound C:\DOCUME~1\Steve\APPLIC~1\Test.wav", null, 0, IntPtr.Zero);
            mciGetErrorString(result, errorTest, errorTest.Length);

            // Save to C drive works everytime.
            result = mciSendString(@"save recsound C:\Test.wav", null, 0, IntPtr.Zero);
            mciGetErrorString(result, errorTest, errorTest.Length);

            mciSendString("close recsound ", null, 0, IntPtr.Zero);
        }


// Get the short path name so that the mciSendString can save the recorded wave file
        private string shortPathName()
        {
            string shortPath = string.Empty;
            long length = 0;
            StringBuilder buffer = new StringBuilder(256);

            // Get the length of the path
            length = GetShortPathName(this.saveRecordingPath, buffer, 256);

            shortPath = buffer.ToString();

            return shortPath;
        }