How to detect VC++ 2008 redistributable?

Detecting the Presence of VC++ 2008 Redistributable

Learn various methods to programmatically and manually detect if the Microsoft Visual C++ 2008 Redistributable is installed on a Windows system.

The Microsoft Visual C++ 2008 Redistributable Package installs runtime components of Visual C++ libraries required to run applications developed with Visual C++ 2008 on a computer that does not have Visual C++ 2008 installed. Detecting its presence is crucial for application installers, troubleshooting, and ensuring compatibility. This article explores several reliable methods to determine if this specific redistributable is installed on a Windows system.

Method 1: Registry Key Check

The most robust and programmatic way to detect installed software, including VC++ redistributables, is by querying the Windows Registry. Each installed redistributable typically leaves specific entries under the HKEY_LOCAL_MACHINE hive. For VC++ 2008, you'll primarily look for entries related to its version and architecture (x86 or x64).

flowchart TD
    A[Start] --> B{"Check HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall"}
    B --> C{"Enumerate Subkeys"}
    C --> D{"Filter by DisplayName containing 'Microsoft Visual C++ 2008 Redistributable'"}
    D --> E{"Check Version and Architecture (x86/x64)"}
    E -- "Match Found" --> F[VC++ 2008 Redistributable Detected]
    E -- "No Match" --> G[VC++ 2008 Redistributable Not Found]
    F --> H[End]
    G --> H[End]

Flowchart for detecting VC++ 2008 Redistributable via Registry

using Microsoft.Win32;
using System;

public class VCRedistDetector
{
    public static bool IsVC2008RedistInstalled(bool is64Bit)
    {
        string uninstallKey = @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall";
        using (RegistryKey rk = Registry.LocalMachine.OpenSubKey(uninstallKey))
        {
            if (rk == null) return false;

            foreach (string skName in rk.GetSubKeyNames())
            {
                using (RegistryKey sk = rk.OpenSubKey(skName))
                {
                    if (sk == null) continue;

                    string displayName = sk.GetValue("DisplayName") as string;
                    if (!string.IsNullOrEmpty(displayName) &&
                        displayName.Contains("Microsoft Visual C++ 2008 Redistributable") &&
                        displayName.Contains(is64Bit ? "x64" : "x86"))
                    {
                        // Further checks could include version numbers if needed
                        return true;
                    }
                }
            }
        }
        return false;
    }

    public static void Main(string[] args)
    {
        Console.WriteLine($"VC++ 2008 Redistributable (x86) installed: {IsVC2008RedistInstalled(false)}");
        Console.WriteLine($"VC++ 2008 Redistributable (x64) installed: {IsVC2008RedistInstalled(true)}");
    }
}

C# code to check for VC++ 2008 Redistributable using Registry

Method 2: Checking for Specific DLLs

While less reliable than registry checks due to potential file deletion or corruption without proper uninstallation, checking for the presence of key DLL files can serve as a secondary or quick check. The VC++ 2008 Redistributable typically installs msvcr90.dll, msvcp90.dll, and msvcm90.dll into the WinSxS (Side-by-Side) directory or the system directory.

$dllName = "msvcr90.dll"
$system32Path = "$env:SystemRoot\System32\$dllName"
$syswow64Path = "$env:SystemRoot\SysWOW64\$dllName"

if (Test-Path $system32Path) {
    Write-Host "$dllName found in System32 (likely x64 or 32-bit on 32-bit OS)"
}

if (Test-Path $syswow64Path) {
    Write-Host "$dllName found in SysWOW64 (likely x86 on 64-bit OS)"
}

if (!(Test-Path $system32Path) -and !(Test-Path $syswow64Path)) {
    Write-Host "$dllName not found in standard system directories."
}

PowerShell script to check for a specific VC++ 2008 DLL

Method 3: Using Windows Installer (MSI) API

For a more robust and official approach, especially within an installer or setup program, you can leverage the Windows Installer (MSI) API. This allows you to query installed products and components. The VC++ redistributables are installed as Windows Installer packages, making them discoverable through this API.

sequenceDiagram
    participant App as Application/Installer
    participant MSI as Windows Installer API
    participant Reg as Registry

    App->>MSI: MsiEnumProductsEx(ProductCode, ...)
    MSI->>Reg: Query HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData
    Reg-->>MSI: Product Information
    MSI-->>App: Enumerate ProductCodes
    App->>MSI: MsiGetProductInfo(ProductCode, INSTALLPROPERTY_PACKAGENAME)
    MSI-->>App: Package Name (e.g., 'vcredist_x86.msi')
    App->>App: Check for VC++ 2008 specific ProductCodes/Package Names
    App-->>App: Determine presence based on matches

Sequence diagram for detecting VC++ redistributable using MSI API

C++ (MSI API)

#include <windows.h> #include <msi.h> #include <msiquery.h> #include

// Simplified example - real world would iterate products and check properties // Product codes for VC++ 2008 Redistributable vary by version and architecture. // You would typically look for specific ProductCodes or check DisplayName.

// Example ProductCode for VC++ 2008 SP1 Redistributable (x86) - this is just an example, // actual codes vary and should be looked up for specific versions. // const wchar_t* VC2008_X86_PRODUCT_CODE = L"{FF66E9F6-83E8-3A11-8D8C-A70799173200}";

bool IsVC2008RedistInstalledMSI() { // This is a very simplified example. A robust solution would enumerate all products // and check their properties (like DisplayName or UpgradeCode). // For VC++ 2008, you'd typically look for a product whose DisplayName contains // "Microsoft Visual C++ 2008 Redistributable".

// A more direct approach might be to check for specific UpgradeCodes or ProductCodes
// if you know them for the exact redistributable you're looking for.
// Example: MsiEnumRelatedProducts(L"{UpgradeCode}", 0, 0, &productCode);

// For demonstration, let's assume we're looking for a specific product code.
// In reality, you'd iterate through all installed products and check their names.
// This requires more complex logic involving MsiEnumProducts and MsiGetProductInfo.

// As a simpler alternative, the registry method (Method 1) is often preferred
// for its directness in many programming languages.

// Return false for this simplified example, as direct ProductCode lookup is brittle.
// Use the registry method for better reliability in C++ as well.
return false;

}

int main() { std::wcout << L"VC++ 2008 Redistributable (MSI API check - simplified): " << (IsVC2008RedistInstalledMSI() ? L"Installed" : L"Not Installed") << std::endl; return 0; }

Python (using wmi or winreg)

import winreg import wmi # Requires 'pip install wmi'

def is_vc2008_redist_installed_registry(is_64bit): try: # Check 64-bit uninstall key first, then 32-bit if on 64-bit OS reg_path = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall" arch_suffix = " (x64)" if is_64bit else " (x86)"

    for hive in [winreg.HKEY_LOCAL_MACHINE]:
        try:
            with winreg.OpenKey(hive, reg_path, 0, winreg.KEY_READ) as key:
                for i in range(0, winreg.QueryInfoKey(key)[0]):
                    skey_name = winreg.EnumKey(key, i)
                    with winreg.OpenKey(key, skey_name) as skey:
                        try:
                            display_name = winreg.QueryValueEx(skey, "DisplayName")[0]
                            if "Microsoft Visual C++ 2008 Redistributable" in display_name and arch_suffix in display_name:
                                return True
                        except OSError:
                            continue
        except OSError:
            continue
except Exception as e:
    print(f"Error checking registry: {e}")
return False

def is_vc2008_redist_installed_wmi(): try: c = wmi.WMI() for product in c.Win32_Product(): if product.Name and "Microsoft Visual C++ 2008 Redistributable" in product.Name: return True except Exception as e: print(f"Error checking WMI: {e}") return False

if name == "main": print(f"VC++ 2008 Redistributable (x86) installed (Registry): {is_vc2008_redist_installed_registry(False)}") print(f"VC++ 2008 Redistributable (x64) installed (Registry): {is_vc2008_redist_installed_registry(True)}") print(f"VC++ 2008 Redistributable installed (WMI): {is_vc2008_redist_installed_wmi()}")

Manual Verification

For troubleshooting or quick checks, you can manually verify the presence of the redistributable through the Windows Control Panel.

1. Open 'Programs and Features'

Navigate to Control Panel > Programs > Programs and Features (or type appwiz.cpl in the Run dialog and press Enter).

2. Search for VC++ 2008

In the list of installed programs, look for entries starting with 'Microsoft Visual C++ 2008 Redistributable'. Pay attention to the architecture (x86 or x64) and any service pack versions (e.g., SP1).

3. Verify Version

If multiple versions are present, ensure the specific version you require is listed. The 'Version' column can provide this detail.