Rileva se è installato Visual C ++ Redistributable per Visual Studio 2012

Come rilevare se è installato Visual C ++ Redistributable per Visual Studio 2012?

Ho provato su Google e nessuno mi ha fatto questa domanda, sorpresa!

Dipende dalla versione che stai usando. Queste due chiavi 2012 hanno funzionato bene per me con le loro versioni corrispondenti da scaricare per l'aggiornamento 4. Tieni presente che alcune di queste posizioni dei reg potrebbero dipendere dal sistema operativo. Ho raccolto queste informazioni da una scatola di Windows 10 x64 . Andrò avanti e scaricherò tutte queste versioni redist e le chiavi di registro che cerco per rilevare l'installazione .:

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 di download diretto: 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 di download diretto: 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 di download diretto: 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 di download diretto: 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 di download diretto: 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 di download diretto: 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 di download diretto: 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 di download diretto: https://download.microsoft.com/download/1/6/B/16B06F60-3B20-4FF2-B699-5E9B7962F9AE/VSU_4/vcredist_x86.exe

avvertenza sulla versione : secondoi risultati di Wai Ha Lee , "... i binari forniti con l'aggiornamento 4 di VC ++ 2012 (11.0.61030.0 ) hanno la versione 11.0.60610.1per i binari ATL e MFC e 11.0.51106.1per tutto il resto, ad esempio msvcp110.dll e 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 di download diretto: 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 di download diretto: https://download.microsoft.com/download/2/E/6/2E61CFA4-993B-4DD4-91DA-3737CD5CD6E3/vcredist_x86.exe

Visual C ++ 2015

_{^{Prendi in considerazione l'utilizzo del pacchetto 2015-2019 come alternativa}}

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 di download diretto: 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 di download diretto: https://download.microsoft.com/download/6/A/A/6AA4EDFF-645B-48C5-81CC-ED5963AEAD48/vc_redist.x86.exe

Visual C ++ 2017

_{^{Prendi in considerazione l'utilizzo del pacchetto 2015-2019 come alternativa}}

Avvertimento : è in uso una nuova convenzione del registro del 2017 o non è stata ancora finalizzata. Come immagino i tasti più in alto di: [HKEY_CLASSES_ROOT\Installer\Dependencies\,,amd64,14.0,bundle] e [HKEY_CLASSES_ROOT\Installer\Dependencies\,,x86,14.0,bundle]

sono soggetti a modifiche, o almeno hanno GUID nidificati diversi, userò l'elenco della chiave che termina con 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 di download diretto: 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 di download diretto: https://download.visualstudio.microsoft.com/download/pr/d0b808a8-aa78-4250-8e54-49b8c23f7328/9c5e6532055786367ee61aafb3313c95/vc_redist.x86.exe

Visual C ++ 2019 ( pacchetto 2015-2019 )

Avvertenza : c'è un'altra nuova convenzione del registro utilizzata per Visual C ++ 2019. Inoltre non sembra esserci un programma di installazione autonomo per Visual C ++ 2019, solo questo programma di installazione in bundle che è Visual C ++ dal 2015 al 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 di download diretto: 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 di download diretto: 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 di download diretto: 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 di download diretto: https://download.visualstudio.microsoft.com/download/pr/cc0046d4-e7b4-45a1-bd46-b1c079191224/9c4042a4c2e6d1f661f4c58cf4d129e9/vc_redist.x64.exe

Changelog :
19 agosto 2019 - Aggiunta una nuova versione della versione bundle 2015-2019
13 giugno 2019 - Aggiunta una nuova sezione per la versione bundle 2015-2019 14.21.27702e aggiunte _{^{piccole note}} alle sezioni 2015 e 2017 sulla considerazione dell'utilizzo di il nuovo bundle in alternativa.
14 dicembre 2018 - Aggiornato MSVC2008 per l' 9.0.30729.6161aggiornamento del Service Pack 1 in base ai risultati di Jim Wolff
27 novembre 2018 - Informazioni aggiornate per MSVC2017 v. 16 maggio 2018 - Aggiornata la versione 2017 per 14.14.26405.0 come nuova voce C ++ 2017 l'8 settembre , 2017 - Versione aggiornata del 2017 per 14.11.25325.0 come nuova voce di Visual C ++ 201714.16
12 settembre 2018 - Aggiunta avvertenza sulla versione all'aggiornamento 4 2012 in base alle scoperte di Wai Ha Lee
il 24 agosto, 2018: versione aggiornata del 2017 per 14.15.26706, le dipendenze di Visual C ++ aggiornate incluse nel pacchetto VS 2017 15.8.1


7 aprile 2017 - Versione 2017 aggiornata 14.10 .25008.0 come nuova voce di Visual C ++ 2017
24 ottobre 2016 - Informazioni sulla versione 2015 aggiornate per 14.0.24215.1
18 agosto 2016 - Informazioni sulla versione 2015 aggiornate per 14.0.24212
27 maggio 2016 - Informazioni aggiornate per MSVC2015 Update 2

Per favore contattami qui se qualcuno di questi diventa obsoleto.

Provare

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

come punto di partenza. Lo userò come controllo per l'installazione del runtime VC ++ 11 (VS 2012).

È possibile verificare che il Installedvalore si trovi 1in questa posizione del registro: HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\11.0\VC\Runtimes\x86su sistemi a 64 bit. Nel codice che comporterebbe l'accesso alla chiave di registro HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\11.0\VC\Runtimes\x86. Notare l'assenza diWow6432Node .

Su un sistema a 32 bit il registro è lo stesso senza Wow6432Node:HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\11.0\VC\Runtimes\x86

Non è presente alcun elemento installcheck nel manifesto del pacchetto del programma di avvio automatico fornito con Visual C ++. Immagino che Microsoft voglia sempre installarlo se lo imposti come prerequisito.

Ovviamente puoi ancora chiamare MsiQueryProductState per verificare se il pacchetto di redist VC è installato tramite MSI, Il codice del pacchetto può essere trovato eseguendo

wmic product get

dalla riga di comando, o se sei già in wmic: root \ cli, esegui

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

La risposta a queste semplici domande purtroppo non è semplice, ma funziona nel 100% di tutti i sistemi, ed è anche estendibile ai numerosi framework .net.

La complessità deriva dal fatto che ci sono (e c'erano) molte revisioni dei runtime VC che potrebbero portare al caso in cui, sebbene fossero installati i runtime VC10, il loro numero di build non era abbastanza recente, quindi il tuo EXE non si avviava a meno che tu non abbia installato proprio runtime esatti richiesti o uno dei runtime più recenti che consentono a questa e alle versioni precedenti della stessa versione principale di funzionare con esso (l'inferno side-by-side). Inoltre, se hai un EXE a 64 bit, dovrai controllare entrambi i tempi di esecuzione a 32 E 64 bit.

Detto questo, l'unico modo affidabile per determinare se i runtime per il tuo EXE sono installati è tentare di eseguire l'EXE o un altro EXE creato con le stesse impostazioni dell'EXE principale e il cui unico scopo è non fare nulla. Esegui semplicemente (il che significa che i runtime sono installati) o non riesci a eseguire (se non installato).

Ho fatto quanto segue per un programma di installazione che richiedeva l'installazione dei runtime VC10 a 32 e 64 bit: Il programma di installazione tenta di avviare tutti gli EXE fittizi e, se riesce, il runtime corrispondente viene considerato installato. Questo risolve anche lo scenario a 32/64 bit.

Questo, a proposito, funziona anche per determinare se è installato il framework .net corretto, il che è molto complicato in Windows 8 e 10, poiché il supporto .net 3.5 integrato scaricabile supporta anche le versioni .net 3.0 e 2.0 - lì non sono voci di registro per questi. (E peggio, non puoi nemmeno usare i programmi di installazione del framework standard qui, devi usare il supporto integrato e scaricarlo tramite Windows o ricostruire la tua app con .net 4, ma questa è un'altra storia).

L'EXE fittizio C ++ può essere creato utilizzando un progetto con il seguente codice (e un altro in una configurazione a 64 bit se necessario):

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

Ricordarsi di impostare le proprietà del progetto Use of MFC su utilizzare MFC in una DLL condivisa . Gli eseguibili avranno una dimensione di circa 4 KB, un piccolo prezzo da pagare per un risultato sicuro.

Per offrire ai tuoi utenti una bella esperienza di installazione, potresti fare quanto segue (il codice di esempio è per NSIS ):

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

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

e chiamarlo in una funzione, ad esempio 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

Quindi lanciare il controllo di runtime, ad esempio quando si lascia il Benvenuto pagina di e memorizza nella cache il risultato, in modo da non dover ricontrollare ogni volta che l'utente fa clic sui pulsanti "Indietro" e "Avanti".

Quindi, crea una sezione di sola lettura nell'albero di installazione e preselezionala o deselezionala su una funzione che viene eseguita prima dei componenti venga visualizzata la pagina .

Ciò assicurerà che l'installazione di ogni componente runtime mancante sia obbligatoria e che venga saltata se è già presente.

Poiché Visual Studio 2010 e versioni successive hanno smesso di utilizzare WinSxS, potrebbe essere sufficiente verificare la presenza di% windir% \ system32 \ msvcr110.dll. Se vuoi verificare di avere una versione abbastanza nuova, puoi controllare se la versione del file è 11.0.50727.1 (VS2012 RTM) o 11.0.51106.1 (VS2012 Update 1).

Mi sono imbattuto in questa domanda cercando una risposta nel contesto del controllo del ridistribuibile di Visual C ++ come parte di un programma di installazione MSI creato da WiX.

Non mi è piaciuto il modo in cui il GUID cambia con la versione e il sistema operativo, quindi ho finito per creare un'azione personalizzata scritta in C # per verificare la ridistribuibilità di Visual C ++.

Tutto ciò che segue è specifico per Visual C ++ 2015 Redistributable (x64), ma può essere facilmente modificato per qualsiasi versione.

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;
        }
    }
}

Quindi nel file 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>

Modifica Sto aggiornando questa risposta con alcune informazioni di base sulla creazione e l'utilizzo di un'azione personalizzata.

Per creare l'azione personalizzata in Visual Studio 2017 con l'estensione WiX Toolset Visual Studio 2017 installata, ho utilizzato il modello di progetto per creare un'azione personalizzata (C # Custom Action Project per WiX v3).

Ho controllato il progetto generato e sembrava che le modifiche fossero già elencate all'inizio di questo articolo: https://www.codeproject.com/Articles/132918/Creating-Custom-Action-for-WIX-Written-in-Managed così ho preso quell'articolo nella sezioneAdding Custom Action to the Installer e l'ho seguito con alcune modifiche.

Un'altra cosa che ho fatto è stata cambiare la versione del framework .NET su cui è costruito il progetto alla 3.5.

Non l'ho trovato molto utile ma puoi anche vedere http://wixtoolset.org/documentation/manual/v3/wixdev/extensions/authoring_custom_actions.html

Per me questa posizione ha funzionato: HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ DevDiv \ vc \ Servicing \ 11.0 \ RuntimeMinimum \ Version

Controlla quale versione hai dopo aver installato il pacchetto e usala come condizione nel tuo programma di installazione. (il mio è impostato su 11.0.50727 dopo l'installazione di VCred).

Vai su Pannello di controllo> Programmi e funzionalità e vengono visualizzati tutti nell'elenco.

Non sono un esperto e questa risposta è piuttosto semplice rispetto a ciò che rispondono le persone (controllando il registro), quindi non sono sicuro che sia la risposta corretta, ma ha fatto il trucco per me.

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

Ci sono riuscito con InnoSetup.

Ho verificato l'esistenza della chiave di registro:

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

Se disinstallato, non esiste. Se installato, esiste.

A proposito, potrebbe anche essere nel Wow6432Node:

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

Il controllo dello stato di installazione del prodotto tramite MsiQueryProductState è praticamente equivalente al controllo diretto del registro, ma è comunque necessario il GUID per ProductCode .

Come accennato altrove, uno svantaggio di questi approcci è che ogni aggiornamento ha il proprio ProductCode!

Per fortuna, MSI fornisce un UpgradeCode che identifica una "famiglia" di prodotti. Puoi usare orca per aprire uno degli MSI per estrarre queste informazioni. Ad esempio, l'UpgradeCode per il ridistribuibile di VS2015 è{65E5BD06-6392-3027-8C26-853107D3CF1A}

È possibile utilizzare MsiEnumRelatedProducts per ottenere tutti gli ID prodotto per tale UpgradeCode. In pratica, poiché ogni aggiornamento di ridistribuzione sostituisce quello precedente, questo produrrà solo un ProductCode, come {B5FC62F5-A367-37A5-9FD2-A6E137C0096F}per VS2015 Update 2 x86.

Indipendentemente da ciò, puoi quindi controllare la versione tramite MsiGetProductInfo (productCode, INSTALLPROPERTY_VERSIONSTRING, ...) o funzioni simili per confrontarla con la versione che desideri, ad esempio per verificare una versione equivalente o successiva.

Si noti che all'interno di un'applicazione C ++, è anche possibile utilizzare _VC_CRT_MAJOR_VERSION, _VC_CRT_MINOR_VERSION, _VC_CRT_BUILD_VERSIONse #include <crtversion.h>- in questo modo è possibile determinare calcolare la versione CRT che il binario è stato costruito con.

Questo codice PowerShell dovrebbe fare il trucco

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

Avevo bisogno della stessa cosa e, sebbene AFAIK questo non possa essere fatto a livello di programmazione, ha funzionato per me.

Sono appena andato su Start -> Disinstalla un programma e ho fatto scorrere verso il basso fino a trovare il ridistribuibile VC ++, che include un numero di versione. Cercando su Google il numero di versione, mi ha detto che appartiene a VS2012 SP1.

Vecchia domanda, ma ecco l'approccio che abbiamo utilizzato con successo da Visual Studio 2005. L'ho appena testato utilizzando anche Visual Studio 2012 Update 4 (dato che stiamo finalmente aggiornando il nostro software dal 2010 al 2012).

Poiché i pacchetti ridistribuibili di Visual C ++ registrano il loro programma di disinstallazione con Windows (quindi compare nell'elenco "Programmi e funzionalità" del pannello di controllo), controlliamo semplicemente il nome visualizzato della chiave di disinstallazione nel registro.

Ecco il codice NSIS pertinente:

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:

Si noti che poiché il nostro programma di installazione è un exe a 32 bit, Windows gestisce la determinazione se la chiave di registro è effettivamente nel Wow6432Node virtualizzato anziché nella posizione sopra, quindi il codice sopra funziona su entrambe le installazioni di Windows a 64 bit e 32 bit senza dover controllare esplicitamente entrambe le chiavi.

Si noti inoltre che per aggiornare il codice precedente a una versione diversa di VC ++ Redist, è sufficiente modificare il GUID nel percorso della chiave di registro e il nome visualizzato con quello che ti serve.

Anche se questo potrebbe non essere il metodo consigliato, negli ultimi 10 anni ha funzionato su oltre 10.000 macchine eseguendo ogni tipo di Windows da XP / XP64 a Windows 10 utilizzando le ridistribuzioni per 2005, 2010, 2010sp1 e ora 2012u4.

Controllerei il Installedvalore di

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

• dove GUID di VC++ 2012 (x86)è{33d1fd90-4274-48a1-9bc1-97e33d9c2d6f}
• WOW6432Nodesarà presente o meno a seconda del VC++ redistprodotto

Ciò che la maggior parte delle persone perde è la necessità /reg:32di verificare la chiave su Windows x64.

Vedere l' articolo della Guida di Microsoft su questo argomento.

Ecco uno script che dimostra come controllare correttamente Visual C ++ Redistributable per 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 soluzione di script PowerShell:

Sulla base delle informazioni nella risposta di @kayleeFrye_onDeck

Ho creato uno script PowerShell che controlla e installa le versioni specificate dall'utente, non ho eseguito test approfonditi con esso, ma per il mio scenario CI (Continuous Integration) funziona perfettamente.

Lo script completo e le informazioni su GitHub

L'approccio che ho usato era basato sul controllo dei regkeys sulla base delle informazioni fornite qui. Quello che segue è il succo di ciò che fa lo 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
    }
}

Il controllo / download / installazione silenziosa in base al $redistInfoquale contiene le informazioni compilate da kayleeFrye_onDeck's.

$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
}

Lo script completo e ulteriori informazioni possono essere trovati su GitHub

Chiunque può contribuire, se ho tempo farò test più approfonditi dello script e continuerò a provare ad aggiungere nuovi pacchetti man mano che le informazioni vengono aggiunte qui.

È difficile ottenere tutti i valori di registro per VC 2012, quindi ho scritto una piccola funzione che eseguirà tutte le dipendenze e corrisponderà alla versione specificata.

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;
}

dipendenze:

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

puoi cercare nel registro. In realtà non ho vs2012 ma ho vs2010.

Esistono 3 chiavi di registro diverse (ma molto simili) per ciascuno dei 3 pacchetti della piattaforma. Ogni chiave ha un valore DWORD chiamato "Installed" con un valore di 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

È possibile utilizzare la funzione di registro per questo ...