/// <summary>
        /// Check if a Microsoft Redistributable Package is installed.
        /// </summary>
        /// <param name="redistributableVersion">The package version to detect.</param>
        /// <returns><c>true</c> if the package is installed, otherwise <c>false</c></returns>
        public static bool IsInstalled(RedistributablePackageVersion redistributableVersion)
        {
            try
            {
                switch (redistributableVersion)
                {
                case RedistributablePackageVersion.VC2015to2019x86:
                    var parametersVc2015to2019x86 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\x86", false);
                    if (parametersVc2015to2019x86 == null)
                    {
                        return(false);
                    }
                    var vc2015to2019x86Version = parametersVc2015to2019x86.GetValue("Version");
                    if (((string)vc2015to2019x86Version).StartsWith("v14.2"))
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2015to2019x64:
                    var parametersVc2015to2019x64 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\VisualStudio\14.0\VC\Runtimes\x64", false);
                    if (parametersVc2015to2019x64 == null)
                    {
                        return(false);
                    }
                    var vc2015to2019x64Version = parametersVc2015to2019x64.GetValue("Version");
                    if (((string)vc2015to2019x64Version).StartsWith("v14.2"))
                    {
                        return(true);
                    }
                    break;
                }
                return(false);
            }
            catch (Exception)
            {
                return(false);
            }
        }
Beispiel #2
0
        /// <summary>
        /// Check if a Microsoft Redistributable Package is installed.
        /// </summary>
        /// <param name="redistributableVersion">The package version to detect.</param>
        /// <returns><c>true</c> if the package is installed, otherwise <c>false</c></returns>
        public static bool IsInstalled(RedistributablePackageVersion redistributableVersion)
        {
            try
            {
                switch (redistributableVersion)
                {
                case RedistributablePackageVersion.VC2015to2019x86:
                    var parametersVc2015to2019x86 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\DevDiv\VC\Servicing\14.0\RuntimeMinimum", false);
                    if (parametersVc2015to2019x86 == null)
                    {
                        return(false);
                    }
                    var vc2015to2019x86Version = parametersVc2015to2019x86.GetValue("Version");
                    if (((string)vc2015to2019x86Version).StartsWith("14"))
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2015to2019x64:
                    var parametersVc2015to2019x64 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\DevDiv\VC\Servicing\14.0\RuntimeMinimum", false);
                    if (parametersVc2015to2019x64 == null)
                    {
                        return(false);
                    }
                    var vc2015to2019x64Version = parametersVc2015to2019x64.GetValue("Version");
                    if (((string)vc2015to2019x64Version).StartsWith("14"))
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2017x86:
                    var paths2017x86 = new List <string>
                    {
                        @"Installer\Dependencies\,,x86,14.0,bundle",
                        @"Installer\Dependencies\VC,redist.x86,x86,14.16,bundle"                                 //changed in 14.16.x
                    };
                    foreach (var path in paths2017x86)
                    {
                        var parametersVc2017x86 = Registry.ClassesRoot.OpenSubKey(path, false);
                        if (parametersVc2017x86 == null)
                        {
                            continue;
                        }
                        var vc2017x86Version = parametersVc2017x86.GetValue("Version");
                        if (vc2017x86Version == null)
                        {
                            return(false);
                        }
                        if (((string)vc2017x86Version).StartsWith("14"))
                        {
                            return(true);
                        }
                    }
                    break;

                case RedistributablePackageVersion.VC2017x64:
                    var paths2017x64 = new List <string>
                    {
                        @"Installer\Dependencies\,,amd64,14.0,bundle",
                        @"Installer\Dependencies\VC,redist.x64,amd64,14.16,bundle"                                 //changed in 14.16.x
                    };
                    foreach (var path in paths2017x64)
                    {
                        var parametersVc2017x64 = Registry.ClassesRoot.OpenSubKey(path, false);
                        if (parametersVc2017x64 == null)
                        {
                            continue;
                        }
                        var vc2017x64Version = parametersVc2017x64.GetValue("Version");
                        if (vc2017x64Version == null)
                        {
                            return(false);
                        }
                        if (((string)vc2017x64Version).StartsWith("14"))
                        {
                            return(true);
                        }
                    }
                    break;

                case RedistributablePackageVersion.VC2015x86:
                    var parametersVc2015x86 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Dependencies\{e2803110-78b3-4664-a479-3611a381656a}", false);
                    if (parametersVc2015x86 == null)
                    {
                        return(false);
                    }
                    var vc2015x86Version = parametersVc2015x86.GetValue("Version");
                    if (((string)vc2015x86Version).StartsWith("14"))
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2015x64:
                    var parametersVc2015x64 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Dependencies\{d992c12e-cab2-426f-bde3-fb8c53950b0d}", false);
                    if (parametersVc2015x64 == null)
                    {
                        return(false);
                    }
                    var vc2015x64Version = parametersVc2015x64.GetValue("Version");
                    if (((string)vc2015x64Version).StartsWith("14"))
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2013x86:
                    var parametersVc2013x86 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Dependencies\{f65db027-aff3-4070-886a-0d87064aabb1}", false);
                    if (parametersVc2013x86 == null)
                    {
                        return(false);
                    }
                    var vc2013x86Version = parametersVc2013x86.GetValue("Version");
                    if (((string)vc2013x86Version).StartsWith("12"))
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2013x64:
                    var parametersVc2013x64 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Dependencies\{050d4fc8-5d48-4b8f-8972-47c82c46020f}", false);
                    if (parametersVc2013x64 == null)
                    {
                        return(false);
                    }
                    var vc2013x64Version = parametersVc2013x64.GetValue("Version");
                    if (((string)vc2013x64Version).StartsWith("12"))
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2012x86:
                    var parametersVc2012x86 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Dependencies\{33d1fd90-4274-48a1-9bc1-97e33d9c2d6f}", false);
                    if (parametersVc2012x86 == null)
                    {
                        return(false);
                    }
                    var vc2012x86Version = parametersVc2012x86.GetValue("Version");
                    if (((string)vc2012x86Version).StartsWith("11"))
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2012x64:
                    var parametersVc2012x64 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Dependencies\{ca67548a-5ebe-413a-b50c-4b9ceb6d66c6}", false);
                    if (parametersVc2012x64 == null)
                    {
                        return(false);
                    }
                    var vc2012x64Version = parametersVc2012x64.GetValue("Version");
                    if (((string)vc2012x64Version).StartsWith("11"))
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2010x86:
                    var parametersVc2010x86 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Products\1D5E3C0FEDA1E123187686FED06E995A", false);
                    if (parametersVc2010x86 == null)
                    {
                        return(false);
                    }
                    var vc2010x86Version = parametersVc2010x86.GetValue("Version");
                    if ((int)vc2010x86Version > 1)
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2010x64:
                    var parametersVc2010x64 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Products\1926E8D15D0BCE53481466615F760A7F", false);
                    if (parametersVc2010x64 == null)
                    {
                        return(false);
                    }
                    var vc2010x64Version = parametersVc2010x64.GetValue("Version");
                    if ((int)vc2010x64Version > 1)
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2008x86:
                    var parametersVc2008x86 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Products\6E815EB96CCE9A53884E7857C57002F0", false);
                    if (parametersVc2008x86 == null)
                    {
                        return(false);
                    }
                    var vc2008x86Version = parametersVc2008x86.GetValue("Version");
                    if ((int)vc2008x86Version > 1)
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2008x64:
                    var parametersVc2008x64 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Products\67D6ECF5CD5FBA732B8B22BAC8DE1B4D", false);
                    if (parametersVc2008x64 == null)
                    {
                        return(false);
                    }
                    var vc2008x64Version = parametersVc2008x64.GetValue("Version");
                    if ((int)vc2008x64Version > 1)
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2005x86:
                    var parametersVc2005x86 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Products\c1c4f01781cc94c4c8fb1542c0981a2a", false);
                    if (parametersVc2005x86 == null)
                    {
                        return(false);
                    }
                    var vc2005x86Version = parametersVc2005x86.GetValue("Version");
                    if ((int)vc2005x86Version > 1)
                    {
                        return(true);
                    }
                    break;

                case RedistributablePackageVersion.VC2005x64:
                    var parametersVc2005x64 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Classes\Installer\Products\1af2a8da7e60d0b429d7e6453b3d0182", false);
                    if (parametersVc2005x64 == null)
                    {
                        return(false);
                    }
                    var vc2005x64Version = parametersVc2005x64.GetValue("Version");
                    if ((int)vc2005x64Version > 1)
                    {
                        return(true);
                    }
                    break;
                }
                return(false);
            }
            catch (Exception)
            {
                return(false);
            }
        }
Beispiel #3
0
        // Token: 0x0600003E RID: 62 RVA: 0x0000AC34 File Offset: 0x0000AC34
        public static bool IsInstalled(RedistributablePackageVersion redistributableVersion)
        {
            bool result;

            try
            {
                switch (redistributableVersion)
                {
                case RedistributablePackageVersion.VC2005x86:
                {
                    RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Products\\c1c4f01781cc94c4c8fb1542c0981a2a", false);
                    bool        flag        = registryKey == null;
                    if (flag)
                    {
                        return(false);
                    }
                    object value = registryKey.GetValue("Version");
                    bool   flag2 = (int)value > 1;
                    if (flag2)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2005x64:
                {
                    RegistryKey registryKey2 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Products\\1af2a8da7e60d0b429d7e6453b3d0182", false);
                    bool        flag3        = registryKey2 == null;
                    if (flag3)
                    {
                        return(false);
                    }
                    object value2 = registryKey2.GetValue("Version");
                    bool   flag4  = (int)value2 > 1;
                    if (flag4)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2008x86:
                {
                    RegistryKey registryKey3 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Products\\6E815EB96CCE9A53884E7857C57002F0", false);
                    bool        flag5        = registryKey3 == null;
                    if (flag5)
                    {
                        return(false);
                    }
                    object value3 = registryKey3.GetValue("Version");
                    bool   flag6  = (int)value3 > 1;
                    if (flag6)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2008x64:
                {
                    RegistryKey registryKey4 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Products\\67D6ECF5CD5FBA732B8B22BAC8DE1B4D", false);
                    bool        flag7        = registryKey4 == null;
                    if (flag7)
                    {
                        return(false);
                    }
                    object value4 = registryKey4.GetValue("Version");
                    bool   flag8  = (int)value4 > 1;
                    if (flag8)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2010x86:
                {
                    RegistryKey registryKey5 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Products\\1D5E3C0FEDA1E123187686FED06E995A", false);
                    bool        flag9        = registryKey5 == null;
                    if (flag9)
                    {
                        return(false);
                    }
                    object value5 = registryKey5.GetValue("Version");
                    bool   flag10 = (int)value5 > 1;
                    if (flag10)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2010x64:
                {
                    RegistryKey registryKey6 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Products\\1926E8D15D0BCE53481466615F760A7F", false);
                    bool        flag11       = registryKey6 == null;
                    if (flag11)
                    {
                        return(false);
                    }
                    object value6 = registryKey6.GetValue("Version");
                    bool   flag12 = (int)value6 > 1;
                    if (flag12)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2012x86:
                {
                    RegistryKey registryKey7 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Dependencies\\{33d1fd90-4274-48a1-9bc1-97e33d9c2d6f}", false);
                    bool        flag13       = registryKey7 == null;
                    if (flag13)
                    {
                        return(false);
                    }
                    object value7 = registryKey7.GetValue("Version");
                    bool   flag14 = ((string)value7).StartsWith("11");
                    if (flag14)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2012x64:
                {
                    RegistryKey registryKey8 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Dependencies\\{ca67548a-5ebe-413a-b50c-4b9ceb6d66c6}", false);
                    bool        flag15       = registryKey8 == null;
                    if (flag15)
                    {
                        return(false);
                    }
                    object value8 = registryKey8.GetValue("Version");
                    bool   flag16 = ((string)value8).StartsWith("11");
                    if (flag16)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2013x86:
                {
                    RegistryKey registryKey9 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Dependencies\\{f65db027-aff3-4070-886a-0d87064aabb1}", false);
                    bool        flag17       = registryKey9 == null;
                    if (flag17)
                    {
                        return(false);
                    }
                    object value9 = registryKey9.GetValue("Version");
                    bool   flag18 = ((string)value9).StartsWith("12");
                    if (flag18)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2013x64:
                {
                    RegistryKey registryKey10 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Dependencies\\{050d4fc8-5d48-4b8f-8972-47c82c46020f}", false);
                    bool        flag19        = registryKey10 == null;
                    if (flag19)
                    {
                        return(false);
                    }
                    object value10 = registryKey10.GetValue("Version");
                    bool   flag20  = ((string)value10).StartsWith("12");
                    if (flag20)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2015x86:
                {
                    RegistryKey registryKey11 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Dependencies\\{e2803110-78b3-4664-a479-3611a381656a}", false);
                    bool        flag21        = registryKey11 == null;
                    if (flag21)
                    {
                        return(false);
                    }
                    object value11 = registryKey11.GetValue("Version");
                    bool   flag22  = ((string)value11).StartsWith("14");
                    if (flag22)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2015x64:
                {
                    RegistryKey registryKey12 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Dependencies\\{d992c12e-cab2-426f-bde3-fb8c53950b0d}", false);
                    bool        flag23        = registryKey12 == null;
                    if (flag23)
                    {
                        return(false);
                    }
                    object value12 = registryKey12.GetValue("Version");
                    bool   flag24  = ((string)value12).StartsWith("14");
                    if (flag24)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2017x86:
                {
                    List <string> list = new List <string>
                    {
                        "Installer\\Dependencies\\,,x86,14.0,bundle",
                        "Installer\\Dependencies\\VC,redist.x86,x86,14.16,bundle"
                    };
                    foreach (string name in list)
                    {
                        RegistryKey registryKey13 = Registry.ClassesRoot.OpenSubKey(name, false);
                        bool        flag25        = registryKey13 == null;
                        if (!flag25)
                        {
                            object value13 = registryKey13.GetValue("Version");
                            bool   flag26  = value13 == null;
                            if (flag26)
                            {
                                return(false);
                            }
                            bool flag27 = ((string)value13).StartsWith("14");
                            if (flag27)
                            {
                                return(true);
                            }
                        }
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2017x64:
                {
                    List <string> list2 = new List <string>
                    {
                        "Installer\\Dependencies\\,,amd64,14.0,bundle",
                        "Installer\\Dependencies\\VC,redist.x64,amd64,14.16,bundle"
                    };
                    foreach (string name2 in list2)
                    {
                        RegistryKey registryKey14 = Registry.ClassesRoot.OpenSubKey(name2, false);
                        bool        flag28        = registryKey14 == null;
                        if (!flag28)
                        {
                            object value14 = registryKey14.GetValue("Version");
                            bool   flag29  = value14 == null;
                            if (flag29)
                            {
                                return(false);
                            }
                            bool flag30 = ((string)value14).StartsWith("14");
                            if (flag30)
                            {
                                return(true);
                            }
                        }
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2015to2019x86:
                {
                    RegistryKey registryKey15 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\DevDiv\\VC\\Servicing\\14.0\\RuntimeMinimum", false);
                    bool        flag31        = registryKey15 == null;
                    if (flag31)
                    {
                        return(false);
                    }
                    object value15 = registryKey15.GetValue("Version");
                    bool   flag32  = ((string)value15).StartsWith("14");
                    if (flag32)
                    {
                        return(true);
                    }
                    break;
                }

                case RedistributablePackageVersion.VC2015to2019x64:
                {
                    RegistryKey registryKey16 = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\DevDiv\\VC\\Servicing\\14.0\\RuntimeMinimum", false);
                    bool        flag33        = registryKey16 == null;
                    if (flag33)
                    {
                        return(false);
                    }
                    object value16 = registryKey16.GetValue("Version");
                    bool   flag34  = ((string)value16).StartsWith("14");
                    if (flag34)
                    {
                        return(true);
                    }
                    break;
                }
                }
                result = false;
            }
            catch (Exception)
            {
                result = false;
            }
            return(result);
        }
        /// <summary>
        /// Check if a Microsoft Redistributable Package is installed.
        /// </summary>
        /// <param name="redistVersion">The package version to detect.</param>
        /// <returns><c>true</c> if the package is installed, otherwise <c>false</c></returns>
        private bool IsInstalled(RedistributablePackageVersion redistVersion)
        {
            try
            {
                if (redistVersion.Equals(RedistributablePackageVersion.VC2015to2019x86) ||
                    redistVersion.Equals(RedistributablePackageVersion.VC2015to2019x64))
                {
                    string _subKey      = @"SOFTWARE\Microsoft\DevDiv\VC\Servicing\14.0\RuntimeMinimum";
                    string _startNumber = "14";
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2017x86))
                {
                    var _paths = new List <string>
                    {
                        @"Installer\Dependencies\,,x86,14.0,bundle",
                        @"Installer\Dependencies\VC,redist.x86,x86,14.16,bundle"                                 //changed in 14.16.x
                    };
                    string _startNumber = "14";

                    return(CheckVCRedistInClassesRoot(_paths, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2017x64))
                {
                    var _paths = new List <string>
                    {
                        @"Installer\Dependencies\,,amd64,14.0,bundle",
                        @"Installer\Dependencies\VC,redist.x64,amd64,14.16,bundle"                                 //changed in 14.16.x
                    };
                    string _startNumber = "14";

                    return(CheckVCRedistInClassesRoot(_paths, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2015x86))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Dependencies\{e2803110-78b3-4664-a479-3611a381656a}";
                    string _startNumber = "14";
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2015x64))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Dependencies\{d992c12e-cab2-426f-bde3-fb8c53950b0d}";
                    string _startNumber = "14";
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2013x86))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Dependencies\{f65db027-aff3-4070-886a-0d87064aabb1}";
                    string _startNumber = "12";
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2013x64))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Dependencies\{050d4fc8-5d48-4b8f-8972-47c82c46020f}";
                    string _startNumber = "12";
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2012x86))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Dependencies\{33d1fd90-4274-48a1-9bc1-97e33d9c2d6f}";
                    string _startNumber = "11";
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2012x64))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Dependencies\{ca67548a-5ebe-413a-b50c-4b9ceb6d66c6}";
                    string _startNumber = "11";
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2010x86))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Products\1D5E3C0FEDA1E123187686FED06E995A";
                    int    _startNumber = 1;
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2010x64))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Products\1926E8D15D0BCE53481466615F760A7F";
                    int    _startNumber = 1;
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2008x86))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Products\6E815EB96CCE9A53884E7857C57002F0";
                    int    _startNumber = 1;
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2008x64))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Products\67D6ECF5CD5FBA732B8B22BAC8DE1B4D";
                    int    _startNumber = 1;
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2005x86))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Products\c1c4f01781cc94c4c8fb1542c0981a2a";
                    int    _startNumber = 1;
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
                else if (redistVersion.Equals(RedistributablePackageVersion.VC2005x64))
                {
                    string _subKey      = @"SOFTWARE\Classes\Installer\Products\1af2a8da7e60d0b429d7e6453b3d0182";
                    int    _startNumber = 1;
                    return(CheckVCRedistInLocalMachine(_subKey, _startNumber));
                }
            }
            catch (Exception ex)
            {
                return(false);
            }

            return(false);
        }
Beispiel #5
0
        /// <summary>
        /// Check if a Microsoft Redistributable Package is installed.
        /// </summary>
        /// <param name="redistributableVersion">The package version to detect.</param>
        /// <returns><c>true</c> if the package is installed, otherwise <c>false</c></returns>
        public static bool IsInstalled(RedistributablePackageVersion redistributableVersion)
        {
            {
                switch (redistributableVersion)
                {
                case RedistributablePackageVersion.VC2015to2019x86:
                case RedistributablePackageVersion.VC2015to2019x64:
                    try
                    {
                        string subKey = Path.Combine("SOFTWARE", "Microsoft", "VisualStudio", "14.0", "VC", "Runtimes",
                                                     (redistributableVersion == RedistributablePackageVersion.VC2015to2019x86) ? "x86" : "x64");

                        sk = Registry.LocalMachine.OpenSubKey(subKey, false);

                        if (sk != null)
                        {
                            InstalledVersion = sk.GetValue("Version").ToString();

                            if (!string.IsNullOrWhiteSpace(InstalledVersion))
                            {
                                if (InstalledVersion.StartsWith("v"))
                                {
                                    char[] charsToTrim = { 'v' };
                                    InstalledVersion = InstalledVersion.Trim(charsToTrim);
                                }

                                if (InstalledVersion.CompareTo("14.20") >= 0)
                                {
                                    return(true);
                                }
                                else
                                {
                                    return(false);
                                }
                            }
                            else
                            {
                                return(false);
                            }
                        }
                        else
                        {
                            return(false);
                        }
                    }
                    catch (Exception Error)
                    {
                        LogToFileAddons.OpenLog("Redistributable Package", null, Error, null, true);
                        return(false);
                    }
                    finally
                    {
                        if (InstalledVersion != null)
                        {
                            InstalledVersion = null;
                        }
                        if (sk != null)
                        {
                            sk.Close();
                            sk.Dispose();
                        }
                    }

                default:
                    return(false);
                }
            }
        }