Detectar se o Visual C ++ Redistributable para Visual Studio 2012 está instalado

Como detectar se o Visual C ++ Redistributable for Visual Studio 2012 está instalado?

Experimentei o Google e ninguém fez essa pergunta, surpresa!

Depende de qual versão você está usando. Essas duas chaves de 2012 funcionaram bem para mim com suas versões correspondentes para baixar para a atualização 4. Esteja ciente de que alguns desses locais de registro podem ser dependentes do sistema operacional. Eu coletei essas informações de uma caixa do Windows 10 x64 . Vou apenas prosseguir e descartar todas essas versões redist e as chaves de registro que procuro para detectar a instalação:

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

advertência de versão : Por usuário Wai Ha Lee 's descobertas, "... os binários que vêm com VC ++ 2012 atualização 4 ( 11.0.61030.0) têm versão 11.0.60610.1para os binários ATL e MFC e 11.0.51106.1para todo o resto, por exemplo, 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 de download direto: 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 download direto: https://download.microsoft.com/download/2/E/6/2E61CFA4-993B-4DD4-91DA-3737CD5CD6E3/vcredist_x86.exe

Visual C ++ 2015

_{^{Considere usar o pacote 2015-2019 como uma 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 de download direto: 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 download direto: https://download.microsoft.com/download/6/A/A/6AA4EDFF-645B-48C5-81CC-ED5963AEAD48/vc_redist.x86.exe

Visual C ++ 2017

_{^{Considere usar o pacote 2015-2019 como uma alternativa}}

Advertência : há uma nova convenção de registro de 2017 sendo usada ou ela ainda não foi finalizada. Como estou adivinhando as teclas superiores de: [HKEY_CLASSES_ROOT\Installer\Dependencies\,,amd64,14.0,bundle] e [HKEY_CLASSES_ROOT\Installer\Dependencies\,,x86,14.0,bundle]

estão sujeitos a alterações ou, pelo menos, têm GUIDs aninhados diferentes, vou usar listar a chave que termina com um 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 download direto: 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 download direto: https://download.visualstudio.microsoft.com/download/pr/d0b808a8-aa78-4250-8e54-49b8c23f7328/9c5e6532055786367ee61aafb3313c95/vc_redist.x86.exe

Visual C ++ 2019 ( pacote 2015-2019 )

Advertência : há outra nova convenção de registro sendo usada para Visual C ++ 2019. Também não parece haver um instalador autônomo para Visual C ++ 2019, apenas este instalador de pacote que é Visual C ++ 2015 a 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 download direto: 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 download direto: 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 download direto: 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 download direto: https://download.visualstudio.microsoft.com/download/pr/cc0046d4-e7b4-45a1-bd46-b1c079191224/9c4042a4c2e6d1f661f4c58cf4d129e9/vc_redist.x64.exe

Registro de alterações :
19 de agosto de 2019 - Adicionada uma nova versão da versão do pacote 2015-2019
13 de junho de 2019 - Adicionada uma nova seção para a versão 2015-2019 do pacote 14.21.27702e adicionadas _{^{pequenas notas}} às seções de 2015 e 2017 sobre como considerar o uso de o novo pacote como alternativa.
14 de dezembro de 2018 - MSVC2008 atualizado para a 9.0.30729.6161atualização do Service Pack 1 de acordo com as descobertas de Jim Wolff
27 de novembro de 2018 - Informações atualizadas para MSVC2017 v. 14.16
12 de setembro de 2018 - Adicionada limitação de versão à Atualização 4 de 2012 de acordo com as descobertas de Wai Ha Lee
em 24 de agosto, 2018 - versão de 2017 atualizada para 14.15.26706, as dependências do Visual C ++ atualizadas empacotadas com o VS 2017 15.8.1
16 de maio de 2018 - versão de 2017 atualizada para 14.14.26405.0 como a nova entrada C ++ 2017
8 de setembro de 2017 - versão de 2017 atualizada para 14.11.25325.0 como a nova entrada do Visual C ++ 2017
7 de abril de 2017 - versão atualizada de 14.10.25008.0 de 2017 como a nova entrada do Visual C ++ 2017
24 de outubro de 2016 - informações da versão de 2015 atualizadas para 14.0.24215.1
18 de agosto de 2016 - Informações atualizadas da versão de 2015 para 14.0.24212
27 de maio de 2016 - Informações atualizadas para MSVC2015 Atualização 2

Entre em contato comigo aqui se algum deles ficar desatualizado.

Experimentar

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

como ponto de partida. Vou usar isso como uma verificação para instalar o tempo de execução do VC ++ 11 (VS 2012).

Você pode verificar se o Installedvalor está 1neste local de registro: HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\11.0\VC\Runtimes\x86em sistemas de 64 bits. No código que resultaria no acesso à chave do registro HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\11.0\VC\Runtimes\x86. Observe a ausência de Wow6432Node.

Em um sistema de 32 bits, o registro é o mesmo sem Wow6432Node:HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\11.0\VC\Runtimes\x86

Não há nenhum elemento installcheck no manifesto do pacote de bootstrapper fornecido com o Visual C ++. Acho que a Microsoft sempre deseja instalar se você configurá-lo como um pré-requisito.

Claro, você ainda pode chamar MsiQueryProductState para verificar se o pacote VC redist está instalado via MSI. O código do pacote pode ser encontrado executando

wmic product get

na linha de comando, ou se você já estiver em wmic: root \ cli, execute

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

A resposta a essas perguntas simples, infelizmente, não é simples, mas funciona em 100% de todos os sistemas e pode ser estendida até mesmo a vários frameworks .net.

A complexidade vem do fato de que há (e havia) muitas revisões de tempos de execução VC que poderiam levar ao caso de que, embora os tempos de execução VC10 tenham sido instalados, seu número de compilação não era recente o suficiente para que seu EXE não fosse iniciado a menos que você instalasse o tempos de execução exatos que você exigiu ou um dos tempos de execução mais recentes que permitem esta e as versões anteriores para a mesma versão principal rodar com ele (o inferno lado a lado). Além disso, se você tiver um EXE de 64 bits, terá que verificar os dois tempos de execução de 32 E 64 bits.

Dito isso, a única maneira confiável de determinar se os tempos de execução do EXE estão instalados é tentar executar o EXE - ou outro EXE que é construído com as mesmas configurações do EXE principal e cujo único propósito é - nada. Basta executar (o que significa que os tempos de execução estão instalados) ou falhar ao executar (quando não instalado).

Eu fiz o seguinte para um instalador que exigia os tempos de execução VC10 de 32 e 64 bits instalados: O instalador tenta iniciar todos os EXEs fictícios e, se tiver êxito, o tempo de execução correspondente é considerado instalado. Isso também resolve o cenário de 32/64 bits.

A propósito, isso também funciona para determinar se a estrutura .net adequada está instalada, o que é muito complicado no Windows 8 e 10, já que o suporte para .net 3.5 integrado para download também oferece suporte para as versões .net 3.0 e 2.0 - aí não há entradas de registro para eles. (E pior, você não pode nem mesmo usar os instaladores do framework padrão aqui, você deve usar o suporte integrado e baixá-lo via Windows, ou reconstruir seu aplicativo com .net 4, mas isso é outra história).

O EXE fictício C ++ pode ser construído usando um projeto com o seguinte código (e outro em uma configuração de 64 bits, se necessário):

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

Lembre-se de definir as propriedades do projeto Uso de MFC para usar MFC em uma DLL compartilhada . Os executáveis ​​terão cerca de 4 KB - um pequeno preço a pagar por um resultado certo.

Para dar aos seus usuários uma boa experiência de instalação, você pode fazer o seguinte (o código de exemplo é para 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 chamá-lo em uma função, por exemplo, 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

Em seguida, inicie a verificação de tempo de execução, por exemplo, ao sair da página de boas - vindas e armazene o resultado em cache, para que você não precise verificar novamente toda vez que o usuário clicar no botão "Voltar" e "Avançar".

Em seguida, crie uma seção somente leitura na árvore de instalação e pré-selecione ou desmarque-a em uma função que é executada antes que a página Componentes seja exibida.

Isso garantirá que a instalação de cada componente de tempo de execução ausente seja obrigatória e seja ignorada se já estiver presente.

Como o Visual Studio 2010 e posterior parou de usar WinSxS, pode ser o suficiente apenas verificar% windir% \ system32 \ msvcr110.dll. Se você deseja verificar se tem uma versão nova o suficiente, você pode verificar se a versão do arquivo é 11.0.50727.1 (VS2012 RTM) ou 11.0.51106.1 (VS2012 Atualização 1).

Me deparei com essa pergunta procurando uma resposta no contexto de verificação do Visual C ++ redistribuível como parte de um instalador MSI criado por WiX.

Não gostei de como o GUID mudou com a versão e o sistema operacional, então acabei criando uma ação personalizada escrita em C # para verificar se o Visual C ++ pode ser redistribuído.

Tudo a seguir é especificamente para Visual C ++ 2015 Redistributable (x64), mas pode ser facilmente modificado para qualquer versão.

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

Então, no arquivo 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>

Editar Estou atualizando esta resposta com algumas informações básicas sobre como criar e usar uma ação personalizada.

Para criar a ação personalizada no Visual Studio 2017 com a extensão WiX Toolset Visual Studio 2017 instalada, usei o modelo de projeto para criar uma ação personalizada (C # Custom Action Project para WiX v3).

Verifiquei o projeto gerado e parecia que já havia as alterações listadas no início deste artigo: https://www.codeproject.com/Articles/132918/Creating-Custom-Action-for-WIX-Written-in-Managed então peguei aquele artigo na seção Adding Custom Action to the Installere o segui com alguns ajustes.

Outra coisa que fiz foi mudar a versão do .NET framework em que o projeto foi criado para 3.5.

Não achei muito útil, mas você também pode ver http://wixtoolset.org/documentation/manual/v3/wixdev/extensions/authoring_custom_actions.html

Para mim, este local funcionou: HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ DevDiv \ vc \ Servicing \ 11.0 \ RuntimeMinimum \ Version

Verifique qual versão você tem depois de instalar o pacote e use-a como uma condição em seu instalador. (o meu é definido para 11.0.50727 após a instalação do VCred).

Basta ir ao Painel de Controle> Programas e Recursos, e todos eles aparecem listados lá.

Não sou um especialista e essa resposta é muito simples em comparação com o que as pessoas estão respondendo (verificando o registro), então não tenho certeza se é a resposta correta, mas funcionou para mim.

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

Consegui fazer isso com InnoSetup.

Eu verifiquei a existência da chave de registro:

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

Se desinstalado, ele não existe. Se instalado, ele existe.

A propósito, também pode estar no nó Wow6432:

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

Verificar o estado de instalação do produto por meio de MsiQueryProductState é praticamente equivalente a verificar o registro diretamente, mas você ainda precisa do GUID para o ProductCode .

Conforme mencionado em outro lugar, uma desvantagem dessas abordagens é que cada atualização tem seu próprio ProductCode!

Felizmente, a MSI fornece um UpgradeCode que identifica uma 'família' de produtos. Você pode usar o orca para abrir um dos MSIs para extrair essas informações. Por exemplo, o UpgradeCode for VS2015's redistributable é{65E5BD06-6392-3027-8C26-853107D3CF1A}

Você pode usar MsiEnumRelatedProducts para obter todos os IDs de produto para esse UpgradeCode. Na prática, como cada atualização redist substitui a anterior, isso produzirá apenas um ProductCode - como {B5FC62F5-A367-37A5-9FD2-A6E137C0096F}para VS2015 Atualização 2 x86.

Independentemente disso, você pode verificar a versão via MsiGetProductInfo (productCode, INSTALLPROPERTY_VERSIONSTRING, ...) ou funções semelhantes para comparar com a versão desejada, por exemplo, para verificar se há uma versão equivalente ou posterior.

Note-se que dentro de um aplicativo C ++, você também pode usar _VC_CRT_MAJOR_VERSION, _VC_CRT_MINOR_VERSION, _VC_CRT_BUILD_VERSIONse você #include <crtversion.h>- desta forma você pode determinar calcular a versão CRT que seu binário foi construído com.

Este código PowerShell deve fazer o truque

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

Eu precisava da mesma coisa e, embora AFAIK isso não possa ser feito de forma programática, funcionou para mim.

Eu simplesmente fui para Iniciar -> Desinstalar um programa e rolei para baixo até encontrar o VC ++ redistribuível, que inclui um número de versão. Pesquisando o número da versão, me disse que pertence ao VS2012 SP1.

Pergunta antiga, mas aqui está a abordagem que usamos desde o Visual Studio 2005 com sucesso. Eu apenas testei usando o Visual Studio 2012 Update 4 também (já que estamos finalmente atualizando nosso software de 2010 a 2012).

Como os pacotes redistribuíveis do Visual C ++ registram seu desinstalador com o Windows (para que apareça na lista "Programas e Recursos" do Painel de Controle), simplesmente verificamos o Nome de Exibição da chave do desinstalador no registro.

Aqui está o código NSIS relevante:

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:

Observe que, como nosso instalador é um exe de 32 bits, o Windows determina se a chave de registro está realmente no Wow6432Node virtualizado em vez do local acima, de modo que o código acima funciona em instalações com Windows de 64 e 32 bits sem ter que verificar as duas chaves explicitamente.

Observe também que, para atualizar o código acima para uma versão diferente do VC ++ Redist, basta alterar o GUID no caminho da chave de registro e o nome de exibição para o que for necessário.

Embora esse possa não ser o método recomendado, ele funcionou em mais de 10.000 máquinas nos últimos 10 anos executando todos os tipos de janelas do XP / XP64 até o Windows 10 usando redistores para 2005, 2010, 2010sp1 e agora 2012u4.

Eu verificaria o Installedvalor de

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

• onde GUID de VC++ 2012 (x86)é{33d1fd90-4274-48a1-9bc1-97e33d9c2d6f}
• WOW6432Nodeestará presente ou não dependendo do VC++ redistproduto

O que a maioria das pessoas não percebe é a necessidade /reg:32de verificar a chave no Windows x64.

Consulte o artigo da Ajuda da Microsoft sobre este assunto.

Aqui está um script que demonstra como verificar corretamente o Visual C ++ Redistributable para 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

A solução de script do PowerShell:

Com base nas informações da resposta de @kayleeFrye_onDeck

Eu criei um script PowerShell que verifica e instala as versões que o usuário especifica, não fiz testes extensivos com ele, mas para o meu próprio cenário de CI (Integração Contínua) ele funciona perfeitamente.

O script completo e informações sobre o github

A abordagem que usei foi baseada na verificação dos regkeys com base nas informações fornecidas aqui. A seguir está a essência do que o script faz:

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

A verificação / download / instalação silenciosa com base na $redistInfoqual contém as informações compiladas de 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
}

O script completo e mais informações podem ser encontrados no github

Qualquer pessoa é bem-vinda para contribuir, se eu tiver tempo farei testes mais extensos do script e continuarei tentando adicionar novos pacotes conforme as informações são adicionadas aqui.

É difícil obter todos os valores de registro para VC 2012, então escrevi uma pequena função que irá passar por todas as dependências e corresponder à versão especificada.

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

Dependências:

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

você pode pesquisar no registro. Na verdade, não tenho o vs2012, mas tenho o vs2010.

Existem 3 chaves de registro diferentes (mas muito semelhantes) para cada um dos 3 pacotes de plataforma. Cada chave possui um valor DWORD denominado “Instalado” com o valor 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

Você pode usar a função de registro para isso ......