Cómo determinar el sistema operativo

Question

cómo implementar una función que devolverá el nombre del sistema operativo? detectar el entorno donde se ejecuta el programa?

win2000/xp/vista/win7 etc ...?

Answer 1

Algo como esto:

function osver: string; 
begin 
    result := 'Unknown (Windows ' + IntToStr(Win32MajorVersion) + '.' + IntToStr(Win32MinorVersion) + ')'; 
    case Win32MajorVersion of 
    4: 
     case Win32MinorVersion of 
     0: result := 'Windows 95'; 
     10: result := 'Windows 98'; 
     90: result := 'Windows ME'; 
     end; 
    5: 
     case Win32MinorVersion of 
     0: result := 'Windows 2000'; 
     1: result := 'Windows XP'; 
     end; 
    6: 
     case Win32MinorVersion of 
     0: result := 'Windows Vista'; 
     1: result := 'Windows 7'; 
     2: result := 'Windows 8'; 
     3: result := 'Windows 8.1'; 
     end; 
    10: 
     case Win32MinorVersion of 
     0: result := 'Windows 10'; 
     end; 
    end; 
end; 

En realidad no hay necesidad de llamar a GetVersionEx porque SysUtils.pas tiene InitPlatformID en su cláusula initialization. Por lo tanto, las constantes globales Win32MajorVersion y Win32MinorVersion (y sus amigos) ya se habrán rellenado.

Answer 2

Como alternativa a la API de Win32, puede utilizar la clase WMI Win32_OperatingSystem.

puede escribir una función simple como esta para recuperar el nombre de la versión de la ventana operativa.

function GetWin32_OSName:string; 
var 
    objWMIService : OLEVariant; 
    colItems  : OLEVariant; 
    colItem  : OLEVariant; 
    oEnum   : IEnumvariant; 
    iValue  : LongWord; 

    function GetWMIObject(const objectName: String): IDispatch; 
    var 
    chEaten: Integer; 
    BindCtx: IBindCtx; 
    Moniker: IMoniker; 
    begin 
    OleCheck(CreateBindCtx(0, bindCtx)); 
    OleCheck(MkParseDisplayName(BindCtx, StringToOleStr(objectName), chEaten, Moniker)); 
    OleCheck(Moniker.BindToObject(BindCtx, nil, IDispatch, Result)); 
    end; 

begin 
    objWMIService := GetWMIObject('winmgmts:\\localhost\root\cimv2'); 
    colItems  := objWMIService.ExecQuery('SELECT Caption FROM Win32_OperatingSystem','WQL',0); 
    oEnum   := IUnknown(colItems._NewEnum) as IEnumVariant; 
    if oEnum.Next(1, colItem, iValue) = 0 then 
    Result:=colItem.Caption; //The caption property return an string wich includes the operating system version. For example, "Microsoft Windows XP Professional Version = 5.1.2500". 
end; 

Addionally se puede recuperar más información acerca de la versión de Windows con los demás propiedades de la clase Win32_OperatingSystem.

Comprobar el código

program GetWMI_Win32_OperatingSystem; 

{$APPTYPE CONSOLE} 

uses 
    SysUtils 
    ,ActiveX 
    ,ComObj 
    ,Variants; 


Procedure GetWin32_OperatingSystem; 
var 
    objWMIService : OLEVariant; 
    colItems  : OLEVariant; 
    colItem  : OLEVariant; 
    oEnum   : IEnumvariant; 
    iValue  : LongWord; 

    function GetWMIObject(const objectName: String): IDispatch; 
    var 
    chEaten: Integer; 
    BindCtx: IBindCtx; 
    Moniker: IMoniker; 
    begin 
    OleCheck(CreateBindCtx(0, bindCtx)); 
    OleCheck(MkParseDisplayName(BindCtx, StringToOleStr(objectName), chEaten, Moniker)); 
    OleCheck(Moniker.BindToObject(BindCtx, nil, IDispatch, Result)); 
    end; 

begin 
    objWMIService := GetWMIObject('winmgmts:\\localhost\root\cimv2'); 
    colItems  := objWMIService.ExecQuery('SELECT * FROM Win32_OperatingSystem','WQL',0); 
    oEnum   := IUnknown(colItems._NewEnum) as IEnumVariant; 
    if oEnum.Next(1, colItem, iValue) = 0 then 
    begin 
    Writeln('Caption  '+colItem.Caption); 
    Writeln('Version  '+colItem.Version); 
    Writeln('BuildNumber '+colItem.BuildNumber); 
    Writeln('BuildType  '+colItem.BuildType); 
    Writeln('CodeSet  '+colItem.CodeSet); 
    Writeln('CountryCode '+colItem.CountryCode); 
    Writeln('BootDevice  '+colItem.BootDevice); 
    Writeln; 
    end; 
end; 


function GetWin32_OSName:string; 
var 
    objWMIService : OLEVariant; 
    colItems  : OLEVariant; 
    colItem  : OLEVariant; 
    oEnum   : IEnumvariant; 
    iValue  : LongWord; 

    function GetWMIObject(const objectName: String): IDispatch; 
    var 
    chEaten: Integer; 
    BindCtx: IBindCtx; 
    Moniker: IMoniker; 
    begin 
    OleCheck(CreateBindCtx(0, bindCtx)); 
    OleCheck(MkParseDisplayName(BindCtx, StringToOleStr(objectName), chEaten, Moniker)); 
    OleCheck(Moniker.BindToObject(BindCtx, nil, IDispatch, Result)); 
    end; 

begin 
    objWMIService := GetWMIObject('winmgmts:\\localhost\root\cimv2'); 
    colItems  := objWMIService.ExecQuery('SELECT Caption FROM Win32_OperatingSystem','WQL',0); 
    oEnum   := IUnknown(colItems._NewEnum) as IEnumVariant; 
    if oEnum.Next(1, colItem, iValue) = 0 then 
    Result:=colItem.Caption; 
end; 

begin 
try 
    CoInitialize(nil); 
    try 
     GetWin32_OperatingSystem; 
     //Writeln(GetWin32_OSName); 
     Readln; 
    finally 
    CoUninitialize; 
    end; 
except 
    on E:Exception do 
    Begin 
     Writeln(E.Classname, ': ', E.Message); 
     Readln; 
    End; 
    end; 
end. 

Answer 3

Yo uso esta en mis programas:

{$J+} 
TYPE 
    TOperatingSystemClass = (osUntested,osUnknown,osWin95,osWin98,osWinME,osWinNT,osWin2000,osWinXP,osWinXPSP1,osWinXPSP2,osWinXPSP3,osWin2003,osWinVista,osWinVistaSP1,osWinVistaSP2,osWinVistaSP3,osWin7,osWin7SP1,osWin7SP2,osWin7SP3,osHigher); 

FUNCTION OperatingSystemClass : TOperatingSystemClass; 
    CONST 
    OSClass  : TOperatingSystemClass = osUntested; 

    VAR 
    Info  : OSVERSIONINFOEX; 
    OldInfo : OSVERSIONINFO ABSOLUTE Info; 

    BEGIN 
    IF OSClass=osUntested THEN BEGIN 
     FillChar(Info,SizeOf(Info),0); 
     Info.dwOSVersionInfoSize:=SizeOf(Info); OSClass:=osUnknown; 
     IF NOT GetVersionEx(OldInfo) THEN BEGIN 
     FillChar(OldInfo,SizeOf(OldInfo),0); 
     OldInfo.dwOSVersionInfoSize:=SizeOf(OldInfo); 
     GetVersionEx(OldInfo) 
     END; 
     CASE Info.dwPlatformId OF 
     VER_PLATFORM_WIN32_WINDOWS  : CASE Info.dwMajorVersion OF 
               3 : OSClass:=osWin95; 
               4 : CASE Info.dwMinorVersion OF 
                0 : OSClass:=osWin95; 
                10 : OSClass:=osWin98 
                ELSE // OTHERWISE // 
                OSClass:=osWinME 
                END 
              END; 
     VER_PLATFORM_WIN32_NT   : CASE Info.dwMajorVersion OF 
               5 : CASE Info.dwMinorVersion OF 
                0 : OSClass:=osWin2000; 
                1 : OSClass:=osWinXP; 
                2 : OSClass:=osWin2003 
                END; 
               6 : IF Info.dwMinorVersion=0 THEN 
                OSClass:=osWinVista 
                ELSE IF Info.dwMinorVersion=1 THEN 
                OSClass:=osWin7 
                ELSE 
                OSClass:=osHigher 
              END 
     END; 
     IF (OSClass IN [osWinXP,osWinVista,osWin7]) AND (Info.wServicePackMajor>0) THEN 
     INC(OSClass,MAX(Info.wServicePackMajor,3)) 
    END; 
    Result:=OSClass 
    END; 

donde

type 
    OSVERSIONINFOEX = packed record 
    dwOSVersionInfoSize: DWORD; 
    dwMajorVersion: DWORD; 
    dwMinorVersion: DWORD; 
    dwBuildNumber: DWORD; 
    dwPlatformId: DWORD; 
    szCSDVersion: Array [0..127 ] of Char; 
    wServicePackMajor: WORD; 
    wServicePackMinor: WORD; 
    wSuiteMask: WORD; 
    wProductType: BYTE; 
    wReserved: BYTE; 
    End; 
    TOSVersionInfoEx = OSVERSIONINFOEX; 
    POSVersionInfoEx = ^TOSVersionInfoEx; 

Answer 4

Si desea obtener más información sobre el Sistema de funcionamiento, puede utilizar WMI (el código de RRUZ lo usa para el nombre). Para obtener más información, puede usar el componente COperatingSystemInfo de GLibWMI (de Sourceforge o Author WebPage (mío) ;-D).
Toda la biblioteca es gratuita y está disponible código sourve. Para OperatingSystem puede obtener estas propiedades:

alt text http://a.imageshack.us/img594/1660/coperatinsysteminfo.png

Saludos

Answer 5

El JCL contiene este tipo enumerado:

TWindowsVersion = 
    (wvUnknown, wvWin95, wvWin95OSR2, wvWin98, wvWin98SE, wvWinME, 
    wvWinNT31, wvWinNT35, wvWinNT351, wvWinNT4, wvWin2000, wvWinXP, 
    wvWin2003, wvWinXP64, wvWin2003R2, wvWinVista, wvWinServer2008, 
    wvWin7, wvWinServer2008R2); 

Contiene esta función, y otros:

function GetWindowsVersion: TWindowsVersion; 

Documentation here

Lo que es aún mejor, cuando salga una nueva versión de Windows, alguien actualizará el JCL y no tendrá que extender este código usted mismo. Además, de todas las respuestas a esta pregunta, solo el JCL maneja la detección del sistema operativo Windows Server, además de las versiones habituales de usuario final de Windows.

Answer 6

function OS_IsWindowsXP: Boolean; 
begin 
Result:= (Win32MajorVersion= 5) AND (Win32MinorVersion= 1); 
end; 

function OS_IsWindowsXPUp: Boolean; 
begin 
Result:= ((Win32MajorVersion = 5) AND (Win32MinorVersion>= 1)) 
     OR (Win32MajorVersion>= 6); 
end; 



function OS_IsWindowsVista: Boolean; 
begin 
Result:= (Win32MajorVersion= 6) AND (Win32MinorVersion= 0); 
end; 

function OS_IsWindowsVistaUp: Boolean; 
begin 
Result:= (Win32MajorVersion>= 6); 
end; 



function OS_IsWindows7: Boolean; 
begin 
Result:= (Win32MajorVersion= 6) AND (Win32MinorVersion= 1); 
end; 

function OS_IsWindows7Up: Boolean; 
begin 
Result:= ((Win32MajorVersion = 6) AND (Win32MinorVersion>= 1)) { Any version 6 equal and above Win7 } 
     OR (Win32MajorVersion>= 7);        { Any version above 6 } 
end; 



function OS_IsWindows8: Boolean; 
begin 
Result:= (Win32MajorVersion = 6) AND (Win32MinorVersion= 2); 
end; 

function OS_IsWindows8Up: Boolean; 
begin 
Result:= ((Win32MajorVersion = 6) AND (Win32MinorVersion>= 2)) 
     OR (Win32MajorVersion>= 7); 
end; 

Answer 7

Desde Delphi XE2 puede utilizar TOSVersion registro. Tenga en cuenta que es un registro global y you cannot create TOSVersion variables.

Por ejemplo:

lblVersion.Caption := TOSVersion.ToString; 

Usted tiene algunas propiedades de grabación disponibles para usar: Minor, Major, Build, Architecture entregada junto con Platform que se puede utilizar para asegurarse de que el sistema operativo es Windows.

Para comparar la versión actual del sistema con la definida, utilice la versión Check.