c# - veo - donde se guardan las apps instaladas de windows 10

¿Cómo puedo detectar si mi aplicación se está ejecutando en Windows 10?

Question

Estoy buscando un medio para detectar si mi aplicación C # se está ejecutando en Windows 10.

Esperaba que Environment.OSVersion hiciera el truco, pero esto parece devolver una Version de 6.3.9600.0 en Windows 8.1 y Windows 10.

Otras soluciones como this tampoco parecen distinguir entre Windows 8 y Windows 10.

¿Alguna sugerencia?

¿Por qué tengo que hacer esto?

Porque estoy usando un control WinForms WebBrowser para alojar una página OAuth que se cuelga y se quema en versiones anteriores de IE (mi aplicación se conecta a la cuenta Nest de un usuario ...).

De forma predeterminada, el control WebBrowser emula IE7. Usando una clave de Registro, puede indicarle que emule la última versión de IE que está instalada en la PC host. Sin embargo, el valor que funcionó con Windows 8.1 (y versiones previas de Windows 10) no funciona en la versión final de Windows 10.

Answer 1

¿Has probado a continuación? [Debe agregar una referencia a Microsoft.VisulaBasic dll]

new Microsoft.VisualBasic.Devices.ComputerInfo().OSFullName

En mi máquina da, Microsoft Windows 7 Ultimate

Answer 2

¿No puedes usar las funciones de Version Helper? https://msdn.microsoft.com/en-us/library/windows/desktop/dn424972(v=vs.85).aspx

IsWindows10OrGreater

Indica si la versión actual del sistema operativo coincide, o es mayor que, la versión de Windows 10. Para Windows 10, IsWindows10OrGreater devuelve falso a menos que la aplicación contenga un manifiesto que incluya una sección de compatibilidad que contenga el GUID que designa Windows 10.

y agregue los GUID: msdn.microsoft.com/en-ca/library/windows/desktop/…

Answer 3

Bajo el capó, Environment.OSVersion usa la función GetVersionEx , que ha quedado en desuso. La documentación advierte sobre el comportamiento que observó:

Las aplicaciones no manifestadas para Windows 8.1 o Windows 10 devolverán el valor de versión del sistema operativo Windows 8 (6.2).

La documentación continúa recomendando:

Identificar el sistema operativo actual generalmente no es la mejor manera de determinar si una característica particular del sistema operativo está presente. Esto se debe a que el sistema operativo puede tener nuevas características agregadas en una DLL redistribuible. En lugar de utilizar GetVersionEx para determinar la plataforma del sistema operativo o el número de versión, pruebe la presencia de la característica en sí.

Si la recomendación anterior no es adecuada para su caso, y realmente desea verificar la versión actual del sistema operativo en ejecución, la documentación también proporciona una pista sobre esto:

Para comparar la versión actual del sistema con la versión requerida, use la función VerifyVersionInfo en lugar de usar GetVersionEx para realizar la comparación usted mismo.

El siguiente artículo ha publicado una solución de trabajo que utiliza la función VerifyVersionInfo : API de Version Helper para .NET .

Dando crédito completo al autor de ese artículo, el siguiente fragmento de código debe proporcionar el comportamiento que está buscando:

public class Program
{
static void Main(string[] args)
{
Console.WriteLine(IsWindowsVersionOrGreater(6, 3, 0)); // Plug in appropriate values.
}
[StructLayout(LayoutKind.Sequential)]
struct OsVersionInfoEx
{
public uint OSVersionInfoSize;
public uint MajorVersion;
public uint MinorVersion;
public uint BuildNumber;
public uint PlatformId;
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
public string CSDVersion;
public ushort ServicePackMajor;
public ushort ServicePackMinor;
public ushort SuiteMask;
public byte ProductType;
public byte Reserved;
}
[DllImport("kernel32.dll")]
static extern ulong VerSetConditionMask(ulong dwlConditionMask,
uint dwTypeBitMask, byte dwConditionMask);
[DllImport("kernel32.dll")]
static extern bool VerifyVersionInfo(
[In] ref OsVersionInfoEx lpVersionInfo,
uint dwTypeMask, ulong dwlConditionMask);
static bool IsWindowsVersionOrGreater(
uint majorVersion, uint minorVersion, ushort servicePackMajor)
{
OsVersionInfoEx osvi = new OsVersionInfoEx();
osvi.OSVersionInfoSize = (uint)Marshal.SizeOf(osvi);
osvi.MajorVersion = majorVersion;
osvi.MinorVersion = minorVersion;
osvi.ServicePackMajor = servicePackMajor;
// These constants initialized with corresponding definitions in
// winnt.h (part of Windows SDK)
const uint VER_MINORVERSION = 0x0000001;
const uint VER_MAJORVERSION = 0x0000002;
const uint VER_SERVICEPACKMAJOR = 0x0000020;
const byte VER_GREATER_EQUAL = 3;
ulong versionOrGreaterMask = VerSetConditionMask(
VerSetConditionMask(
VerSetConditionMask(
0, VER_MAJORVERSION, VER_GREATER_EQUAL),
VER_MINORVERSION, VER_GREATER_EQUAL),
VER_SERVICEPACKMAJOR, VER_GREATER_EQUAL);
uint versionOrGreaterTypeMask = VER_MAJORVERSION |
VER_MINORVERSION | VER_SERVICEPACKMAJOR;
return VerifyVersionInfo(ref osvi, versionOrGreaterTypeMask,
versionOrGreaterMask);
}
}

Descargo de responsabilidad: aún no tengo Windows 10, por lo que no he probado el código en Windows 10.

Answer 4

Prueba este:

string subKey = @"SOFTWARE/Wow6432Node/Microsoft/Windows NT/CurrentVersion";
Microsoft.Win32.RegistryKey key = Microsoft.Win32.Registry.LocalMachine;
Microsoft.Win32.RegistryKey skey = key.OpenSubKey(subKey);
string name = skey.GetValue("ProductName").ToString();

y luego puedes usar una cláusula if:

if(name.Contains("Windows 10"))
{
//... procedures
}
else
{
//... procedures
}

Answer 5

Si observa el registro, encontrará el nombre del entorno:

HKEY_LOCAL_MACHINE/SOFTWARE/Microsoft/Windows NT/CurrentVersion/ProductName

Por ejemplo, mi nombre de producto es Windows 10 Home :

Con este código, obtienes si Windows 10:

 static bool IsWindows10()
{
var reg = Registry.LocalMachine.OpenSubKey(@"SOFTWARE/Microsoft/Windows NT/CurrentVersion");
string productName = (string)reg.GetValue("ProductName");
return productName.StartsWith("Windows 10");
}

Nota: Agregar using Microsoft.Win32; a tus usos.

Answer 6

Sugiero usar el registro para encontrar los valores que desea. Microsoft ha cambiado la forma en que Windows 10 aparece en el registro, por lo que el código debe adaptarse para eso.

Aquí está el código que uso, que identifica correctamente a Windows 10 también:

namespace Inspection
{
/// <summary>
/// Static class that adds convenient methods for getting information on the running computers basic hardware and os setup.
/// </summary>
public static class ComputerInfo
{
/// <summary>
/// Returns the Windows major version number for this computer.
/// </summary>
public static uint WinMajorVersion
{
get
{
dynamic major;
// The ''CurrentMajorVersionNumber'' string value in the CurrentVersion key is new for Windows 10,
// and will most likely (hopefully) be there for some time before MS decides to change this - again...
if (TryGetRegistryKey(@"SOFTWARE/Microsoft/Windows NT/CurrentVersion", "CurrentMajorVersionNumber", out major))
{
return (uint) major;
}
// When the ''CurrentMajorVersionNumber'' value is not present we fallback to reading the previous key used for this: ''CurrentVersion''
dynamic version;
if (!TryGetRegistryKey(@"SOFTWARE/Microsoft/Windows NT/CurrentVersion", "CurrentVersion", out version))
return 0;
var versionParts = ((string) version).Split(''.'');
if (versionParts.Length != 2) return 0;
uint majorAsUInt;
return uint.TryParse(versionParts[0], out majorAsUInt) ? majorAsUInt : 0;
}
}
/// <summary>
/// Returns the Windows minor version number for this computer.
/// </summary>
public static uint WinMinorVersion
{
get
{
dynamic minor;
// The ''CurrentMinorVersionNumber'' string value in the CurrentVersion key is new for Windows 10,
// and will most likely (hopefully) be there for some time before MS decides to change this - again...
if (TryGetRegistryKey(@"SOFTWARE/Microsoft/Windows NT/CurrentVersion", "CurrentMinorVersionNumber",
out minor))
{
return (uint) minor;
}
// When the ''CurrentMinorVersionNumber'' value is not present we fallback to reading the previous key used for this: ''CurrentVersion''
dynamic version;
if (!TryGetRegistryKey(@"SOFTWARE/Microsoft/Windows NT/CurrentVersion", "CurrentVersion", out version))
return 0;
var versionParts = ((string) version).Split(''.'');
if (versionParts.Length != 2) return 0;
uint minorAsUInt;
return uint.TryParse(versionParts[1], out minorAsUInt) ? minorAsUInt : 0;
}
}
/// <summary>
/// Returns whether or not the current computer is a server or not.
/// </summary>
public static uint IsServer
{
get
{
dynamic installationType;
if (TryGetRegistryKey(@"SOFTWARE/Microsoft/Windows NT/CurrentVersion", "InstallationType",
out installationType))
{
return (uint) (installationType.Equals("Client") ? 0 : 1);
}
return 0;
}
}
private static bool TryGetRegistryKey(string path, string key, out dynamic value)
{
value = null;
try
{
var rk = Registry.LocalMachine.OpenSubKey(path);
if (rk == null) return false;
value = rk.GetValue(key);
return value != null;
}
catch
{
return false;
}
}
}
}

Answer 7

Responder

Use Environment.OSVersion y agregue un archivo de manifiesto de aplicación con los elementos relevantes de supportedOS comentar.

por ejemplo, agregue esto debajo de <asmv1: assembly>

<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
<application>
<!-- Windows 10 -->
<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>
<!-- Windows 8.1 -->
<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>
<!-- Windows Vista -->
<supportedOS Id="{e2011457-1546-43c5-a5fe-008deee3d3f0}"/>
<!-- Windows 7 -->
<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>
<!-- Windows 8 -->
<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>
</application>
</compatibility>

Razón

No me gusta la respuesta de @Mitat Koyuncu porque usa el registro innecesariamente y, como se menciona en los comentarios, usa un análisis de cadenas no confiable.

Tampoco me gusta la respuesta de @sstan porque usa código de terceros y necesita el manifiesto de la aplicación de todos modos.

Desde MSDN :

Windows 10: VerifyVersionInfo devuelve falso cuando lo invocan las aplicaciones que no tienen un manifiesto de compatibilidad para Windows 8.1 o Windows 10 si el parámetro lpVersionInfo está configurado para que especifique Windows 8.1 o Windows 10, incluso cuando la versión actual del sistema operativo sea Windows 8.1 o Windows 10. Específicamente, VerifyVersionInfo tiene el siguiente comportamiento:

• Si la aplicación no tiene manifiesto, VerifyVersionInfo se comporta como si la versión del sistema operativo fuera Windows 8 (6.2).

• Si la aplicación tiene un manifiesto que contiene el GUID que corresponde a Windows 8.1, VerifyVersionInfo se comporta como si la versión del sistema operativo fuera Windows 8.1 (6.3).

• Si la aplicación tiene un manifiesto que contiene el GUID que corresponde a Windows 10, VerifyVersionInfo se comporta como si la versión del sistema operativo fuera Windows 10 (10.0).

La razón es porque VerifyVersionInfo está en desuso en Windows 10.

He probado en Windows 10 y, de hecho, Environment.OSVersion funciona exactamente como se esperaba cuando la aplicación. Manifest contiene el GUID relevante como el anterior. Es más probable por qué no lo cambiaron o lo desaprobaron de .Net Framework.