Détecter si Visual C++ Redistributable pour Visual Studio 2012 est installé
Comment détecter si Visual C++ Redistributable for Visual Studio 2012 est installé?
J'ai essayé Google et personne n'a posé cette question, surprise!
Essayer
HKLM\SOFTWARE\Microsoft\DevDiv\VC\Servicing\11.0
comme point de départ. J'utiliserai ceci comme vérification pour l'installation du runtime VC++ 11 (VS 2012).
Vous pouvez vérifier que la valeur Installed est 1 dans cet emplacement du registre: HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\11.0\VC\Runtimes\x86 sur des 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. Notez 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 pas d'élément installcheck dans le manifeste du package d'amorçage fourni avec Visual C++. Je suppose que Microsoft veut toujours installer si vous le définissez comme condition préalable.
Bien sûr, vous pouvez toujours appeler MsiQueryProductState pour vérifier si le package VC redist 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, lancez
product where "Caption like '%C++ 2012%'"
La réponse à ces questions simples n’est malheureusement pas simple, mais concerne 100% des systèmes, et peut même être étendue aux nombreux frameworks .net.
La complexité provient du fait qu'il existe (et existait) de nombreuses VC modifications de runtimes pouvant donner à penser que, bien que les versions de VC10 aient été installées, leur numéro de version n'était pas assez récent pour que votre fichier EXE ne démarre pas à moins que vous n'installiez les runtimes très exacts requis ou l'un des plus récents qui permettent à cette version et aux versions précédentes de la même version majeure de s'exécuter avec elle (l'enfer côte à côte) . EXE 64 bits, vous devrez vérifier les deux, les exécutions 32 ET 64 bits.
Cela dit, le seul moyen fiable de déterminer si les programmes d’exécution de votre fichier EXE sont installés est d’essayer d’exécuter le fichier EXE - ou un autre fichier EXE construit avec les mêmes paramètres que votre fichier EXE principal et dont le seul but est de ne fais rien. Il suffit d’exécuter (ce qui signifie que les programmes d’exécution sont installés) ou d’échouer (si non installé).
J'ai effectué les opérations suivantes pour un programme d'installation nécessitant l'installation des environnements d'exécution VC10 32 et 64 bits: Le programme d'installation tente de lancer tous les fichiers EXE factices. S'il réussit, le moteur d'exécution correspondant est considéré comme installé. Cela résout également le scénario 32/64 bits.
Soit dit en passant, cela permet également de déterminer si le cadre .net approprié est installé, ce qui est très délicat dans Windows 8 et 10, car la prise en charge intégrée téléchargeable .net 3.5 prend également en charge les versions .net 3.0 et 2.0. Et, pire encore, vous ne pouvez même pas utiliser les programmes d'installation du framework standard ici, vous devez utiliser le support intégré et le télécharger via Windows ou recréer votre application avec .net 4 , mais c’est une autre histoire).
Le fichier EXE factice C++ peut être créé à 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 à Utiliser MFC dans un fichier partagé DLL . Les exécutables auront une taille d'environ 4 Ko - un petit prix à payer pour une résultat certain.
Pour donner à vos utilisateurs une expérience d’installation de Nice, vous pouvez procéder comme suit (exemple de code 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
Lancez ensuite le contrôle d’exécution, par exemple. Lorsque vous quittez la page Welcome et mettez le résultat en cache, vous n'avez donc pas à vérifier chaque fois que l'utilisateur clique sur les boutons "Précédent" et "Suivant".
Créez ensuite une section en lecture seule dans l’arborescence de l’installation et présélectionnez-la ou désélectionnez-la dans la fonction a qui est exécutée avant que la page Components ne soit affichée.
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.
Depuis que Visual Studio 2010 et versions ultérieures ont cessé d’utiliser WinSxS, il suffit parfois de vérifier% windir%\system32\msvcr110.dll. Si vous souhaitez vérifier que vous disposez d'une nouvelle version suffisante, 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 en cherchant une réponse dans le contexte de la recherche du redistribuable Visual C++ dans le cadre d’un programme d’installation MSI créé par WiX.
Je n'aimais pas comment le GUID changeait 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 la redistribuable Visual C++.
Tout ce qui suit est spécifiquement destiné à 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>
Edit Je mets à jour cette réponse avec des 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 énumérées au début de cet article: https://www.codeproject.com/Articles/132918/Creating-Custom-Action-for-WIX-Written-in -Managed J'ai donc choisi cet article dans la section Adding Custom Action to the Installer et l'ai suivi avec quelques modifications.
Une autre chose que j'ai faite a été de changer la version du framework .NET sur lequel le projet est construit en version 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\LOGICIEL\Microsoft\DevDiv\vc\Servicing\11.0\RuntimeMinimum\Version
Vérifiez la version que vous avez après l'installation du paquet 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).
Il suffit d'aller dans Panneau de configuration> Programmes et fonctionnalités, et ils apparaissent tous énumérés ici.
Je ne suis pas un expert et cette réponse est assez simple comparée à ce que les gens répondent (vérification du registre), je ne suis donc pas sûr que ce soit la bonne réponse, mais cela a été très utile pour moi.
Vérifier l'état d'installation du produit via MsiQueryProductState est à peu près équivalent à une vérification directe du registre, mais vous avez toujours besoin du GUID pour le ProductCode .
Comme mentionné précédemment, un inconvénient de ces approches est que chaque mise à jour possède son propre code de produit!
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 code de mise à niveau pour VS2015 est redistribuable est {65E5BD06-6392-3027-8C26-853107D3CF1A}
Vous pouvez utiliser MsiEnumRelatedProducts pour obtenir tous les ID de produit pour ce UpgradeCode. En pratique, étant donné que chaque mise à jour redist remplace la précédente, cela ne produira qu'un seul ProductCode, tel que {B5FC62F5-A367-37A5-9FD2-A6E137C0096F} pour VS2015 Update 2 x86.
Indépendamment de cela, vous pouvez ensuite vérifier la version via MsiGetProductInfo (productCode, INSTALLPROPERTY_VERSIONSTRING, ...) ou des fonctions similaires à comparer avec la version souhaitée, 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_VERSION si vous #include <crtversion.h> - de cette façon, vous pouvez déterminer la version CRT avec laquelle votre binaire a été construit.
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
Si désinstallé, il n'existe pas. Si installé, il existe.
À propos, cela pourrait aussi être dans le Wow6432Node:
HKLM\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\11.0\VC\Runtimes
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
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 que je sache, cela ne peut 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 l'écran jusqu'à trouver le redistribuable VC++, qui inclut 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 avec succès depuis Visual Studio 2005. Je viens juste de le tester avec Visual Studio 2012 Update 4 également (puisque nous mettons enfin à jour notre logiciel de 2010 à 2012).
Étant donné que les packages Visual C++ Redistributable 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 complet de la clé 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, comme notre programme d’installation est un fichier exe de 32 bits, Windows s’applique à déterminer si la clé de registre se trouve réellement dans le nœud 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 explicitement les deux clés.
Notez également que pour mettre à jour le code ci-dessus vers une version différente de VC++ Redist, modifiez simplement le GUID dans le chemin de la clé de registre et le nom complet à votre convenance.
Bien que ce ne soit peut-être pas la méthode recommandée, il a fonctionné sur plus de 10 000 machines au cours des 10 dernières années, exécutant toutes les versions de Windows de XP/XP64 à Windows 10 à l'aide de redists pour 2005, 2010, 2010sp1 et maintenant 2012u4.
Je voudrais vérifier la valeur Installed 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 pas en fonction du produitVC++ redist
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 effectué de tests approfondis avec ce script, mais pour mon propre scénario CI (intégration continue), il fonctionne parfaitement.
Le script complet et les infos sur github
L'approche que j'ai utilisée était basée sur la vérification des registres sur la base des informations fournies ici. Ce qui suit est l'essentiel de ce que le script fait:
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 basée sur $redistInfo qui contient les informations compilées à partir 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 sont disponibles 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 paquets à mesure que les informations sont ajoutées ici.
Ce que la plupart des gens manquent, c'est le /reg:32 requis pour vérifier la clé sous Windows x64.
Voir 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