How do I correctly retrieve the open command associated with an extension on Windows?

Question

I'm trying to figure out the executable used to open files of a given extension, so I can display that executable's icon if the extension doesn't have one.

I'm aware of the open verb in the HKEY_CLASSES_ROOT registry key for the file type, but I've found that it's value is not always correct.

For example, I'm currently running Windows in Parallels on OS X. The default association of PDF files was Safari. I changed the default association, through explorer, to Adobe Reader. The open verb in the registry is still Safari, but when I double click a PDF file, it opens with Adobe Reader. Both the 32-bit and 64-bit registry have the same values.

Is there a better way to retrieve the association of a file type, either with .NET or winapi?

The biggest problem is that there are "classes" of file types and then there are extensions. They can be combined in various ways. — 0xC0000022L, Nov 19 '12 at 20:10
Is there some sort of .NET function or winapi call that can deal with this? — Collin Dauphinee, Nov 19 '12 at 20:12
see my answer. I am not quite at home in the .NET world, but I am giving a few pointers in my answer that may even help you find an existing .NET class for the Win32/Shell API stuff described. — 0xC0000022L, Nov 19 '12 at 20:21

score 3 · Accepted Answer · edited May 23 '17 at 12:33

Your best bet is probably to use the Assoc* group of functions, such as AssocQueryKey() and AssocQueryString() via PInvoke. I don't know, however, whether one of the many classes that come with the .NET framework in its many incarnations wraps this for you already. But the Shell API gives you an option to retrieve this information.

Also note the remark section which states that the above functions are wrappers for the IQueryAssociations interface, which makes it even more likely you have another more straight route to what you want from within .NET.

Old-style function was this one: FindExecutable(). Don't use it, though. It uses the same flawed error code magic as ShellExecute().

Also see the answers for Windows: List and Launch applications associated with an extension

score 2 · Answer 2 · answered Apr 29 '14 at 18:23

My code that include check to prevent from some common errors... Hope it helps :-)

using System;
using System.Diagnostics;
using System.IO;
using System.Runtime.InteropServices;
using System.Text;

namespace HQ.Util.Unmanaged
{
    /// <summary>
    /// Usage: string executablePath = FileAssociation.GetExecFileAssociatedToExtension(pathExtension, "open");
    /// Usage: string command FileAssociation.GetExecCommandAssociatedToExtension(pathExtension, "open");
    /// </summary>
    public static class FileAssociation
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="ext"></param>
        /// <param name="verb"></param>
        /// <returns>Return null if not found</returns>
        public static string GetExecCommandAssociatedToExtension(string ext, string verb = null)
        {
            if (ext[0] != '.')
            {
                ext = "." + ext;
            }

            string  executablePath = FileExtentionInfo(AssocStr.Command, ext, verb);

            // Ensure to not return the default OpenWith.exe associated executable in Windows 8 or higher
            if (!string.IsNullOrEmpty(executablePath) && File.Exists(executablePath) &&
                !executablePath.ToLower().EndsWith(".dll"))
            {
                if (executablePath.ToLower().EndsWith("openwith.exe"))
                {
                    return null; // 'OpenWith.exe' is th windows 8 or higher default for unknown extensions. I don't want to have it as associted file
                }
                return executablePath;
            }
            return executablePath;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="ext"></param>
        /// <param name="verb"></param>
        /// <returns>Return null if not found</returns>
        public static string GetExecFileAssociatedToExtension(string ext, string verb = null)
        {
            if (ext[0] != '.')
            {
                ext = "." + ext;
            }

            string executablePath = FileExtentionInfo(AssocStr.Executable, ext, verb); // Will only work for 'open' verb
            if (string.IsNullOrEmpty(executablePath))
            {
                executablePath = FileExtentionInfo(AssocStr.Command, ext, verb); // required to find command of any other verb than 'open'

                // Extract only the path
                if (!string.IsNullOrEmpty(executablePath) && executablePath.Length > 1) 
                {
                    if (executablePath[0] == '"')
                    {
                        executablePath = executablePath.Split('\"')[1];
                    }
                    else if (executablePath[0] == '\'')
                    {
                        executablePath = executablePath.Split('\'')[1];
                    }
                }
            }

            // Ensure to not return the default OpenWith.exe associated executable in Windows 8 or higher
            if (!string.IsNullOrEmpty(executablePath) && File.Exists(executablePath) &&
                !executablePath.ToLower().EndsWith(".dll"))
            {
                if (executablePath.ToLower().EndsWith("openwith.exe"))
                {
                    return null; // 'OpenWith.exe' is th windows 8 or higher default for unknown extensions. I don't want to have it as associted file
                }
                return executablePath;
            }
            return executablePath;
        }

        [DllImport("Shlwapi.dll", SetLastError = true, CharSet = CharSet.Auto)]
        static extern uint AssocQueryString(AssocF flags, AssocStr str, string pszAssoc, string pszExtra, [Out] StringBuilder pszOut, [In][Out] ref uint pcchOut);

        private static string FileExtentionInfo(AssocStr assocStr, string doctype, string verb)
        {
            uint pcchOut = 0;
            AssocQueryString(AssocF.Verify, assocStr, doctype, verb, null, ref pcchOut);

            Debug.Assert(pcchOut != 0);
            if (pcchOut == 0)
            {
                return "";
            }

            StringBuilder pszOut = new StringBuilder((int)pcchOut);
            AssocQueryString(AssocF.Verify, assocStr, doctype, verb, pszOut, ref pcchOut);
            return pszOut.ToString();
        }

        [Flags]
        public enum AssocF
        {
            Init_NoRemapCLSID = 0x1,
            Init_ByExeName = 0x2,
            Open_ByExeName = 0x2,
            Init_DefaultToStar = 0x4,
            Init_DefaultToFolder = 0x8,
            NoUserSettings = 0x10,
            NoTruncate = 0x20,
            Verify = 0x40,
            RemapRunDll = 0x80,
            NoFixUps = 0x100,
            IgnoreBaseClass = 0x200
        }

        public enum AssocStr
        {
            Command = 1,
            Executable,
            FriendlyDocName,
            FriendlyAppName,
            NoOpen,
            ShellNewValue,
            DDECommand,
            DDEIfExec,
            DDEApplication,
            DDETopic
        }



    }
}

Nice work. Came here after FindExecutableA stopped working for me. — Derek, Feb 19 '19 at 14:53

score -1 · Answer 3 · answered Nov 19 '12 at 20:08

-1

You also need to check HKEY_USERS\{User}\Software\Classes. Users can override their own default application.

answered Nov 19 '12 at 20:08

Middas

1,862
1
29
44

The `HKEY_USERS\{guid}_CLASSES` and `HKEY_USERS\{guid}\Software\Classes` key in my registry has old (also incorrect) associations. – Collin Dauphinee Nov 19 '12 at 20:10

How do I correctly retrieve the open command associated with an extension on Windows?

3 Answers3