Cómo determinar si .NET Core está instalado

358

Sé que para versiones anteriores de .NET, puede determinar si una versión determinada está instalada siguiendo

https://support.microsoft.com/en-us/kb/318785  

¿Existe un método oficial para determinar si .NET Core está instalado?

(Y no me refiero al SDK, quiero verificar un servidor sin el SDK, para determinar si tiene DotNetCore.1.0.0-WindowsHosting.exe instalado)

puedo ver

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\.NET Cross-Platform Runtime Environment\.NET Framework 4.6\Win\v1-rc1 

con la versión # de 1.0.11123.0 en mi máquina con Windows 7, pero no veo lo mismo en mi máquina con Windows 10.

4
  • 2
    Buena pregunta. Cualquiera que siga .NET Core sabe que el control de versiones en tiempo de ejecución y SDK es un tema muy confuso. Sean 18 de febrero de 2017 a las 0:10
  • 1
    @Chiramisu, todos los que se marcaron a continuación funcionaron para mí, pero debido a algunos detalles de implementación irrelevantes, elegí la configuración de estado deseada y lo usé para asegurarme de que el alojamiento del servidor dnc de Windows esté instalado. (Es decir, tengo Asegúrese = Ausente en DotNetCore.1.0.0-WindowsServerHosting.exe y Asegúrese = Presente en DotnetCore.2.0.5-WindowsServerHosting.exe) (o cualquier otro nombre de archivo que pueda encontrar). DSC maneja todo el lío involucrado con la verificación para asegurarse de que el paquete apropiado esté instalado / desinstalado. weloytty 23/03/18 a las 11:23
  • 3
    dotnet --list-sdks y dotnet --list-runtimes están disponibles en mi host con 2.1.300-preview1-008174 como versión activajumpercake 10 de mayo de 2018 a las 19:06
  • 2
    Ejecute el siguiente comando en powershell dotnet --info Sourcemanikanta kumar 26/04/19 a las 6:17
422

Gran pregunta, y la respuesta no es sencilla. No existe el comando "muéstrame todas las versiones principales de .net", pero hay esperanza.

EDITAR:

No estoy seguro de cuándo se agregó, pero el comando info ahora incluye esta información en su salida. Imprimirá los tiempos de ejecución y los SDK instalados, así como otra información:

dotnet --info

Si solo desea ver los SDK: dotnet --list-sdks

Si solo desea ver los tiempos de ejecución instalados: dotnet --list-runtimes

Estoy en Windows, pero supongo que también funcionaría en Mac o Linux con una versión actual.

Además, puede hacer referencia al archivo de descarga de .NET Core para ayudarlo a descifrar las versiones del SDK.


INFORMACIÓN ANTIGUA: Todo lo que se encuentra debajo de este punto es información antigua, que es menos relevante, pero aún puede ser útil.

Ver tiempos de ejecución instalados :

Abrir C:\Program Files\dotnet\shared\Microsoft.NETCore.Appen el Explorador de Windows

Ver los SDK instalados :

Abrir C:\Program Files\dotnet\sdken el Explorador de Windows

(Fuente de las ubicaciones: blog de un desarrollador )


Además, puede ver las últimas versiones de Runtime y SDK instaladas al emitir estos comandos en el símbolo del sistema:

dotnet La última versión de Runtime es lo primero que se enumera. DESCARGO DE RESPONSABILIDAD: Esto ya no funciona, pero puede funcionar para versiones anteriores.

dotnet --version Última versión del SDK DESCARGO DE RESPONSABILIDAD: Aparentemente, el resultado de esto puede verse afectado por cualquier archivo de configuración global.json.


En macOS, puede verificar la versión principal de .net usando el siguiente comando.

ls /usr/local/share/dotnet/shared/Microsoft.NETCore.App/

En Ubuntu o Alpine:

ls /usr/share/dotnet/shared/Microsoft.NETCore.App/

Enumerará la carpeta con el nombre de la versión instalada.

9
  • dieciséis
    En macOS:ls /usr/local/share/dotnet/shared/Microsoft.NETCore.App/Sergii Volchkov 11/06/2017 a las 19:02
  • 1
    @SergiiVolchkov gracias por el comentario. ¿Puede decirme cómo desinstalar dotnet core1.0.0 de mac? Pankaj Parkar 2 de septiembre de 2017 a las 17:15
  • 1
    .NET Core 2.1.0 agrega "dotnet --list-runtimes" y "dotnet --list-sdks"b8adamson 2 mar. 18 a las 15:27
  • 3
    dotnet --versionenumera el SDK en uso, que es el último de forma predeterminada, pero no siempre es cierto. Si tiene un archivo global.json en la estructura de su carpeta, mostrará la versión configurada en global.json, no la última. Maíra Wenzel - MSFT 27/03/18 a las 1:29
  • 1
    para novatos - estos deben ejecutarse en la línea cmd de WindowsPrashanth Subramanian 12/11/20 a las 8:22
220

Usando Powershell :

Tiempos de ejecución:

(dir (Get-Command dotnet).Path.Replace('dotnet.exe', 'shared\Microsoft.NETCore.App')).Name

SDK:

(dir (Get-Command dotnet).Path.Replace('dotnet.exe', 'sdk')).Name
6
  • 1
    @MarceloFilho ¿Qué versión tienes? Puedes conseguirlo usando [System.Environment]::OSVersion. Probé los comandos mencionados anteriormente con Windows 10, versión 10.0.15063.0. Funciona bien. Andriy Tolstoy 2 de marzo de 2018 a las 8:06
  • 8
    Puedo confirmar que esto funciona perfectamente en Windows Server 2016 y Windows 10.user5389726598465 1 de mayo de 2018 a las 9:58
  • 1
    ¿No está disponible el comando dotnet solo con el SDK instalado? Lo que era exactamente lo contrario de lo que pedía el OP. Aurimas N. 5 de junio de 2018 a las 7:32
  • @AurimasN. No, el comando dotnet.exe está disponible con las implementaciones de SDK y Runtime. El SDK simplemente agrega los comandos CLI necesarios y las bibliotecas de requisitos previos, necesarios para realizar "dotnet.exe build" y "dotnet.exe run" desde dentro de un proyecto. Jason Mock 16 de agosto de 2018 a las 23:31
  • 3
    Funciona en PowerShell en Windows 10, pero prefiero lo dotnet --infosugerido en otras respuestas. Manfred 24 oct 2018 a las 2:20
175

La respuesta correcta para entornos de solo tiempo de ejecución sin el SDK, como un servidor con el paquete de alojamiento de Windows instalado, es ejecutar PowerShell con el siguiente comando:

dotnet --info

Según la documentación oficial :

  • La --versionopción "Imprime la versión de .NET Core SDK en uso". y por lo tanto no funciona si el SDK no está instalado. Mientras que...
  • La --infoopción "Imprime información detallada sobre las herramientas de la CLI y el entorno, como el sistema operativo actual, confirma SHA para la versión y otra información".

Aquí hay otro artículo oficial que explica cómo funciona el control de versiones de .NET Core . :)

3
  • 12
    Lo increíble es que esta es la respuesta real. Y está enterrado debajo de una pila de respuestas de personas que ni siquiera se molestaron en leer la pregunta correctamente. Jammer 12 de abril de 2018 a las 8:53
  • 1
    --infono funciona en mi servidor, mientras que --versionsí funciona. La opción de información me da:Did you mean to run dotnet SDK commands? Please install dotnet SDK from: http://go.microsoft.com/fwlink/?LinkID=798306&clcid=0x409ArieKanarie 4 de junio de 2018 a las 13:29
  • @ArieKanarie Es posible que deba reparar con la herramienta de reparación de Microsoft .NET Framework . Chiramisu 4 de junio de 2018 a las 18:44
111

Puede comprobar si dotnet.exe está disponible:

where dotnet

Luego puede verificar la versión:

dotnet --version

ACTUALIZACIÓN: ahora hay una mejor manera de hacer esto, que se explica bien en muchas otras respuestas:

dotnet --info

2
  • 36
    Supera la versión de la CLI de dotnet, no el tiempo de ejecución. Son dos cosas diferentes. Tener CLI instalado, no significa que el tiempo de ejecución esté instalado y si es la misma versión. Aleksanderis 10/03/2017 a las 16:31
  • sshed a un servidor con solo el tiempo de ejecución instalado para confirmar, no funciona. En su lugar, vea esta respuesta . galdin 2 de diciembre de 2017 a las 5:50
51

Una de las formas ficticias de determinar si .NET Coreestá instalado en Windows es:

  • Presione Windows+R
  • Escribe cmd
  • En el símbolo del sistema, escriba dotnet --version

dotnet --versión

Si .NET Coreestá instalado, no deberíamos obtener ningún error en los pasos anteriores.

8
  • 6
    Consulte el comentario anterior a la misma respuesta: supera a la versión de la CLI de dotnet, no al tiempo de ejecución. Son dos cosas diferentes. Tener CLI instalado, no significa que el tiempo de ejecución esté instalado y si es la misma versiónMichael Freidgeim 13 de septiembre de 2017 a las 3:58
  • Nitpcking, pero no puede tener una CLI que funcione sin un tiempo de ejecución instalado. Entonces, si tiene una CLI, tendrá algo de tiempo de ejecución, es solo que puede ser una versión completamente diferente. omajid 13 dic 2017 a las 23:06
  • @omajid No estoy seguro de qué CLI estás hablando. La CLI a la que me refiero en mi respuesta es la CLI del símbolo del sistema predeterminado en Windows 10 x64 que está instalado / disponible sin instalaciones especialesxameeramir 14 de diciembre de 2017 a las 5:58
  • Esta no es la respuesta a la pregunta. Jammer 12 de abril de 2018 a las 8:55
  • @Jammer Te sugiero que proporciones una sugerencia de ediciónxameeramir 12/04/18 a las 11:46
21

(1) Si está en el sistema Windows.

Abra el símbolo del sistema.

 dotnet --version

(2) Ejecute el siguiente comando si está en un sistema Linux.

dotnet --version

dotnet --info
3
  • type dotnet --version- No funciona en Windows 10. dotnet --versionaunque funciona. ¿Estás seguro de tu respuesta o fue typeun error tipográfico? Ambos comandos de Linux funcionan en Win 10 para mí. Aditya 5 feb 2018 a las 18:14
  • @Aditya está de acuerdo en que typees una instrucción para el lector y no parte del comando. He editado la publicación para que coincida. JohnLBevan 2/04/18 a las 9:25
  • Sí, fue una instrucción. Hiren Parghi 19/04/18 a las 11:09
16

Trabajo principalmente con máquinas y servidores de desarrollo de Windows.

Solo quería señalar (al menos para NET.Core 2.0 y superior) que lo único que se necesita es ejecutar dotnet --infoen un símbolo del sistema para obtener información sobre la última versión instalada. Si .NET Core está instalado, obtendrá alguna respuesta.

En mi máquina de desarrollo (Windows 10), el resultado es el siguiente. SDK es 2.1.2 y el tiempo de ejecución es 2.0.3.

.NET Command Line Tools (2.1.2)

Product Information:
 Version:            2.1.2
 Commit SHA-1 hash:  5695315371

Runtime Environment:
 OS Name:     Windows
 OS Version:  10.0.15063
 OS Platform: Windows
 RID:         win10-x64
 Base Path:   C:\Program Files\dotnet\sdk\2.1.2\

Microsoft .NET Core Shared Framework Host

  Version  : 2.0.3
  Build    : a9190d4a75f4a982ae4b4fa8d1a24526566c69df

En uno de mis servidores que ejecutan Windows Server 2016 con el paquete de alojamiento de Windows Server (sin SDK), el resultado es el siguiente. Sin SDK, el tiempo de ejecución es 2.0.3.

Microsoft .NET Core Shared Framework Host

Version  : 2.0.3
Build    : a9190d4a75f4a982ae4b4fa8d1a24526566c69df

Salud !

12

Los siguientes comandos están disponibles con .NET Core SDK 2.1 (v2.1.300) :

Para enumerar todos los SDK de .NET Core instalados, use: dotnet --list-sdks

Para enumerar todos los tiempos de ejecución de .NET Core instalados, use dotnet --list-runtimes

(probado en Windows al momento de la escritura, 03 de junio de 2018, y nuevamente el 23 de agosto de 2018)

Actualización a partir del 24 de octubre de 2018: la mejor opción probablemente esté ahora dotnet --infoen una ventana de terminal o PowerShell como ya se mencionó en otras respuestas.

3
  • Todos podemos aprender. Curioso por saber el motivo del voto negativo. ¿Quizás dejar un comentario cuando votas en contra? Manfred 22/08/18 a las 20:25
  • No voté en contra, pero supongo que puede deberse a que mencionó los comandos "disponibles con .NET Core SDK", mientras que la pregunta dice "Quiero verificar un servidor sin el SDK". Su respuesta mejoraría si determina cuál de los comandos anteriores funciona cuando solo está instalado el tiempo de ejecución . ToolmakerSteve 14/03/19 a las 13:48
  • @ToolmakerSteve Sí, ese podría ser el punto. Sin embargo, no tengo un entorno sin el SDK y no quisiera llegar a ese extremo eliminándolo ... Sin embargo, gracias por su comentario. Muy apreciado. Manfred 17/03/19 a las 21:58
8

En Windows, solo necesita abrir el símbolo del sistema y escribir:

dotnet --version

Si está instalado .net core framework, obtendrá la versión instalada actual

ver captura de pantalla:

ingrese la descripción de la imagen aquí

1
  • 3
    Esto le da la versión del SDK, no la versión en tiempo de ejecuciónsilkfire 6/10/18 a las 10:29
1

Alternativamente, puedes mirar dentro

C: \ Archivos de programa \ dotnet \ sdk

1

Ejecuta este comando

dotnet --list-sdks

ingrese la descripción de la imagen aquí

1
  • dotnet --list-runtimespara Runtimes instaladosShekhar Reddy 20/12/20 a las 23:24
1

Puede ver qué versiones de .NET Core SDK están instaladas actualmente con una terminal. Abra una terminal y ejecute el siguiente comando.

dotnet --list-sdks
1
dotnet --info

O

dotnet --version

escriba los comandos anteriores en su CMD o Terminal . Entonces mostrará algo como un bramido ingrese la descripción de la imagen aquí

O

ingrese la descripción de la imagen aquí

0

Mire C:\Program Files\dotnet\shared\Microsoft.NETCore.Apppara ver qué versiones del tiempo de ejecución tienen directorios allí. Fuente.

Muchas de las respuestas aquí confunden el SDK con el Runtime, que son diferentes.

0

Después de todas las otras respuestas, esto podría resultar útil.

Abra su aplicación en Visual Studio. En el Explorador de soluciones, haga clic con el botón derecho en su proyecto. Haga clic en Propiedades. Haga clic en Aplicación. En "Target Framework", haga clic en el botón desplegable y ahí están, todos los frameworks instalados.

Por cierto, ahora puede elegir qué marco desea.

1
  • Usé Visual Studio 2017. YMMV. Baruch Atta 15 de mayo de 2019 a las 14:37
0

It's possible that .NET Core is installed but not added to the PATH variable for your operating system or user profile. Running the dotnet commands may not work. As an alternative, you can check that the .NET Core install folders exist.

Está instalado en una carpeta estándar si no lo cambió durante la instilación

  • ejecutable dotnet C:\program files\dotnet\dotnet.exe

  • .NET SDK C:\program files\dotnet\sdk\{version}\

  • .NET Runtime C:\program files\dotnet\shared\{runtime-type}\{version}\

Para obtener más detalles, consulte Cómo verificar que .NET Core ya está instalado en la página de documentación de .NET

0

Puede usar Ejecutar> comando> dotnet --version ingrese la descripción de la imagen aquí

0

Este método solo funciona en Windows y puede ser un poco exagerado.

function Get-InstalledApps {
  [CmdletBinding(SupportsShouldProcess=$false)]
  Param ([Parameter(Mandatory=$false, ValueFromPipeline=$true)] [string]$ComputerName=$env:COMPUTERNAME,
         [Parameter(Mandatory=$false, ValueFromPipeline=$false)] [System.Management.Automation.PSCredential]$Credential)

  Begin { Write-Verbose "Entering $($PSCmdlet.MyInvocation.MyCommand.Name)" }

  Process {
    $HKEY_LOCAL_MACHINE=2147483650
    [email protected]()

    if ($Credential -eq $null) { $Reg=[Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey([Microsoft.Win32.RegistryHive]::LocalMachine,$ComputerName) }
    else { $Reg=Get-WmiObject -Namespace "root\default" -List "StdRegProv" -ComputerName $ComputerName -Credential $Credential }

    [email protected]("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall")
    if ([IntPtr]::Size -ne 4) {
      $RegPath+="SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall"
    }

    for ($i=0; $i -lt $RegPath.Count; $i++) {
      if ($Credential -eq $null) {
        $RegKey=$Reg.OpenSubKey($RegPath[$i])
        $InstallKeys=$RegKey.GetSubKeyNames()
        $RegKey.Close()
      }
      else { $InstallKeys=$Reg.EnumKey($HKEY_LOCAL_MACHINE,$RegPath[$i]) | Select-Object -ExpandProperty sNames }
      [email protected]($InstallKeys)

      for ($j=0; $j -lt $InstallKeys.Count; $j++) {
        if ($Credential -eq $null) {
          $AppKey=$Reg.OpenSubKey(($RegPath[$i]+"\\"+$InstallKeys[$j]))
          $Result=New-Object -Type PSObject -Property @{ComputerName=$ComputerName;
                                                        DisplayName=$AppKey.GetValue("DisplayName");
                                                        Publisher=$AppKey.GetValue("Publisher");
                                                        InstallDate=$AppKey.GetValue("InstallDate");
                                                        DisplayVersion=$AppKey.GetValue("DisplayVersion");
                                                        UninstallString=$AppKey.GetValue("UninstallString")}
          $AppKey.Close()
        }
        else {
          $Result=New-Object -Type PSObject -Property @{ComputerName=$ComputerName;
                                                        DisplayName=$Reg.GetStringValue($HKEY_LOCAL_MACHINE,($RegPath[$i]+"\"+$InstallKeys[$j]),"DisplayName").sValue;
                                                        Publisher=$Reg.GetStringValue($HKEY_LOCAL_MACHINE,($RegPath[$i]+"\"+$InstallKeys[$j]),"Publisher").sValue;
                                                        InstallDate=$Reg.GetStringValue($HKEY_LOCAL_MACHINE,($RegPath[$i]+"\"+$InstallKeys[$j]),"InstallDate").sValue;
                                                        DisplayVersion=$Reg.GetStringValue($HKEY_LOCAL_MACHINE,($RegPath[$i]+"\"+$InstallKeys[$j]),"DisplayVersion").sValue;
                                                        UninstallString=$Reg.GetStringValue($HKEY_LOCAL_MACHINE,($RegPath[$i]+"\"+$InstallKeys[$j]),"UninstallString").sValue;}
        }
        if ($Result.DisplayName -ne $null) { $Results+=$Result }
      }
    }
    if ($Credential -eq $null ) { $Reg.Close() }
    $Results
  }

  End { Write-Verbose "Exiting $($PSCmdlet.MyInvocation.MyCommand.Name)" }
}

$NetSDK=Get-InstalledApps | Where-Object { $_.DisplayName -like "*.NET Core SDK*" } | Sort-Object -Property DisplayVersion -Descending | Select-Object -First 1
$NetHost=Get-InstalledApps | Where-Object { $_.DisplayName -like "*ASP.NET Core*" } | Sort-Object -Property DisplayVersion -Descending | Select-Object -First 1
$NetSDK
$NetHost