Détecter si Visual C ++ Redistributable pour Visual Studio 2012 est installé

Comment détecter si Visual C ++ Redistributable pour Visual Studio 2012 est installé?

J'ai essayé Google et personne ne m'a posé cette question, surprise!

Cela dépend de la version que vous utilisez. Ces deux clés 2012 ont bien fonctionné pour moi avec leurs versions correspondantes à télécharger pour la mise à jour 4. Veuillez noter que certains de ces emplacements d'enregistrement peuvent dépendre du système d'exploitation. J'ai collecté ces informations à partir d'une boîte Windows 10 x64 . Je vais juste aller de l'avant et vider toutes ces versions de redist et les clés de registre que je recherche pour détecter l'installation:

Visual C ++ 2005

Microsoft Visual C++ 2005 Redistributable (x64)
Registry Key: HKLM\SOFTWARE\Classes\Installer\Products\1af2a8da7e60d0b429d7e6453b3d0182
Configuration: x64
Version: 6.0.2900.2180

URL de téléchargement direct: https://download.microsoft.com/download/8/B/4/8B42259F-5D70-43F4-AC2E-4B208FD8D66A/vcredist_x64.EXE

Microsoft Visual C++ 2005 Redistributable (x86)
Registry Key: HKLM\SOFTWARE\Classes\Installer\Products\c1c4f01781cc94c4c8fb1542c0981a2a 
Configuration: x86
Version: 6.0.2900.2180

URL de téléchargement direct: https://download.microsoft.com/download/8/B/4/8B42259F-5D70-43F4-AC2E-4B208FD8D66A/vcredist_x86.EXE

Visual C ++ 2008

Microsoft Visual C++ 2008 Redistributable - x64 9.0.30729.6161 (SP1)
Registry Key: HKLM\SOFTWARE\Classes\Installer\Products\67D6ECF5CD5FBA732B8B22BAC8DE1B4D 
Configuration: x64
Version: 9.0.30729.6161 (Actual $Version data in registry: 0x9007809 [DWORD])

URL de téléchargement direct: https://download.microsoft.com/download/2/d/6/2d61c766-107b-409d-8fba-c39e61ca08e8/vcredist_x64.exe

Microsoft Visual C++ 2008 Redistributable - x86 9.0.30729.6161 (SP1)
Registry Key: HKLM\SOFTWARE\Classes\Installer\Products\6E815EB96CCE9A53884E7857C57002F0
Configuration: x86
Version: 9.0.30729.6161 (Actual $Version data in registry: 0x9007809 [DWORD])

URL de téléchargement direct: https://download.microsoft.com/download/d/d/9/dd9a82d0-52ef-40db-8dab-795376989c03/vcredist_x86.exe

Visual C ++ 2010

Microsoft Visual C++ 2010 Redistributable (x64)
Registry Key: HKLM\SOFTWARE\Classes\Installer\Products\1926E8D15D0BCE53481466615F760A7F 
Configuration: x64
Version: 10.0.40219.325

URL de téléchargement direct: https://download.microsoft.com/download/1/6/5/165255E7-1014-4D0A-B094-B6A430A6BFFC/vcredist_x64.exe

Microsoft Visual C++ 2010 Redistributable (x86)
Registry Key: HKLM\SOFTWARE\Classes\Installer\Products\1D5E3C0FEDA1E123187686FED06E995A 
Configuration: x86
Version: 10.0.40219.325

URL de téléchargement direct: https://download.microsoft.com/download/1/6/5/165255E7-1014-4D0A-B094-B6A430A6BFFC/vcredist_x86.exe

Visual C ++ 2012

Microsoft Visual C++ 2012 Redistributable (x64)
Registry Key: HKLM\SOFTWARE\Classes\Installer\Dependencies\{ca67548a-5ebe-413a-b50c-4b9ceb6d66c6} 
Configuration: x64
Version: 11.0.61030.0

URL de téléchargement direct: https://download.microsoft.com/download/1/6/B/16B06F60-3B20-4FF2-B699-5E9B7962F9AE/VSU_4/vcredist_x64.exe

Microsoft Visual C++ 2012 Redistributable (x86)
Registry Key: HKLM\SOFTWARE\Classes\Installer\Dependencies\{33d1fd90-4274-48a1-9bc1-97e33d9c2d6f} 
Configuration: x86
Version: 11.0.61030.0

URL de téléchargement direct: https://download.microsoft.com/download/1/6/B/16B06F60-3B20-4FF2-B699-5E9B7962F9AE/VSU_4/vcredist_x86.exe

mise en garde concernant la version : d'aprèsles conclusions de Wai Ha Lee , "... les binaires fournis avec la mise à jour 4 de VC ++ 2012 ( 11.0.61030.0) ont une version 11.0.60610.1pour les binaires ATL et MFC, et 11.0.51106.1pour tout le reste, par exemple msvcp110.dll et msvcr110.dll . .. "

Visual C ++ 2013

Microsoft Visual C++ 2013 Redistributable (x64)
Registry Key: HKLM\SOFTWARE\Classes\Installer\Dependencies\{050d4fc8-5d48-4b8f-8972-47c82c46020f} 
Configuration: x64
Version: 12.0.30501.0

URL de téléchargement direct: https://download.microsoft.com/download/2/E/6/2E61CFA4-993B-4DD4-91DA-3737CD5CD6E3/vcredist_x64.exe

Microsoft Visual C++ 2013 Redistributable (x86)
Registry Key: HKLM\SOFTWARE\Classes\Installer\Dependencies\{f65db027-aff3-4070-886a-0d87064aabb1} 
Configuration: x86
Version: 12.0.30501.0

URL de téléchargement direct: https://download.microsoft.com/download/2/E/6/2E61CFA4-993B-4DD4-91DA-3737CD5CD6E3/vcredist_x86.exe

Visual C ++ 2015

_{^{Envisagez d'utiliser l'offre groupée 2015-2019 comme alternative}}

Microsoft Visual C++ 2015 Redistributable (x64) - 14.0.24215
Registry Key: HKLM\SOFTWARE\Classes\Installer\Dependencies\{d992c12e-cab2-426f-bde3-fb8c53950b0d}
Configuration: x64
Version: 14.0.24215.1

URL de téléchargement direct: https://download.microsoft.com/download/6/A/A/6AA4EDFF-645B-48C5-81CC-ED5963AEAD48/vc_redist.x64.exe

Microsoft Visual C++ 2015 Redistributable (x86) - 14.0.24215
Registry Key: HKLM\SOFTWARE\Classes\Installer\Dependencies\{e2803110-78b3-4664-a479-3611a381656a}
Configuration: x86
Version: 14.0.24215.1

URL de téléchargement direct: https://download.microsoft.com/download/6/A/A/6AA4EDFF-645B-48C5-81CC-ED5963AEAD48/vc_redist.x86.exe

Visual C ++ 2017

_{^{Envisagez d'utiliser l'offre groupée 2015-2019 comme alternative}}

Attention : soit une nouvelle convention de registre 2017 est utilisée, soit elle n'a pas encore été finalisée. Comme je devine les touches les plus hautes de: [HKEY_CLASSES_ROOT\Installer\Dependencies\,,amd64,14.0,bundle] et [HKEY_CLASSES_ROOT\Installer\Dependencies\,,x86,14.0,bundle]

sont sujets à changement, ou ont au moins différents GUID imbriqués, je vais utiliser la liste de la clé qui se termine par un GUID.

Microsoft Visual C++ 2017 Redistributable (x64) - 14.16.27012
Registry Key: [HKEY_CLASSES_ROOT\Installer\Dependencies\VC,redist.x64,amd64,14.16,bundle\Dependents\{427ada59-85e7-4bc8-b8d5-ebf59db60423}]
Configuration: x64
Version: 14.16.27012.6

URL de téléchargement direct: https://download.visualstudio.microsoft.com/download/pr/9fbed7c7-7012-4cc0-a0a3-a541f51981b5/e7eec15278b4473e26d7e32cef53a34c/vc_redist.x64.exe

Microsoft Visual C++ 2017 Redistributable (x86) - 14.16.27012
Registry Key: [HKEY_CLASSES_ROOT\Installer\Dependencies\VC,redist.x86,x86,14.16,bundle\Dependents\{67f67547-9693-4937-aa13-56e296bd40f6}]
Configuration: x86
Version: 14.16.27012.6

URL de téléchargement direct: https://download.visualstudio.microsoft.com/download/pr/d0b808a8-aa78-4250-8e54-49b8c23f7328/9c5e6532055786367ee61aafb3313c95/vc_redist.x86.exe

Visual C ++ 2019 ( ensemble 2015-2019 )

Mise en garde : une autre nouvelle convention de registre est utilisée pour Visual C ++ 2019. Il ne semble pas non plus y avoir de programme d'installation autonome pour Visual C ++ 2019, mais uniquement ce programme d'installation de bundle qui est Visual C ++ 2015 à 2019.

14.21.27702

Microsoft Visual C++ 2015-2019 Redistributable (x64) - 14.21.27702
Registry Key: [HKEY_CLASSES_ROOT\Installer\Dependencies\VC,redist.x64,amd64,14.21,bundle\Dependents\{f4220b74-9edd-4ded-bc8b-0342c1e164d8}]
Configuration: x64
Version: 14.21.27702  

URL de téléchargement direct: https://download.visualstudio.microsoft.com/download/pr/9e04d214-5a9d-4515-9960-3d71398d98c3/1e1e62ab57bbb4bf5199e8ce88f040be/vc_redist.x64.exe

Microsoft Visual C++ 2015-2019 Redistributable (x86) - 14.21.27702
Registry Key: [HKEY_CLASSES_ROOT\Installer\Dependencies\VC,redist.x86,x86,14.21,bundle\Dependents\{49697869-be8e-427d-81a0-c334d1d14950}]
Configuration: x86
Version: 14.21.27702

URL de téléchargement direct: https://download.visualstudio.microsoft.com/download/pr/c8edbb87-c7ec-4500-a461-71e8912d25e9/99ba493d660597490cbb8b3211d2cae4/vc_redist.x86.exe

14.22.27821

Microsoft Visual C++ 2015-2019 Redistributable (x86) - 14.22.27821
Registry Key: [HKEY_CLASSES_ROOT\Installer\Dependencies\VC,redist.x86,x86,14.22,bundle\Dependents\{5bfc1380-fd35-4b85-9715-7351535d077e}]
Configuration: x86
Version: 14.22.27821

URL de téléchargement direct: https://download.visualstudio.microsoft.com/download/pr/0c1cfec3-e028-4996-8bb7-0c751ba41e32/1abed1573f36075bfdfc538a2af00d37/vc_redist.x86.exe

Microsoft Visual C++ 2015-2019 Redistributable (x86) - 14.22.27821
Registry Key: [HKEY_CLASSES_ROOT\Installer\Dependencies\VC,redist.x64,amd64,14.22,bundle\Dependents\{6361b579-2795-4886-b2a8-53d5239b6452}]
Configuration: x64
Version: 14.22.27821

URL de téléchargement direct: https://download.visualstudio.microsoft.com/download/pr/cc0046d4-e7b4-45a1-bd46-b1c079191224/9c4042a4c2e6d1f661f4c58cf4d129e9/vc_redist.x64.exe

Changelog :
19 août 2019 - Ajout d'une nouvelle version de la version du bundle 2015-2019
13 juin 2019 - Ajout d'une nouvelle section pour la version du bundle 2015-2019 14.21.27702et ajout de _{^{petites notes}} aux sections 2015 et 2017 sur la prise en compte de l'utilisation de le nouveau bundle comme alternative.
14 décembre 2018 - Mise à jour de MSVC2008 pour la 9.0.30729.6161mise à jour du Service Pack 1 selon les conclusions de Jim Wolff
27 novembre 2018 - Mise à jour des informations pour MSVC2017 v.12 14.16
septembre 2018 - Ajout de la mise en garde de version à la mise à jour 4 de 2012 conformément aux conclusions de Wai Ha Lee
le 24 août 2018 - Version 2017 mise à jour pour 14.15.26706, les dépendances Visual C ++ mises à jour empaquetées avec VS 2017 15.8.1
16 mai 2018 - Version 2017 mise à jour pour 14.14.26405.0 en tant que nouvelle entrée C ++ 2017
8 septembre 2017 - Version 2017 mise à jour pour 14.11.25325.0 en tant que nouvelle entrée Visual C ++ 2017
7 avril 2017 - Version 2017 mise à jour de 14.10 .25008.0 en tant que nouvelle entrée de Visual C ++ 2017
24 octobre 2016 - Informations de version de 2015 mises à jour pour 14.0.24215.1
18 août 2016 - Informations de version de 2015 mises à jour pour 14.0.24212
27 mai 2016 - Informations mises à jour pour MSVC2015 Update 2

Veuillez me contacter ici si l'un de ceux-ci devient obsolète.

Essayer

HKLM\SOFTWARE\Microsoft\DevDiv\VC\Servicing\11.0

comme point de départ. J'utiliserai ceci pour vérifier l'installation du runtime VC ++ 11 (VS 2012).

Vous pouvez vérifier que la Installedvaleur se trouve 1dans cet emplacement de registre: HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\11.0\VC\Runtimes\x86sur les systèmes 64 bits. Dans le code qui entraînerait l'accès à la clé de registre HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\11.0\VC\Runtimes\x86. Remarquez l'absence de Wow6432Node.

Sur un système 32 bits, le registre est le même sans Wow6432Node:HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\11.0\VC\Runtimes\x86

Il n'y a aucun élément installcheck dans le manifeste du package de démarrage fourni avec Visual C ++. Je suppose que Microsoft veut toujours installer si vous le définissez comme prérequis.

Bien sûr, vous pouvez toujours appeler MsiQueryProductState pour vérifier si le package de redistribution VC est installé via MSI, le code du package peut être trouvé en exécutant

wmic product get

en ligne de commande, ou si vous êtes déjà sur wmic: root \ cli, exécutez

product where "Caption like '%C++ 2012%'"

La réponse à ces questions simples n'est malheureusement pas simple, mais fonctionne dans 100% de tous les systèmes, et même extensible aux nombreux frameworks .net.

La complexité vient du fait qu'il y a (et il y avait) de nombreuses révisions des runtimes VC qui pourraient conduire au cas où bien que les runtimes VC10 aient été installés, leur numéro de build n'était pas assez récent pour que votre EXE ne démarre pas à moins que vous n'ayez installé le très les temps d'exécution exacts dont vous avez besoin ou l'un des plus récents exécutables qui permettent à cette version et aux versions précédentes de la même version majeure de fonctionner avec elle (l'enfer côte à côte). De plus, si vous avez un EXE 64 bits, vous devrez vérifier les deux, les environnements d'exécution 32 ET 64 bits.

Cela dit, le seul moyen fiable de déterminer si les environnements d'exécution de votre EXE sont installés est d'essayer d'exécuter le fichier EXE. - ou un autre EXE qui est construit avec les mêmes paramètres que votre EXE principal et dont le seul but est de ne rien faire. Exécutez simplement (ce qui signifie que les runtimes sont installés) ou échouez (lorsqu'ils ne sont pas installés).

J'ai fait ce qui suit pour un programme d'installation qui nécessitait l'installation des runtimes VC10 32 et 64 bits: Le programme d'installation tente de lancer tous les fichiers EXE factices et s'il réussit, le runtime correspondant est considéré comme installé. Cela résout également le scénario 32/64 bits.

Cela fonctionne également pour déterminer si le framework .net approprié est installé, ce qui est très délicat dans Windows 8 et 10, car le support .net 3.5 intégré téléchargeable prend également en charge les versions 3.0 et 2.0. il n'y a pas d'entrées de registre pour ces derniers. (Et pire, vous ne pouvez même pas utiliser les installateurs de framework standard ici, vous devez utiliser le support intégré et le télécharger via Windows, ou reconstruire votre application avec .net 4, mais c'est une autre histoire).

Le fichier EXE factice C ++ peut être généré à l'aide d'un projet avec le code suivant (et un autre dans une configuration 64 bits si nécessaire):

int _tmain(int argc, _TCHAR* argv[])
{
    return 0;
}

N'oubliez pas de définir les propriétés du projet Utilisation de MFC pour utiliser MFC dans une DLL partagée . Les exécutables auront une taille d'environ 4 Ko - un petit prix à payer pour un résultat sûr.

Pour offrir à vos utilisateurs une expérience d'installation agréable, vous pouvez effectuer les opérations suivantes (l'exemple de code est pour NSIS ):

Function TryLaunchApplication
  Pop $1 ; pathname
  nsExec::Exec $1
  Pop $0

  ${If} $0 == "error"
  ${OrIf} $0 != 0
    Push 0
  ${Else}
    Push 1
  ${EndIf}
FunctionEnd

et appelez-le dans une fonction, par exemple CheckRuntimes

Function CheckRuntimes
  ; Try to execute VC++ 10 application (32 bit)
  Push "Vc10RuntimeCheckerApp.exe"
  Call TryLaunchApplication
  Pop $Vc10RuntimesFound

  ; Add 64 bit check if required.
  ; Remember to try running the 64 bit EXE only on a 64 bit OS,
  ; which requires further checks.

  ; Try to execute .net application
  Push "DotNetRuntimeCheckerApp.exe"
  Call TryLaunchApplication
  Pop $DotNetFrameworkFound
FunctionEnd

Ensuite , lancez la vérification de l' exécution par exemple lorsque vous quittez la bienvenue la page et mettre en cache le résultat, de sorte que vous n'avez pas de vérifier à nouveau chaque fois que l'utilisateur clique sur le bouton « Précédent » et « Suivant ».

Ensuite, créez une section en lecture seule dans l'arborescence d'installation et présélectionnez ou désélectionnez-la sur une fonction qui est exécutée avant que la page Composants ne s'affiche.

Cela garantira que l'installation de chaque composant d'exécution manquant est obligatoire et est ignorée s'il est déjà présent.

Étant donné que Visual Studio 2010 et les versions ultérieures ont cessé d'utiliser WinSxS, il peut suffire de vérifier simplement% windir% \ system32 \ msvcr110.dll. Si vous souhaitez vérifier que vous disposez d'une version suffisamment nouvelle, vous pouvez vérifier si la version du fichier est 11.0.50727.1 (VS2012 RTM) ou 11.0.51106.1 (VS2012 Update 1).

Je suis tombé sur cette question à la recherche d'une réponse dans le contexte de la vérification du redistribuable Visual C ++ dans le cadre d'un programme d'installation MSI créé par WiX.

Je n'aimais pas la façon dont le GUID change avec la version et le système d'exploitation, j'ai donc fini par créer une action personnalisée écrite en C # pour vérifier le redistribuable Visual C ++.

Tout ce qui suit est spécifiquement pour Visual C ++ 2015 Redistributable (x64), mais il peut être facilement modifié pour n'importe quelle version.

using Microsoft.Deployment.WindowsInstaller;
using Microsoft.Win32;

namespace CustomActions
{
    public class DependencyChecks
    {
        [CustomAction]
        public static ActionResult IsVC2015RedistInstalled(Session session)
        {
            session.Log("Begin Visual C++ 2015 Redistributable installation check.");

            var dependenciesKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Classes\\Installer\\Dependencies");

            foreach(var subKey in dependenciesKey.GetSubKeyNames())
            {
                var dependency = dependenciesKey.OpenSubKey(subKey);
                var displayName = (string)dependency.GetValue("DisplayName");
                if(displayName != null)
                {
                    if (displayName.Contains("Microsoft Visual C++ 2015 Redistributable (x64)"))
                    {
                        session.Log("Visual C++ 2015 Redistributable is installed.");
                        return ActionResult.Success;
                    }
                }
            }

            session.Log("Visual C++ 2015 Redistributable is not installed.");
            session.Message(InstallMessage.Error, new Record(1, "This application requires Visual C++ 2015 Redistributable. Please install, then run this installer again. https://www.microsoft.com/en-us/download/details.aspx?id=53587"));
            return ActionResult.Failure;
        }
    }
}

Puis dans le fichier wxs

<Binary Id='VC2015RedistCheck' SourceFile='!(wix.ResourcesDir=resources)\CustomActions.CA.dll'/>
    <CustomAction
      Id='VC2015RedistCheckAction'
      Execute='immediate'
      BinaryKey='VC2015RedistCheck'
      DllEntry="IsVC2015RedistInstalled"
      Return='check'/>

<InstallExecuteSequence>
  <Custom Action='VC2015RedistCheckAction' After='InstallInitialize'/>
</InstallExecuteSequence>

Modifier Je mets à jour cette réponse avec quelques informations de base sur la création et l'utilisation d'une action personnalisée.

Pour créer l'action personnalisée dans Visual Studio 2017 avec l'extension WiX Toolset Visual Studio 2017 installée, j'ai utilisé le modèle de projet pour créer une action personnalisée (Projet d'action personnalisée C # pour WiX v3).

J'ai vérifié le projet généré et il semblait déjà avoir les modifications répertoriées au début de cet article: https://www.codeproject.com/Articles/132918/Creating-Custom-Action-for-WIX-Written-in-Managed alors j'ai pris cet article dans la sectionAdding Custom Action to the Installer et l' suivi avec quelques ajustements.

Une autre chose que j'ai faite a été de changer la version du framework .NET sur laquelle le projet est construit en 3.5.

Je ne l'ai pas trouvé vraiment utile mais vous pouvez aussi voir http://wixtoolset.org/documentation/manual/v3/wixdev/extensions/authoring_custom_actions.html

Pour moi, cet emplacement a fonctionné: HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ DevDiv \ vc \ Servicing \ 11.0 \ RuntimeMinimum \ Version

Vérifiez la version dont vous disposez après avoir installé le package et utilisez-la comme condition dans votre programme d'installation. (le mien est réglé sur 11.0.50727 après l'installation de VCred).

Allez simplement dans Panneau de configuration> Programmes et fonctionnalités, et ils apparaissent tous ici.

Je ne suis pas un expert et cette réponse est assez simple par rapport à ce que les gens répondent (vérification du registre), donc je ne suis pas sûr que ce soit la bonne réponse, mais cela a fait l'affaire pour moi.

if RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\10.0\VC\VCRedist\x86","Installed") = 0 Then
  if RegRead("HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\11.0\VC\Runtimes\x86","Installed") = 0 Then

J'ai réussi à faire cela avec InnoSetup.

J'ai vérifié l'existence de la clé de registre:

HKLM\SOFTWARE\Microsoft\VisualStudio\11.0\VC\Runtimes

S'il est désinstallé, il n'existe pas. S'il est installé, il existe.

À propos, cela pourrait également être dans le Wow6432Node:

HKLM\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\11.0\VC\Runtimes

Vérifier l'état d'installation du produit via MsiQueryProductState équivaut à peu près à vérifier le registre directement, mais vous avez toujours besoin du GUID pour le ProductCode .

Comme mentionné ailleurs, un inconvénient de ces approches est que chaque mise à jour a son propre ProductCode!

Heureusement, MSI fournit un UpgradeCode qui identifie une «famille» de produits. Vous pouvez utiliser orca pour ouvrir l'un des MSI afin d'extraire ces informations. Par exemple, le UpgradeCode pour le redistribuable de VS2015 est{65E5BD06-6392-3027-8C26-853107D3CF1A}

Vous pouvez utiliser MsiEnumRelatedProducts pour obtenir tous les ID de produit pour ce UpgradeCode. En pratique, puisque chaque mise à jour de redist remplace la précédente, cela ne donnera qu'un seul ProductCode - tel que{B5FC62F5-A367-37A5-9FD2-A6E137C0096F} pour VS2015 Update 2 x86.

Quoi qu'il en soit, vous pouvez ensuite vérifier la version via MsiGetProductInfo ( , INSTALLPROPERTY_VERSIONSTRING, ...) ou des fonctions similaires pour comparer avec la version que vous souhaitez, par exemple pour rechercher une version équivalente ou ultérieure.

Notez que dans une application C ++, vous pouvez également utiliser _VC_CRT_MAJOR_VERSION, _VC_CRT_MINOR_VERSION, _VC_CRT_BUILD_VERSIONsi vous #include <crtversion.h>- cette façon , vous pouvez déterminer calculer la version CRT que votre binaire a été construit avec.

Ce code PowerShell devrait faire l'affaire

Get-ItemProperty
HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\* | 
Select-Object DisplayName, DisplayVersion, Publisher, InstallDate |
Format-Table –AutoSize

J'avais besoin de la même chose, et bien qu'AFAIK cela ne puisse pas être fait par programme, cela a fonctionné pour moi.

Je suis juste allé dans Démarrer -> Désinstaller un programme et j'ai fait défiler jusqu'à ce que je trouve le redistribuable VC ++, qui comprend un numéro de version. Googler le numéro de version, m'a dit qu'il appartient à VS2012 SP1.

Ancienne question mais voici l'approche que nous avons utilisée depuis Visual Studio 2005 avec succès. Je viens de le tester en utilisant Visual Studio 2012 Update 4 également (puisque nous mettons enfin à jour notre logiciel de 2010 à 2012).

Puisque les packages redistribuables Visual C ++ enregistrent leur programme de désinstallation avec Windows (il apparaît donc dans la liste "Programmes et fonctionnalités" du panneau de configuration), nous vérifions simplement le nom d'affichage de la clé du programme de désinstallation dans le registre.

Voici le code NSIS pertinent:

ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\{33d1fd90-4274-48a1-9bc1-97e33d9c2d6f}\" "DisplayName"
StrCmp $0 "Microsoft Visual C++ 2012 Redistributable (x86) - 11.0.61030" vs2012redistInstalled
DetailPrint "Microsoft Visual C++ 2012 Update 4 Redistributable not found!"
DetailPrint "Downloading from www.mywebsite.com"
; insert applicable download code here
ExecWait '"<downloaded redist exe>" /promptrestart /passive'
vs2012redistInstalled:

Notez que puisque notre programme d'installation est un exe 32 bits, Windows gère la détermination si la clé de registre se trouve réellement dans le Wow6432Node virtualisé au lieu de l'emplacement ci-dessus, de sorte que le code ci-dessus fonctionne sur les installations Windows 64 bits et 32 ​​bits sans avoir à vérifier les deux clés explicitement.

Notez également que pour mettre à jour le code ci-dessus vers une version différente de la redistribution VC ++, modifiez simplement le GUID dans le chemin d'accès de la clé de Registre et le nom complet en fonction de vos besoins.

Bien que ce ne soit peut-être pas la méthode recommandée, elle a fonctionné sur plus de 10000 machines au cours des 10 dernières années exécutant toutes les versions de Windows de XP / XP64 à Windows 10 en utilisant des redistributions pour 2005, 2010, 2010sp1 et maintenant 2012u4.

Je vérifierais la Installedvaleur de

HKLM\SOFTWARE\[WOW6432Node]\Microsoft\Windows\CurrentVersion\Uninstall\{VCRedist_GUID} clé

• où GUID de VC++ 2012 (x86)est{33d1fd90-4274-48a1-9bc1-97e33d9c2d6f}
• WOW6432Nodesera présent ou non selon le VC++ redistproduit

Ce que la plupart des gens manquent, c'est la /reg:32vérification de la clé sous Windows x64.

Consultez l' article d'aide de Microsoft à ce sujet.

Voici un script qui montre comment vérifier correctement Visual C ++ Redistributable pour Visual Studio 2012 Update 4.

@ECHO OFF

:Author
REM "CREATED BY WAR59312"
REM "FEB 7th 2017"

REM Clear Screen
CLS

TITLE Detect Visual C++ 2012 Redistributables

REM This Batch Script Detects If Visual C++ Redistributable for Visual Studio 2012 Update 4 Is Installed

:DetectWindowsOS
REM Are We Running On x86 Or x64
IF NOT DEFINED PROCESSOR_ARCHITEW6432 (
IF %PROCESSOR_ARCHITECTURE% EQU x86 (
REM Windows Is x86
GoTo Check32Bit
) ELSE (
REM Windows Is x64
SET NeededFor64BitOnly=/reg:32
GoTo Check64Bit
)) ELSE (
REM Windows Is Unknown But Assume x64 To Be Safe
SET NeededFor64BitOnly=/reg:32
GoTo Check64Bit
)

:Check64Bit
REM Checks If Visual C++ 64Bit Redistributable for Visual Studio 2012 Update 4 Is Installed
REG QUERY "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\11.0\VC\Runtimes\x64" /v "Version" %NeededFor64BitOnly% 2>NUL^ | (
  FIND "v11.0.61030.00" >NUL
) && (
  ECHO.
  ECHO 64bit Visual C++ Redistributable for Visual Studio 2012 Update 4 Is Installed
  ECHO.
  GoTo Check32Bit
) || (
   ECHO.
   ECHO 64bit Visual C++ Redistributable for Visual Studio 2012 Update 4 Is NOT Installed
   ECHO.
   GoTo Check32Bit
)

:Check32Bit
REM Checks If Visual C++ 32Bit Redistributable for Visual Studio 2012 Update 4 Is Installed
REG QUERY "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\11.0\VC\Runtimes\x86" /v "Version" %NeededFor64BitOnly% 2>NUL^ | (
  FIND "v11.0.61030.00" >NUL
) && (
   ECHO.
   ECHO 32bit Visual C++ Redistributable for Visual Studio 2012 Update 4 Is Installed
) || (
   ECHO.
   ECHO 32bit Visual C++ Redistributable for Visual Studio 2012 Update 4 Is NOT Installed
)

:END
ECHO.
PAUSE

EXIT

La solution de script PowerShell:

Sur la base des informations contenues dans la réponse de @kayleeFrye_onDeck

J'ai créé un script PowerShell qui vérifie et installe les versions spécifiées par l'utilisateur, je n'ai pas fait de tests approfondis avec lui, mais pour mon propre scénario CI (intégration continue), cela fonctionne parfaitement.

Le script complet et les informations sur github

L'approche que j'ai utilisée était basée sur la vérification des clés d'enregistrement sur la base des informations fournies ici. Voici l'essentiel de ce que fait le script:

function Test-RegistryValue {
param (
 [parameter(Mandatory=$true)]
 [ValidateNotNullOrEmpty()]$Path,
 [parameter(Mandatory=$true)]
 [ValidateNotNullOrEmpty()]$Value
)
    try {
    Get-ItemProperty -Path "$($Path+$Value)" -ErrorAction Stop | Out-Null
        return $true
    }
    catch {
        return $false
    }
}

La vérification / téléchargement / installation silencieuse sur la base de $redistInfolaquelle contient les informations compilées de kayleeFrye_onDeck.

$redistInstalled = Test-RegistryValue -Path $redistInfo.RegPath -Value $redistInfo.RegValue
if($redistInstalled -eq $False) {
    Invoke-WebRequest -Uri $redistInfo.DownloadUrl -OutFile $downloadTargetPath
    Start-Process -FilePath $downloadTargetPath -ArgumentList "$($redistInfo.SilentInstallArgs)" -Wait -NoNewWindow | Wait-Process
}

Le script complet et plus d'informations peuvent être trouvés sur github

Tout le monde est invité à contribuer, si j'ai le temps, je ferai des tests plus approfondis du script et continuerai à essayer d'ajouter de nouveaux packages au fur et à mesure que des informations seront ajoutées ici.

Il est difficile d'obtenir toutes les valeurs de registre pour VC 2012, j'ai donc écrit une petite fonction qui passera en revue toutes les dépendances et correspondra à la version spécifiée.

public static bool IsVC2012Installed()
{
    string dependenciesPath = @"SOFTWARE\Classes\Installer\Dependencies";

    using (RegistryKey dependencies = Registry.LocalMachine.OpenSubKey(dependenciesPath))
    {
        if (dependencies == null) return false;

        foreach (string subKeyName in dependencies.GetSubKeyNames().Where(n => !n.ToLower().Contains("dotnet") && !n.ToLower().Contains("microsoft")))
        {
            using (RegistryKey subDir = Registry.LocalMachine.OpenSubKey(dependenciesPath + "\\" + subKeyName))
            {
                var value = subDir.GetValue("DisplayName")?.ToString() ?? null;
                if (string.IsNullOrEmpty(value)) continue;

                if (Regex.IsMatch(value, @"C\+\+ 2012")) //here u can specify your version.
                {
                    return true;
                }
            }
        }
    }

    return false;
}

Dépendances:

using System.Text.RegularExpressions;
using Microsoft.Win32;
using System.Linq;

vous pouvez rechercher dans le registre.En fait, je n'ai pas vs2012 mais j'ai vs2010.

Il existe 3 clés de registre différentes (mais très similaires) pour chacun des 3 packages de plate-forme. Chaque clé a une valeur DWORD appelée «Installé» avec une valeur de 1.

• HKLM \ SOFTWARE \ Microsoft \ VisualStudio \ 10.0 \ VC \ VCRedist \ x86

• HKLM \ SOFTWARE \ Microsoft \ VisualStudio \ 10.0 \ VC \ VCRedist \ x64

• HKLM \ SOFTWARE \ Microsoft \ VisualStudio \ 10.0 \ VC \ VCRedist \ ia64

Vous pouvez utiliser la fonction de registre pour cela ......