public abstract class Duration
{
    /// <summary>
    /// Abstract method of getting duration(ms) of audio or video
    /// </summary>
    /// <param name="filePath">audio/video's path</param>
    /// <returns>Duration in original format, duration in milliseconds</returns>
    public abstract Tuple<string, long> GetDuration(string filePath);

    /// <summary>
    /// Convert format of "00:10:16" and "00:00:19.82" into milliseconds
    /// </summary>
    /// <param name="formatTime"></param>
    /// <returns>Time in milliseconds</returns>
    public long GetTimeInMillisecond(string formatTime)
    {
        double totalMilliSecends = 0;

        if (!string.IsNullOrEmpty(formatTime))
        {
            string[] timeParts = formatTime.Split(':');
            totalMilliSecends = Convert.ToInt16(timeParts[0]) * 60 * 60 * 1000
                + Convert.ToInt16(timeParts[1]) * 60 * 1000
                + Math.Round(double.Parse(timeParts[2]) * 1000);
        }

        return (long)totalMilliSecends;
    }
}

public class ByNAudio : Duration
{
    /// <summary>
    /// Get duration(ms) of audio or video by NAudio.dll
    /// </summary>
    /// <param name="filePath">audio/video's path</param>
    /// <returns>Duration in original format, duration in milliseconds</returns>
    /// <remarks>return value from NAudio.dll is in format of: "00:00:19.820"</remarks>
    public override Tuple<string, long> GetDuration(string filePath)
    {
        TimeSpan ts;
        try
        {
            using (AudioFileReader audioFileReader = new AudioFileReader(filePath))
            {
                ts = audioFileReader.TotalTime;
            }
        }
        catch (Exception)
        {
            /* As NAudio is mainly used for processing audio, so some formats may not surport,
                * just use 00:00:00 instead for these cases.
                */
            ts = new TimeSpan();
            //throw ex;
        }

        return Tuple.Create(ts.ToString(), GetTimeInMillisecond(ts.ToString()));
    }
}

public class ByShell32 : Duration
{
    /// <summary>
    /// Get duration(ms) of audio or video by Shell32.dll
    /// </summary>
    /// <param name="filePath">audio/video's path</param>
    /// <returns>Duration in original format, duration in milliseconds</returns>
    /// <remarks>return value from Shell32.dll is in format of: "00:10:16"</remarks>
    public override Tuple<string, long> GetDuration(string filePath)
    {
        try
        {
            string dir = Path.GetDirectoryName(filePath);

            // From Add Reference --> COM 
            Shell32.Shell shell = new Shell32.Shell();
            Shell32.Folder folder = shell.NameSpace(dir);
            Shell32.FolderItem folderitem = folder.ParseName(Path.GetFileName(filePath));

            string duration = null;

            // Deal with different versions of OS
            if (Environment.OSVersion.Version.Major >= 6)
            {
                duration = folder.GetDetailsOf(folderitem, 27);
            }
            else
            {
                duration = folder.GetDetailsOf(folderitem, 21);
            }

            duration = string.IsNullOrEmpty(duration) ? "00:00:00" : duration;
            return Tuple.Create(duration, GetTimeInMillisecond(duration));
        }
        catch (Exception ex)
        {
            throw ex;
        }
    }
}

public class ByFFmpeg : Duration
    {
        private StringBuilder result = new StringBuilder(); // Store output text of ffmpeg

        /// <summary>
        /// Get duration(ms) of audio or video by FFmpeg.exe
        /// </summary>
        /// <param name="filePath">audio/video's path</param>
        /// <returns>Duration in original format, duration in milliseconds</returns>
        /// <remarks>return value from FFmpeg.exe is in format of: "00:00:19.82"</remarks>
        public override Tuple<string, long> GetDuration(string filePath)
        {
            GetMediaInfo(filePath);
            string duration = MatchDuration(result.ToString());

            return Tuple.Create(duration, GetTimeInMillisecond(duration));
        }

        // Call exe async
        private void GetMediaInfo(string filePath)
        {
            result.Clear(); // Clear result to avoid previous value's interference

            Process p = new Process();
            p.StartInfo.FileName = "ffmpeg.exe";
            p.StartInfo.RedirectStandardError = true;
            p.StartInfo.UseShellExecute = false;
            p.StartInfo.Arguments = string.Concat("-i ", filePath);
            p.ErrorDataReceived += new DataReceivedEventHandler(OutputCallback);

            p.Start();
            p.BeginErrorReadLine();

            p.WaitForExit();
            p.Close();
            p.Dispose();
        }

        // Callback funciton of output stream
        private void OutputCallback(object sender, DataReceivedEventArgs e)
        {
            if (!string.IsNullOrEmpty(e.Data))
            {
                result.Append(e.Data);
            }
        }

        // Match the 'Duration' section in "ffmpeg -i filepath" output text
        private string MatchDuration(string text)
        {
            string pattern = @"Duration:\s(\d{2}:\d{2}:\d{2}.\d+)";
            Match m = Regex.Match(text, pattern);

            return m.Groups.Count == 2 ? m.Groups[1].ToString() : string.Empty;
        }
    }