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

109

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

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

sean717
fonte
1
Por que não remover essa dependência configurando a biblioteca Runtime em C ++> Geração de código como Multi-threaded [depurar] em vez de Multi-threaded [depurar] dll? Acabei de resolver um problema de instalação redist em tempo de execução simplesmente removendo a dependência.
Cem Kalyoncu
Descobri como detectar pacotes por tentativa e erro. Eu gostaria que houvesse uma bala mágica, mas se houver, ainda não a encontrei. Eu tenho uma resposta abaixo para alguns redistas específicos que parecem trabalhar 100% do tempo para ajudar com a maioria deles atualmente .
kayleeFrye_onDeck
3
Considere alterar a resposta aceita para kayleeFrye_onDeck. Passei muito tempo procurando um método confiável e este parece ser o único, acho que, com todas as outras respostas não confiáveis, ajudará muitas pessoas a encontrar as informações certas
musefan
Parece haver uma atualização para tempos de execução do Visual Studio 2017: 14.10.V25017. Link: go.microsoft.com/fwlink/?LinkId=746572 Você poderia atualizar os valores do Registro?
karel vergauwe

Respostas:

172

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.

kayleeFrye_onDeck
fonte
4
Isto é perfeito. Este é o único que descobri que não dá falsos positivos quando o Visual Studio é instalado ou o tempo de execução é desinstalado.
AN
2
O GUID da pré-atualização 1 do VS2015 é {74d0e5db-b326-4dae-a6b2-445b9de1836e}, portanto, você pode entrar em apuros usando este mecanismo. Para cada atualização futura! Iniciar o VCRedist pré-atualização 1 com a Atualização 1 instalada deu-me um erro - então vou usar a chave de registro do instalador VC - que parece estar bem se você usar o VCRedist?
GilesDMiddleton
4
infelizmente isso não contém VCREDIST 14.0 Atualização 2 - como lidamos com a compatibilidade com versões futuras (detectando versões mais recentes e sucessivas do mesmo tempo de execução)
Shaun Wilson
2
@ManjunathBabu, não acredito que haja qualquer documentação externa relacionada às convenções de registro para os instaladores redistribuíveis do Visual C ++. Acabei de notar que eles pareciam realmente seguir algo semelhante a um esquema desta vez para 2017, em vez de apenas jogar outro GUID em algum lugar sem um nome de chave pai significativo. Até agora, eles usaram esses locais para todos os instaladores lançados para 2017: [HKEY_CLASSES_ROOT\Installer\Dependencies\,,x86,14.0,bundle\Dependents\{$GUID}e[HKEY_CLASSES_ROOT\Installer\Dependencies\,,amd64,14.0,bundle\Dependents\{$GUID}
kayleeFrye_onDeck
2
O novo pacote do Visual C ++ 2017 altera o caminho do registro (versão 14.16.27012.6)[HKEY_CLASSES_ROOT\Installer\Dependencies\VC,redist.x86,x86,14.16,bundle] [HKEY_CLASSES_ROOT\Installer\Dependencies\VC,redist.x64,amd64,14.16,bundle]
live2
31

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).

Dave Dawkins
fonte
7
HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ DevDiv \ vc \ Servicing \ 11.0 \ RuntimeMinimum \ Install deve ser definido como 1
Alex Spence
3
Para 32 bits (também conhecido como x86), a chave está localizada em:HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\DevDiv\VC\Servicing\11.0\RuntimeMinimum
CodeFox
@kayleeFrye_onDeck, você descobriu como fazer isso? Ainda estou procurando uma maneira confiável também, mas nenhuma das respostas nesta página funcionou para mim
AN
Resposta melhor do que a aceita, pois não depende do pacote UUID, provavelmente mudando a cada patch que a Microsoft fornecer
jpo38
25

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

Mike de Klerk
fonte
Eu tenho uma máquina Win7 de 32 bits com o runtime VC ++ 2012 instalado e não tenho essa chave reg.
BryanJ
Tem certeza de que não possui `HKEY_LOCAL_MACHINE \ SOFTWARE \ Microsoft \ VisualStudio \ 11.0 \ VC`? O que você tem?
Mike de Klerk
2
Sim, HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\11.0\VCmas não tenho a Runtimeschave. Eu tenho a chave da resposta de Dave HKLM\SOFTWARE\Microsoft\DevDiv\VC\Servicing\11.0.
BryanJ
@BryanJ Estranho que cada sistema possa ser tão diferente ... Obrigado por adicionar esta informação útil
Mike de Klerk
3
História engraçada e nenhuma informação real da MS. Acho que você tem a melhor resposta que encontrei até agora. Testei para instalar o vcredist em uma VM relativley fresca e esta é a única chave que encontrei depois. Então, polegar para cima do meu lado ...
anhoppe
12

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%'"
Sheng Jiang 蒋 晟
fonte
10

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.

Michael
fonte
Obrigado pela dica útil, você se lembra que tipo de projeto deve ser criado? O VS tem muitos deles para escolher :-).
greenoldman
9

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).

BCran
fonte
+1 isto é mais simples e mais infalível. As chaves do registro estão todas bem e tal, mas se o usuário mexeu no sistema e excluiu msvcr110.dll a verificação do registro é inútil. É melhor verificar todos os componentes de que você precisa (msvcr110.dll, msvcp110.dll, mfc, ...). E para a atualização 3, a versão é 11.0.60610.1.
stijn
ok, ignore essa última parte: parece que apenas o instalador é 11.0.60610.1, a versão das dlls crt ainda é 11.0.51106.1
stijn
sim, o .dll é 11.0.51106.1, embora eu tenha o vs2012 sp4 instalado
Blub
Isso não vai funcionar. Desinstalei 2005-2015 e ainda tenho arquivos msvc para 60, 100, 110, 120 e 140 lá.
kayleeFrye_onDeck
Observe que os binários que vêm com a atualização 4 ( 11.0.61030.0) do VC ++ 2012 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. Não sei por quê. Você pode confirmar isso (nas máquinas com Windows 10 em que testei) acessando C:\ProgramData\Package Cache\{BD95A8CD-1D9F-35AD-981A-3E7925026EBB}v11.0.61030\packages\vcRuntimeMinimum_x86e C:\ProgramData\Package Cache\{B175520C-86A2-35A7-8619-86DC379688B9}v11.0.61030\packages\vcRuntimeAdditional_x86inspecionando os arquivos nos arquivos .cab.
Wai Ha Lee de
5

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

TJ Rockefeller
fonte
4

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).

attila
fonte
Esta resposta é exatamente o que estávamos procurando (em comparação com outras respostas aqui, que são menos sobre o tempo de execução e mais sobre Visual Studio, infelizmente.)
Shaun Wilson
Essa resposta não funciona, pois essa chave existe depois que você desinstalou os redistas.
kayleeFrye_onDeck
4

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.

Programas e características

Adrian Pauly
fonte
3
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
Al.Pertro
fonte
3

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

Fandi Susanto
fonte
Isso não é verdade. As chaves existem em ambos os locais quando foram desinstaladas.
kayleeFrye_onDeck
1
@kayleeFrye_onDeck Sim ... Devo concordar com você. Mas, na verdade, quando tentei pela primeira vez, foi bem sucedido. Mas recentemente é como você disse. Não sei por que é assim.
Fandi Susanto
3

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.

adzm
fonte
Como você conseguiu essa informação? E esse é o UpgradeCode para a versão x86 ou x64?
Ben Key
Você pode usar o Orca para abrir o msi e extrair o UpgradeCode. O fornecido aqui é para x86, pelo menos. Quanto a onde obtive o resto das informações, esta é basicamente a fonte primária; Não consegui encontrar outras referências a essa abordagem online em relação à redist especificamente, mas o padrão UpgradeCode / família é comum com instaladores MSI.
adzm
Estou ciente de Orca. O problema tem a ver com chegar a esse MSI. Não conheço uma maneira de acessá-lo diretamente. A única maneira que conheço é encontrá-lo de alguma forma no diretório c: \ Windows \ Installer. Tenho mais de 1.000 arquivos nesse diretório. Os arquivos são nomeados aleatoriamente. A única maneira de determinar qual MSI está correto é examinar a descrição. Isso envolve pressionar Alt + Enter em 1.000 arquivos no explorer ou usar uma ferramenta para despejar as descrições de 1.000 arquivos.
Ben Key
Ahh, entendi. Você também pode pesquisar o registro para encontrar o caminho ou mesmo o código de atualização se souber o código do produto, em HKLM \ SOFTWARE \ Microsoft \ Windows \ CurrentVersion \ Installer \ UpgradeCodes. No entanto, pode ser necessário usar o WMIC (ou algum outro acesso programático ao msi db) para descobrir o resto. wmic product get / format: csv irá despejar um csv que você pode pesquisar - ele tem os caminhos msi nos valores retornados. Você poderia escrever um roteiro melhor, tenho certeza, mas isso deve ser o suficiente para colocá-lo no seu caminho.
adzm
3

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
Ernie C
fonte
porque codificar um monte de códigos de produto não funcionaria, nós também enumeramos o registro verificando o "nome do produto" de cada entrada com um regex, então verificamos VersionMajor / VersionMinor (que é tudo o que realmente nos interessa), este tem o valor de nos permitir produzir um único build e saber que ele continuará funcionando durante a vida útil de uma determinada versão do vcredist. a intenção aqui é exata, mas pode exigir transliteração para conjuntos de ferramentas como NSIS ou instaladores baseados em WinAPI.
Shaun Wilson
2

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.

bavaza
fonte
2

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.

kinar
fonte
1

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
Aprendiz
fonte
0

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
war59312
fonte
0

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.

Jim Wolff
fonte
0

É 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;
ssamko
fonte
-5

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

vikky
fonte
1
Eu escrevi isso na primeira linha "Que eu não tenho VS2012". Portanto, não há necessidade de comentar isso ............. E isso foi apenas para vs2010
vikky
1
Você notou isso, mas parecia que estava sugerindo que sua solução pode funcionar para o VS2012 também, já que essa era a pergunta do OP (mas não foi possível verificar porque você não tem o VS2012). Eu estava simplesmente afirmando que essa abordagem, de fato, não funciona com o VS2012 desde que o verifiquei.
StellarEleven
Por que votar na minha resposta ...... Eu deixei claro que é para vs2012 ... e isso é aceito como resposta pelo usuário .... então, por quê ???????????
vikky
1
Parece que com um sistema operacional x64 bit este valor está localizado emHKLM\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\VC\VCRedist\...
bas
1
As chaves do VS 2012 são HKLM \ SOFTWARE \ Microsoft \ VisualStudio \ 11.0 \ VC \ RunTimes ____ HKLM \ SOFTWARE \ Wow6432Node \ Microsoft \ VisualStudio \ 11.0 \ VC \ RunTimes ___
Adam L