mp4box/OSInfo.cs

   1 // ------------------------------------------------------------------
   2 // Copyright (C) 2011-2016 Maruko Toolbox Project
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //      http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
  13 // express or implied.
  14 // See the License for the specific language governing permissions
  15 // and limitations under the License.
  16 // -------------------------------------------------------------------
  17 //
  18
  19 using System;
  20 using System.Collections;
  21 using System.Diagnostics;
  22 using System.Management;
  23 using System.Runtime.InteropServices;
  24 using System.Windows.Forms;
  25
  26 namespace mp4box
  27 {
  28     public class OSInfo
  29     {
  30         [StructLayout(LayoutKind.Sequential)]
  31         private struct OSVERSIONINFOEX
  32         {
  33             public int dwOSVersionInfoSize;
  34             public int dwMajorVersion;
  35             public int dwMinorVersion;
  36             public int dwBuildNumber;
  37             public int dwPlatformId;
  38             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
  39             public string szCSDVersion;
  40             public short wServicePackMajor;
  41             public short wServicePackMinor;
  42             public short wSuiteMask;
  43             public byte wProductType;
  44             public byte wReserved;
  45         }
  46
  47         [DllImport("kernel32.dll")]
  48         private static extern bool GetVersionEx(ref OSVERSIONINFOEX osVersionInfo);
  49
  50         [DllImport("kernel32.dll")]
  51         private static extern bool GetProductInfo(int dwOSMajorVersion, int dwOSMinorVersion, int dwSpMajorVersion, int dwSpMinorVersion, out uint pdwReturnedProductType);
  52
  53         [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]
  54         [return: MarshalAs(UnmanagedType.Bool)]
  55         public static extern bool IsWow64Process([In] IntPtr hProcess, [Out] out bool lpSystemInfo);
  56
  57         #region Private Constants
  58         private const int VER_NT_WORKSTATION = 1;
  59         private const int VER_NT_DOMAIN_CONTROLLER = 2;
  60         private const int VER_NT_SERVER = 3;
  61         private const int VER_SUITE_SMALLBUSINESS = 1;
  62         private const int VER_SUITE_ENTERPRISE = 2;
  63         private const int VER_SUITE_TERMINAL = 16;
  64         private const int VER_SUITE_DATACENTER = 128;
  65         private const int VER_SUITE_SINGLEUSERTS = 256;
  66         private const int VER_SUITE_PERSONAL = 512;
  67         private const int VER_SUITE_BLADE = 1024;
  68         private const int PRODUCT_UNDEFINED = 0x00000000;
  69         private const int PRODUCT_ULTIMATE = 0x00000001;
  70         private const int PRODUCT_HOME_BASIC = 0x00000002;
  71         private const int PRODUCT_HOME_PREMIUM = 0x00000003;
  72         private const int PRODUCT_ENTERPRISE = 0x00000004;
  73         private const int PRODUCT_ENTERPRISE_N = 0x0000001B;
  74         private const int PRODUCT_HOME_BASIC_N = 0x00000005;
  75         private const int PRODUCT_BUSINESS = 0x00000006;
  76         private const int PRODUCT_BUSINESS_N = 0x00000010;
  77         private const int PRODUCT_STARTER = 0x0000000B;
  78         private const int PRODUCT_PROFESSIONAL = 0x00000030;
  79         private const int PRODUCT_PROFESSIONAL_N = 0x00000031;
  80         private const int PRODUCT_PROFESSIONAL_WMC = 0x00000067;
  81         private const int PRODUCT_CORE = 0x00000065;
  82         private const int PRODUCT_CORE_N = 0x00000062;
  83         private const int PRODUCT_CORE_COUNTRYSPECIFIC = 0x00000063;
  84         private const int PRODUCT_MOBILE_CORE = 0x00000068;
  85         private const int PRODUCT_MOBILE_ENTERPRISE = 0x00000085;
  86         private const int PRODUCT_EDUCATION = 0x00000079;
  87         private const int PRODUCT_EDUCATION_N = 0x0000007A;
  88         #endregion
  89
  90         #region Public Methods
  91         /// <summary>
  92         /// Determines whether the specified process is running under WOW64.
  93         /// </summary>
  94         /// <returns>a boolean</returns>
  95         public static bool isWow64()
  96         {
  97             if (Environment.OSVersion.Version.Major == 5 && Environment.OSVersion.Version.Minor == 0)
  98                 return false;   // windows 2000
  99
 100             Process p = Process.GetCurrentProcess();
 101             IntPtr handle = p.Handle;
 102             bool isWow64;
 103             bool success = IsWow64Process(handle, out isWow64);
 104             if ((!success) && (IntPtr.Size != 8))
 105                 throw new Exception();
 106             else
 107                 return isWow64;
 108         }
 109
 110         /// <summary>
 111         /// Returns the service pack information of the operating system running on this computer.
 112         /// </summary>
 113         /// <returns>A string containing the operating system service pack information.</returns>
 114         public static string GetOSServicePack()
 115         {
 116             OSVERSIONINFOEX osVersionInfo = new OSVERSIONINFOEX();
 117
 118             osVersionInfo.dwOSVersionInfoSize = Marshal.SizeOf(typeof(OSVERSIONINFOEX));
 119
 120             if (!GetVersionEx(ref osVersionInfo))
 121             {
 122                 return "";
 123             }
 124             else
 125             {
 126                 if (osVersionInfo.szCSDVersion != "")
 127                 {
 128                     return " SP" + osVersionInfo.szCSDVersion.Substring(13, 1);
 129                 }
 130                 else
 131                 {
 132                     return "";
 133                 }
 134             }
 135         }
 136
 137         /// <summary>
 138         /// Returns the name of the operating system running on this computer.
 139         /// </summary>
 140         /// <returns>A string containing the the operating system name.</returns>
 141         public static string GetOSName()
 142         {
 143             OperatingSystem osInfo = Environment.OSVersion;
 144             OSVERSIONINFOEX osVersionInfo = new OSVERSIONINFOEX();
 145             osVersionInfo.dwOSVersionInfoSize = Marshal.SizeOf(typeof(OSVERSIONINFOEX));
 146             string osName = "UNKNOWN";
 147             bool x64Detection = true;
 148
 149             if (!GetVersionEx(ref osVersionInfo))
 150                 return "";
 151
 152             switch (osInfo.Platform)
 153             {
 154                 case PlatformID.Win32Windows:
 155                     {
 156                         x64Detection = false;
 157                         switch (osInfo.Version.Minor)
 158                         {
 159                             case 0: osName = "Windows 95"; break;
 160                             case 10:
 161                                 {
 162                                     if (osInfo.Version.Revision.ToString() == "2222A")
 163                                         osName = "Windows 98 第二版";
 164                                     else
 165                                         osName = "Windows 98";
 166                                 }
 167                                 break;
 168                             case 90: osName = "Windows Me"; break;
 169                         }
 170                         break;
 171                     }
 172                 case PlatformID.Win32NT:
 173                     {
 174                         switch (osInfo.Version.Major)
 175                         {
 176                             case 3:
 177                                 x64Detection = false;
 178                                 osName = "Windows NT 3.51";
 179                                 break;
 180                             case 4:
 181                                 {
 182                                     x64Detection = false;
 183                                     switch (osVersionInfo.wProductType)
 184                                     {
 185                                         case 1: osName = "Windows NT 4.0 工作站"; break;
 186                                         case 3: osName = "Windows NT 4.0 服务器"; break;
 187                                     }
 188                                     break;
 189                                 }
 190                             case 5:
 191                                 {
 192                                     switch (osInfo.Version.Minor)
 193                                     {
 194                                         case 0: // win2K
 195                                             {
 196                                                 x64Detection = false;
 197                                                 if ((osVersionInfo.wSuiteMask & VER_SUITE_DATACENTER) == VER_SUITE_DATACENTER)
 198                                                     osName = "Windows 2000 数据中心服务器";
 199                                                 else if ((osVersionInfo.wSuiteMask & VER_SUITE_ENTERPRISE) == VER_SUITE_ENTERPRISE)
 200                                                     osName = "Windows 2000 高级服务器";
 201                                                 else
 202                                                     osName = "Windows 2000";
 203                                                 break;
 204                                             }
 205                                         case 1: // winXP
 206                                             {
 207                                                 if ((osVersionInfo.wSuiteMask & VER_SUITE_PERSONAL) == VER_SUITE_PERSONAL)
 208                                                     osName = "Windows XP 家庭版";
 209                                                 else
 210                                                     osName = "Windows XP 专业版";
 211                                                 break;
 212                                             }
 213                                         case 2: // winserver 2003
 214                                             {
 215                                                 if ((osVersionInfo.wSuiteMask & VER_SUITE_DATACENTER) == VER_SUITE_DATACENTER)
 216                                                     osName = "Windows Server 2003 数据中心版";
 217                                                 else if ((osVersionInfo.wSuiteMask & VER_SUITE_ENTERPRISE) == VER_SUITE_ENTERPRISE)
 218                                                     osName = "Windows Server 2003 企业版";
 219                                                 else if ((osVersionInfo.wSuiteMask & VER_SUITE_BLADE) == VER_SUITE_BLADE)
 220                                                     osName = "Windows Server 2003 网络版";
 221                                                 else
 222                                                     osName = "Windows Server 2003 标准版";
 223                                                 break;
 224                                             }
 225                                     }
 226                                     break;
 227                                 }
 228                             case 6:
 229                                 {
 230                                     switch (osInfo.Version.Minor)
 231                                     {
 232                                         case 0:
 233                                             {
 234                                                 switch (osVersionInfo.wProductType)
 235                                                 {
 236                                                     case 1: // Vista
 237                                                         {
 238                                                             uint edition = PRODUCT_UNDEFINED;
 239                                                             if (GetProductInfo(osVersionInfo.dwMajorVersion,
 240                                                                                 osVersionInfo.dwMinorVersion,
 241                                                                                 osVersionInfo.wServicePackMajor,
 242                                                                                 osVersionInfo.wServicePackMinor,
 243                                                                                 out edition))
 244                                                             {
 245                                                                 switch (edition)
 246                                                                 {
 247                                                                     case PRODUCT_ULTIMATE: osName = "Windows Vista 旗舰版"; break;
 248                                                                     case PRODUCT_HOME_BASIC:
 249                                                                     case PRODUCT_HOME_BASIC_N: osName = "Windows Vista 家庭普通版"; break;
 250                                                                     case PRODUCT_HOME_PREMIUM: osName = "Windows Vista 家庭高级版"; break;
 251                                                                     case PRODUCT_ENTERPRISE: osName = "Windows Vista 企业版"; break;
 252                                                                     case PRODUCT_BUSINESS:
 253                                                                     case PRODUCT_BUSINESS_N: osName = "Windows Vista 商用版"; break;
 254                                                                     case PRODUCT_STARTER: osName = "Windows Vista 简易版"; break;
 255                                                                     default: osName = "Windows Vista"; break;
 256                                                                 }
 257                                                             }
 258                                                             break;
 259                                                         }
 260                                                     case 3: // Server 2008
 261                                                         {
 262                                                             if ((osVersionInfo.wSuiteMask & VER_SUITE_DATACENTER) == VER_SUITE_DATACENTER)
 263                                                                 osName = "Windows Server 2008 数据中心服务器";
 264                                                             else if ((osVersionInfo.wSuiteMask & VER_SUITE_ENTERPRISE) == VER_SUITE_ENTERPRISE)
 265                                                                 osName = "Windows Server 2008 高级服务器";
 266                                                             else
 267                                                                 osName = "Windows Server 2008";
 268                                                             break;
 269                                                         }
 270                                                 }
 271                                                 break;
 272                                             }
 273                                         case 1: // Se7en
 274                                             {
 275                                                 uint edition = PRODUCT_UNDEFINED;
 276                                                 if (GetProductInfo(osVersionInfo.dwMajorVersion,
 277                                                                     osVersionInfo.dwMinorVersion,
 278                                                                     osVersionInfo.wServicePackMajor,
 279                                                                     osVersionInfo.wServicePackMinor,
 280                                                                     out edition))
 281                                                 {
 282                                                     switch (edition)
 283                                                     {
 284                                                         case PRODUCT_ULTIMATE: osName = "Windows 7 旗舰版"; break;
 285                                                         case PRODUCT_HOME_BASIC:
 286                                                         case PRODUCT_HOME_BASIC_N: osName = "Windows 7 家庭普通版"; break;
 287                                                         case PRODUCT_HOME_PREMIUM: osName = "Windows 7 家庭高级版"; break;
 288                                                         case PRODUCT_ENTERPRISE: osName = "Windows 7 企业版"; break;
 289                                                         case PRODUCT_BUSINESS:
 290                                                         case PRODUCT_BUSINESS_N: osName = "Windows 7 专业版"; break;
 291                                                         case PRODUCT_STARTER: osName = "Windows 7 入门版"; break;
 292                                                         default: osName = "Windows 7"; break;
 293                                                     }
 294                                                 }
 295                                                 break;
 296                                             }
 297                                         case 2: // Windows 8
 298                                             {
 299                                                 uint edition = PRODUCT_UNDEFINED;
 300                                                 if (GetProductInfo(osVersionInfo.dwMajorVersion,
 301                                                                     osVersionInfo.dwMinorVersion,
 302                                                                     osVersionInfo.wServicePackMajor,
 303                                                                     osVersionInfo.wServicePackMinor,
 304                                                                     out edition))
 305                                                 {
 306                                                     switch (edition)
 307                                                     {
 308                                                         case PRODUCT_CORE:
 309                                                         case PRODUCT_CORE_COUNTRYSPECIFIC:
 310                                                         case PRODUCT_CORE_N: osName = "Windows 8 核心版"; break;
 311                                                         case PRODUCT_ENTERPRISE:
 312                                                         case PRODUCT_ENTERPRISE_N: osName = "Windows 8 企业版"; break;
 313                                                         case PRODUCT_PROFESSIONAL:
 314                                                         case PRODUCT_PROFESSIONAL_N: osName = "Windows 8 专业版"; break;
 315                                                         case PRODUCT_PROFESSIONAL_WMC: osName = "Windows 8 专业版(含Media Center)"; break;
 316                                                         default: osName = "Windows 8"; break;
 317                                                     }
 318                                                 }
 319                                                 break;
 320                                             }
 321                                         case 3: // Windows 8.1
 322                                             {
 323                                                 uint edition = PRODUCT_UNDEFINED;
 324                                                 if (GetProductInfo(osVersionInfo.dwMajorVersion,
 325                                                                     osVersionInfo.dwMinorVersion,
 326                                                                     osVersionInfo.wServicePackMajor,
 327                                                                     osVersionInfo.wServicePackMinor,
 328                                                                     out edition))
 329                                                 {
 330                                                     switch (edition)
 331                                                     {
 332                                                         case PRODUCT_CORE:
 333                                                         case PRODUCT_CORE_COUNTRYSPECIFIC:
 334                                                         case PRODUCT_CORE_N: osName = "Windows 8.1 核心版"; break;
 335                                                         case PRODUCT_ENTERPRISE:
 336                                                         case PRODUCT_ENTERPRISE_N: osName = "Windows 8.1 企业版"; break;
 337                                                         case PRODUCT_PROFESSIONAL:
 338                                                         case PRODUCT_PROFESSIONAL_N: osName = "Windows 8.1 专业版"; break;
 339                                                         case PRODUCT_PROFESSIONAL_WMC: osName = "Windows 8.1 专业版(含Media Center)"; break;
 340                                                         default: osName = "Windows 8.1"; break;
 341                                                     }
 342                                                 }
 343                                                 break;
 344                                             }
 345                                     }
 346                                     break;
 347                                 }
 348                             case 10:
 349                                 {
 350                                     switch (osInfo.Version.Minor)
 351                                     {
 352                                         case 0:
 353                                             {
 354                                                 switch (osVersionInfo.wProductType)
 355                                                 {
 356                                                     case 1: // X
 357                                                         {
 358                                                             uint edition = PRODUCT_UNDEFINED;
 359                                                             if (GetProductInfo(osVersionInfo.dwMajorVersion,
 360                                                                                 osVersionInfo.dwMinorVersion,
 361                                                                                 osVersionInfo.wServicePackMajor,
 362                                                                                 osVersionInfo.wServicePackMinor,
 363                                                                                 out edition))
 364                                                             {
 365                                                                 switch (edition)
 366                                                                 {
 367                                                                     case PRODUCT_CORE:
 368                                                                     case PRODUCT_CORE_COUNTRYSPECIFIC:
 369                                                                     case PRODUCT_CORE_N: osName = "Windows 10 家庭版"; break;
 370                                                                     case PRODUCT_ENTERPRISE:
 371                                                                     case PRODUCT_ENTERPRISE_N: osName = "Windows 10 企业版"; break;
 372                                                                     case PRODUCT_PROFESSIONAL:
 373                                                                     case PRODUCT_PROFESSIONAL_N: osName = "Windows 10 专业版"; break;
 374                                                                     case PRODUCT_EDUCATION:
 375                                                                     case PRODUCT_EDUCATION_N: osName = "Windows 10 教育版"; break;
 376                                                                     case PRODUCT_MOBILE_CORE:
 377                                                                     case PRODUCT_MOBILE_ENTERPRISE: osName = "Windows 10 移动版"; break;
 378                                                                     default: osName = "Windows 10"; break;
 379                                                                 }
 380                                                             }
 381                                                             break;
 382                                                         }
 383                                                 }
 384                                                 break;
 385                                             }
 386                                     }
 387                                 }
 388                                 break;
 389                         }
 390                     }
 391                     break;
 392             }
 393             if (IntPtr.Size == 8)
 394                 osName += " x64";
 395             if (IntPtr.Size == 4)
 396             {
 397                 if (x64Detection)
 398                 {
 399                     if (!isWow64())
 400                         osName += " x86";
 401                     else
 402                         osName += " x64";
 403                 }
 404             }
 405             return osName;
 406         }
 407
 408         /// <summary>
 409         /// Returns the name of the highest .NET Framework running on this computer.
 410         /// </summary>
 411         /// <returns>A string containing the Name of the Framework Version.</returns>
 412         ///
 413         public static string GetDotNetVersion()
 414         {
 415             return GetDotNetVersion("");
 416         }
 417
 418         /// <summary>
 419         /// Returns the version of the .NET framework running on this computer.
 420         /// </summary>
 421         /// <param name="getSpecificVersion">if not empty only the specified version and if empty the highest version will be returned</param>
 422         /// <returns>A string containing the version of the framework version.</returns>
 423         public static string GetDotNetVersion(string getSpecificVersion)
 424         {
 425             string fv = "unknown";
 426             string componentsKeyName = "SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\";
 427             using (Microsoft.Win32.RegistryKey componentsKey = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(componentsKeyName))
 428             {
 429                 try
 430                 {
 431                     string[] instComps = componentsKey.GetSubKeyNames();
 432                     ArrayList versions = new ArrayList();
 433
 434                     foreach (string instComp in instComps)
 435                     {
 436                         if (!instComp.StartsWith("v"))
 437                             continue;
 438
 439                         bool bFound = false;
 440                         Microsoft.Win32.RegistryKey key = componentsKey.OpenSubKey(instComp);
 441                         string version = (string)key.GetValue("Version", "");
 442
 443                         if (!String.IsNullOrEmpty(version))
 444                         {
 445                             versions.Add(version);
 446                             continue;
 447                         }
 448                         else
 449                         {
 450                             foreach (string strRegKey in key.GetSubKeyNames())
 451                             {
 452                                 Microsoft.Win32.RegistryKey strKey = key.OpenSubKey(strRegKey);
 453                                 version = (string)strKey.GetValue("Version", "");
 454                                 if (!String.IsNullOrEmpty(version))
 455                                 {
 456                                     bFound = true;
 457                                     versions.Add(version);
 458                                 }
 459                             }
 460                         }
 461                         if (!bFound)
 462                         {
 463                             string install = key.GetValue("Install", "").ToString();
 464                             version = instComp.Substring(1);
 465                             if (!version.Equals("4") && install.Equals("1"))
 466                                 versions.Add(version);
 467                         }
 468                     }
 469                     versions.Sort();
 470
 471                     foreach (string version in versions)
 472                     {
 473                         if (!String.IsNullOrEmpty(getSpecificVersion) && (version.StartsWith(getSpecificVersion) || DotNetVersionFormated(version).StartsWith(getSpecificVersion)))
 474                             return DotNetVersionFormated(version);
 475                         fv = version;
 476                     }
 477
 478                     if (!String.IsNullOrEmpty(getSpecificVersion))
 479                         return null;
 480                 }
 481                 catch
 482                 {
 483                     return null;
 484                 }
 485             }
 486             return DotNetVersionFormated(fv);
 487         }
 488
 489         /// <summary>
 490         /// Returns the name of the dotNet Framework formated
 491         /// </summary>
 492         /// <returns>A string containing the dotNet Framework</returns>
 493         ///
 494         public static string DotNetVersionFormated(string dotNetVersion)
 495         {
 496             string dnvf = "unknown";
 497             string major = string.Empty;
 498             string minor = string.Empty;
 499             string build = string.Empty;
 500             string revision = string.Empty;
 501
 502             try
 503             {
 504                 if (dotNetVersion != "unknown")
 505                 {
 506                     string[] versions = dotNetVersion.Split('.');
 507
 508                     if (versions.Length >= 1)
 509                         major = versions[0].ToString();
 510                     if (versions.Length > 1)
 511                         minor = versions[1].ToString();
 512                     if (versions.Length > 2)
 513                         build = versions[2].ToString();
 514                     if (versions.Length > 3)
 515                         revision = versions[3].ToString();
 516
 517                     switch (major)
 518                     {
 519                         case "1":
 520                             {
 521                                 switch (minor)
 522                                 {
 523                                     case "0":
 524                                         {
 525                                             switch (revision)
 526                                             {
 527                                                 case "209": dnvf = "1.0 SP1"; break;
 528                                                 case "288": dnvf = "1.0 SP2"; break;
 529                                                 case "6018": dnvf = "1.0 SP3"; break;
 530                                                 default: dnvf = "1.0"; break;
 531                                             }
 532                                         }
 533                                         break;
 534                                     case "1":
 535                                         {
 536                                             switch (revision)
 537                                             {
 538                                                 case "2032":
 539                                                 case "2300": dnvf = "1.1 SP1"; break;
 540                                                 default: dnvf = "1.1"; break;
 541                                             }
 542                                         }
 543                                         break;
 544                                     default: dnvf = "1.x"; break;
 545                                 }
 546                                 break;
 547                             }
 548                         case "2":
 549                             {
 550                                 switch (revision)
 551                                 {
 552                                     case "1433":
 553                                     case "1434": dnvf = "2.0 SP1"; break;
 554                                     case "2407":
 555                                     case "3053":
 556                                     case "3074":
 557                                     case "4016":
 558                                     case "4927": dnvf = "2.0 SP2"; break;
 559                                     default: dnvf = "2.0"; break;
 560                                 }
 561                             }
 562                             break;
 563                         case "3":
 564                             {
 565                                 switch (minor)
 566                                 {
 567                                     case "0":
 568                                         {
 569                                             switch (revision)
 570                                             {
 571                                                 case "648": dnvf = "3.0 SP1"; break;
 572                                                 case "1453":
 573                                                 case "2123":
 574                                                 case "4000":
 575                                                 case "4037":
 576                                                 case "4902": // Se7en
 577                                                 case "4926": // Se7en
 578                                                     dnvf = "3.0 SP2"; break;
 579                                                 default: dnvf = "3.0"; break;
 580                                             }
 581                                         }
 582                                         break;
 583                                     case "5":
 584                                         {
 585                                             switch (revision)
 586                                             {
 587                                                 case "4926": // Se7en
 588                                                 case "1": dnvf = "3.5 SP1"; break;
 589                                                 default: dnvf = "3.5"; break;
 590                                             }
 591                                         }
 592                                         break;
 593                                     default: dnvf = "3.x"; break;
 594                                 }
 595                             }
 596                             break;
 597                         case "4":
 598                             {
 599                                 switch (minor)
 600                                 {
 601                                     case "0": dnvf = "4.0"; break;
 602                                     case "5":
 603                                         {
 604                                             switch (build)
 605                                             {
 606                                                 case "50709": dnvf = "4.5"; break;
 607                                                 case "51641": dnvf = "4.5.1"; break;
 608                                                 case "51650": dnvf = "4.5.2"; break;
 609                                                 default: dnvf = "4.5.x"; break;
 610                                             }
 611                                         }
 612                                         break;
 613                                     case "6":
 614                                         {
 615                                             switch (build)
 616                                             {
 617                                                 case "00079": dnvf = "4.6"; break;
 618                                                 default: dnvf = "4.6.x"; break;
 619                                             }
 620                                         }
 621                                         break;
 622                                     default: dnvf = "4." + minor; break;
 623                                 }
 624                             }
 625                             break;
 626                         default: dnvf = major + ".x"; break;
 627                     }
 628
 629                     if (string.IsNullOrEmpty(revision))
 630                         dnvf += " (" + major + "." + minor + "." + build + ")";
 631                     else
 632                         dnvf += " (" + major + "." + minor + "." + build + "." + revision + ")";
 633                 }
 634             }
 635             catch
 636             {
 637                 dnvf = "unknown: " + dotNetVersion;
 638             }
 639             return dnvf;
 640         }
 641
 642         /// <summary>
 643         /// Get some stuff from the Management Object Queries
 644         /// </summary>
 645         /// <returns>A string containing the result of the MO query.</returns>
 646         ///
 647         public static string GetMOStuff(string queryObject)
 648         {
 649             ManagementObjectSearcher searcher = null;
 650             string res = "";
 651             try
 652             {
 653                 searcher = new ManagementObjectSearcher("SELECT * FROM " + queryObject);
 654                 foreach (ManagementObject mo in searcher.Get())
 655                 {
 656                     if (queryObject == "Win32_OperatingSystem")
 657                     {
 658                         res = mo["Caption"].ToString();
 659                     }
 660                     else if (queryObject == "Win32_Processor")
 661                     {
 662                         res = mo["Name"].ToString();
 663                     }
 664                     else if (queryObject == "Win32_LogicalDisk")
 665                     {
 666                         if (mo["DriveType"].ToString() == "3") // HDD
 667                         {
 668                             long freespace = long.Parse(mo["FreeSpace"].ToString()) / 1073741824;
 669                             long totalsize = long.Parse(mo["Size"].ToString()) / 1073741824;
 670
 671                             if (mo["VolumeName"].ToString() == "")
 672                                 mo["VolumeName"] = "Local Disk";
 673
 674                             res += mo["VolumeName"].ToString() + " (" + mo["Name"].ToString() + ")  -  " + Convert.ToString(freespace) + " Go free of " + Convert.ToString(totalsize) + " Go\n";
 675                         }
 676                     }
 677                 }
 678             }
 679             catch (Exception ex)
 680             {
 681                 MessageBox.Show(ex.ToString());
 682             }
 683             return res;
 684         }
 685         #endregion
 686
 687         #region Public Properties
 688         /// <summary>
 689         /// Gets the full version of the operating system running on this computer.
 690         /// </summary>
 691         public static string OSVersion
 692         {
 693             get
 694             {
 695                 return Environment.OSVersion.Version.ToString();
 696             }
 697         }
 698
 699         /// <summary>
 700         /// Gets the major version of the operating system running on this computer.
 701         /// </summary>
 702         public static int OSMajorVersion
 703         {
 704             get
 705             {
 706                 return Environment.OSVersion.Version.Major;
 707             }
 708         }
 709
 710         /// <summary>
 711         /// Gets the minor version of the operating system running on this computer.
 712         /// </summary>
 713         public static int OSMinorVersion
 714         {
 715             get
 716             {
 717                 return Environment.OSVersion.Version.Minor;
 718             }
 719         }
 720
 721         /// <summary>
 722         /// Gets the build version of the operating system running on this computer.
 723         /// </summary>
 724         public static int OSBuildVersion
 725         {
 726             get
 727             {
 728                 return Environment.OSVersion.Version.Build;
 729             }
 730         }
 731
 732         /// <summary>
 733         /// Gets the revision version of the operating system running on this computer.
 734         /// </summary>
 735         public static int OSRevisionVersion
 736         {
 737             get
 738             {
 739                 return Environment.OSVersion.Version.Revision;
 740             }
 741         }
 742         #endregion
 743     }
 744 }