Comment puis-je obtenir la version programme d'une DLL ou un fichier EXE?
Question
Je dois obtenir la version du produit et la version du fichier pour un fichier DLL ou EXE en utilisant des API natives Win32 en C ou C ++. Je suis onglet pas à la recherche de la version Windows, mais les numéros de version que vous voyez par un clic droit sur un fichier DLL, en sélectionnant « Propriétés », puis regarder « Détails ». Cela est généralement un numéro de version en pointillé en quatre parties x.x.x.x.
La solution
Vous utilisez l'API GetFileVersionInfo .
Voir Utilisation des informations sur la version sur MSDN site.
Exemple:
DWORD verHandle = 0;
UINT size = 0;
LPBYTE lpBuffer = NULL;
DWORD verSize = GetFileVersionInfoSize( szVersionFile, &verHandle);
if (verSize != NULL)
{
LPSTR verData = new char[verSize];
if (GetFileVersionInfo( szVersionFile, verHandle, verSize, verData))
{
if (VerQueryValue(verData,"\\",(VOID FAR* FAR*)&lpBuffer,&size))
{
if (size)
{
VS_FIXEDFILEINFO *verInfo = (VS_FIXEDFILEINFO *)lpBuffer;
if (verInfo->dwSignature == 0xfeef04bd)
{
// Doesn't matter if you are on 32 bit or 64 bit,
// DWORD is always 32 bits, so first two revision numbers
// come from dwFileVersionMS, last two come from dwFileVersionLS
TRACE( "File Version: %d.%d.%d.%d\n",
( verInfo->dwFileVersionMS >> 16 ) & 0xffff,
( verInfo->dwFileVersionMS >> 0 ) & 0xffff,
( verInfo->dwFileVersionLS >> 16 ) & 0xffff,
( verInfo->dwFileVersionLS >> 0 ) & 0xffff
);
}
}
}
}
delete[] verData;
}
Autres conseils
Toutes ces solutions ne fonctionnent pas correctement (avec mon système). J'ai découvert que chacune des quatre parties du numéro de version sont enregistrées en tant que valeur 16 bits.
Les deux premiers chiffres sont enregistrés dans les dwFileVersionMS DWORD 32 bits, et les deux seconds en dwFileVersionLS. Donc, je modifié votre code à la section de sortie comme ceci:
TRACE( "File Version: %d.%d.%d.%d\n",
( pFileInfo->dwFileVersionMS >> 16 ) & 0xffff,
( pFileInfo->dwFileVersionMS >> 0 ) & 0xffff,
( pFileInfo->dwFileVersionLS >> 16 ) & 0xffff,
( pFileInfo->dwFileVersionLS >> 0 ) & 0xffff
);
Et cela fonctionne parfaitement. La sortie est formaté comme sur mon système:
major.minor.build.revision
Vous obtenez ces informations en utilisant les API d'information la version . Voici un exemple:
void PrintFileVersion( TCHAR *pszFilePath )
{
DWORD dwSize = 0;
BYTE *pbVersionInfo = NULL;
VS_FIXEDFILEINFO *pFileInfo = NULL;
UINT puLenFileInfo = 0;
// Get the version information for the file requested
dwSize = GetFileVersionInfoSize( pszFilePath, NULL );
if ( dwSize == 0 )
{
printf( "Error in GetFileVersionInfoSize: %d\n", GetLastError() );
return;
}
pbVersionInfo = new BYTE[ dwSize ];
if ( !GetFileVersionInfo( pszFilePath, 0, dwSize, pbVersionInfo ) )
{
printf( "Error in GetFileVersionInfo: %d\n", GetLastError() );
delete[] pbVersionInfo;
return;
}
if ( !VerQueryValue( pbVersionInfo, TEXT("\\"), (LPVOID*) &pFileInfo, &puLenFileInfo ) )
{
printf( "Error in VerQueryValue: %d\n", GetLastError() );
delete[] pbVersionInfo;
return;
}
// pFileInfo->dwFileVersionMS is usually zero. However, you should check
// this if your version numbers seem to be wrong
printf( "File Version: %d.%d.%d.%d\n",
( pFileInfo->dwFileVersionLS >> 24 ) & 0xff,
( pFileInfo->dwFileVersionLS >> 16 ) & 0xff,
( pFileInfo->dwFileVersionLS >> 8 ) & 0xff,
( pFileInfo->dwFileVersionLS >> 0 ) & 0xff
);
// pFileInfo->dwProductVersionMS is usually zero. However, you should check
// this if your version numbers seem to be wrong.
printf( "Product Version: %d.%d.%d.%d\n",
( pFileInfo->dwProductVersionLS >> 24 ) & 0xff,
( pFileInfo->dwProductVersionLS >> 16 ) & 0xff,
( pFileInfo->dwProductVersionLS >> 8 ) & 0xff,
( pFileInfo->dwProductVersionLS >> 0 ) & 0xff
);
}
Ce code indique les numéros de version de fichier correctement.
( pFileInfo->dwFileVersionMS >> 16 ) & 0xff,
( pFileInfo->dwFileVersionMS >> 0 ) & 0xff,
( pFileInfo->dwFileVersionLS >> 16 ) & 0xff,
( pFileInfo->dwFileVersionLS >> 0 ) & 0xff);
trouvé ces articles ... désolé, mais je n'ai pas l'expérience directe avec la façon de le faire en utilisant des API natives, donc je Reporté à une recherche sur Internet:
- C ++: Identification de la version nombre d'une DLL ou Executable
- VB (probablement la version 6): Comment utiliser fonctions de VERSION.DLL
espère que ces aide!
Le plus simple est d'utiliser le GetFileVersionInfoEx ou GetFileVersionInfo fonctions API.
Vous pouvez aussi le faire à partir de vos ressources d'application comme expliqué .
Étant donné qu'aucune des réponses mentionner ... Je trouve que vous devez faire des calculs différents selon si vous utilisez des systèmes 32 bits ou 64 bits . Voilà pourquoi vous trouvez que certaines réponses dans ce travail de question pour vous, et d'autres ne le font pas.
Voici une exemple d'implémentation que j'utilise:
if(IsWow64())
{
// 64 bit build
major = (verInfo->dwProductVersionMS >> 16) & 0xffff;
minor = (verInfo->dwProductVersionMS >> 0) & 0xffff;
revision = (verInfo->dwProductVersionLS >> 16) & 0xffff;
build = (verInfo->dwProductVersionLS >> 0) & 0xffff;
}
else
{
// 32 bit build
major = HIWORD(verInfo->dwProductVersionMS);
minor = LOWORD(verInfo->dwProductVersionMS);
revision = HIWORD(verInfo->dwProductVersionLS);
build = LOWORD(verInfo->dwProductVersionLS);
}
Et la mise en œuvre de IsWow64 (pas le mien):
typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
LPFN_ISWOW64PROCESS fnIsWow64Process;
BOOL IsWow64()
{
BOOL bIsWow64 = FALSE;
//IsWow64Process is not available on all supported versions of Windows.
//Use GetModuleHandle to get a handle to the DLL that contains the function
//and GetProcAddress to get a pointer to the function if available.
fnIsWow64Process = (LPFN_ISWOW64PROCESS) GetProcAddress(
GetModuleHandle(TEXT("kernel32")),"IsWow64Process");
if(NULL != fnIsWow64Process)
{
if (!fnIsWow64Process(GetCurrentProcess(),&bIsWow64))
{
// Handle error...
}
}
return bIsWow64;
}