CODEWITHSUNDEEP
c#asp.net-core.net-core
weloytty
weloytty

Reputation: 6098

How to determine if .NET Core is installed

I know that for older versions of .NET, you can determine if a given version is installed by following 

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

Is there an official method of determining if .NET Core is installed?

(And I don't mean the SDK, I want to check a server without the SDK, to determine if it has DotNetCore.1.0.0-WindowsHosting.exe installed on it)

I can see 

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

with Version# of 1.0.11123.0 on my windows 7 machine, but I don't see the same stuff on my Windows 10 machine.

Upvotes: 441

Views: 575361

Answers (22)

Allen.Cai
Allen.Cai

Reputation: 549

Using terminal command:

dotnet --list-runtimes

OR Using CSharp code:

using CliWrap;
using CliWrap.EventStream;
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;

// License: Do whatever you want with this. This is what my project uses,
// I make no guarantees it works or will work in the future
// THIS IS ONLY FOR .NET CORE DETECTION (no .NET framework!)
// Requires CliWrap https://github.com/Tyrrrz/CliWrap

namespace DotnetHelper
{
    /// <summary>
    /// Class that can determine if a version of .NET Core is installed
    /// </summary>
    public class DotNetRuntimeVersionDetector
    {
        /// <summary>
        /// This is very windows specific
        /// </summary>
        /// <returns>List of versions matching the specified version</returns>
        public static async IAsyncEnumerable<ProductInfo> GetInstalledRuntimesAsync([EnumeratorCancellation] CancellationToken cancellationToken = default)
        {
            // No validation. Make sure exit code is checked in the calling process.
            Command cmd = Cli.Wrap("dotnet.exe").WithArguments("--list-runtimes").WithValidation(CommandResultValidation.None);
            await foreach(CommandEvent cmdEvent in cmd.ListenAsync(cancellationToken))
            {
                switch(cmdEvent)
                {
                    case StartedCommandEvent started:
                        break;
                    case StandardOutputCommandEvent stdOut:
                        if(string.IsNullOrWhiteSpace(stdOut.Text))
                        {
                            continue;
                        }

                        if(stdOut.Text.StartsWith("Microsoft.NETCore.App")
                           || stdOut.Text.StartsWith("Microsoft.WindowsDesktop.App")
                           || stdOut.Text.StartsWith("Microsoft.AspNetCore.App")
                           || stdOut.Text.StartsWith("Microsoft.AspNetCore.All"))
                        {
                            yield return Parse(stdOut.Text);
                        }
                        break;
                    case StandardErrorCommandEvent stdErr:
                        break;
                    case ExitedCommandEvent exited:
                        break;
                }
            }
        }

        private static ProductInfo Parse(ReadOnlySpan<char> stdOutText)
        {
            int firstIndex = stdOutText.IndexOf(' ');
            string productName = stdOutText.Slice(0, firstIndex).ToString();
            ReadOnlySpan<char> subText = stdOutText.Slice(firstIndex + 1, stdOutText.Length - firstIndex - 2);
            int secondIndex = subText.IndexOf(' ');
            ReadOnlySpan<char> version = subText.Slice(0, secondIndex);
            ReadOnlySpan<char> path = subText.Slice(secondIndex + 2);
            return new ProductInfo(productName, Version.Parse(version), string.Concat(path, "\\", version));
        }

        private static Version ParseVersion(string stdOutText)
        {
            // 0 = SDK name, 1 = version, 2+ = path parts
            string[] split = stdOutText.Split(' ');
            return Version.Parse(split[1]);
        }
    }

    /// <summary>
    /// .NET Product information
    /// </summary>
    /// <param name="ProductName">Product name</param>
    /// <param name="Version">Product version</param>
    /// <param name="InstalledPath">Installed path</param>
    public record struct ProductInfo(string ProductName, Version Version, string InstalledPath);
}

OR Using PowerShell code:

class ProductInfo {
    [string]$ProductName
    [System.Version]$Version
    [string]$InstalledPath
    
    ProductInfo()
    {
        
    }
    
    ProductInfo([string]$productName, [System.Version]$version, [string]$installedPath)
    {
        $this.ProductName = $productName
        $this.Version = $version
        $this.Args = $installedPath
    }
}

function Get-InstalledDotNetRuntimes
{
    [OutputType([ProductInfo[]])]
    param ()
    
    # Execute `dotnet --list-runtimes` command.
    $runtimes = Invoke-Expression "dotnet --list-runtimes"
    
    # Create an empty array to store the Product informations.
    # $productInfos = New-Object System.Collections.Generic.List[ProductInfo]
    [ProductInfo[]]$productInfos = @()
    
    # Foreach line of output
    $runtimes -split "`n" | ForEach-Object {
        # Skip empty line
        if (![string]::IsNullOrWhiteSpace($_))
        {
            # Parse product name, version and installation path
            $parts = $_ -split " ", 3
            $productName = $parts[0]
            $version = [System.Version]::Parse($parts[1])
            $installedPath = $parts[2].TrimStart('[').TrimEnd(']') # Remove [] characters before and after
            
            # Create a new ProductInfo object.
            $productInfo = New-Object ProductInfo -Property @{
                ProductName   = $productName
                Version       = $version
                InstalledPath = $installedPath
            }
            
            # Add the ProductInfo object to the array
            $productInfos += $productInfo
        }
    }
    
    # Output the ProductInfo list
    return $productInfos
}

Get-InstalledDotNetRuntimes

Upvotes: 0

Mgamerz
Mgamerz

Reputation: 2890

I came here looking for a programmatic way to determine this; while this question has many good answers, none of them seem programmatic.

I made a small file in C# that parses the output of dotnet.exe --list-runtimes which could be pretty easily adapted to fit your needs. It uses the CliWrap nuget package; you could probably do without it, but I already used it in my project, as it makes command line handling easier for my needs.

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using CliWrap;
using CliWrap.EventStream;

// License: Do whatever you want with this. This is what my project uses,
// I make no guarantees it works or will work in the future
// THIS IS ONLY FOR .NET CORE DETECTION (no .NET framework!)
// Requires CliWrap https://github.com/Tyrrrz/CliWrap

namespace DotnetHelper
{
    /// <summary>
    /// Class that can determine if a version of .NET Core is installed
    /// </summary>
    public class DotNetRuntimeVersionDetector
    {
        /// <summary>
        /// This is very windows specific
        /// </summary>
        /// <param name="desktopVersionsOnly">If it needs to filter to Windows Desktop versions only (WPF/Winforms).</param>
        /// <returns>List of versions matching the specified version</returns>
        public static async Task<Version[]> GetInstalledRuntimeVersions(bool desktopVersion)
        {
            // No validation. Make sure exit code is checked in the calling process.
            var cmd = Cli.Wrap(@"dotnet.exe").WithArguments(@"--list-runtimes").WithValidation(CommandResultValidation.None);
            var runtimes = new List<Version>();
            await foreach (var cmdEvent in cmd.ListenAsync())
            {
                switch (cmdEvent)
                {
                    case StartedCommandEvent started:
                        break;
                    case StandardOutputCommandEvent stdOut:
                        if (string.IsNullOrWhiteSpace(stdOut.Text))
                        {
                            continue;
                        }

                        if (stdOut.Text.StartsWith(@"Microsoft.NETCore.App") && !desktopVersion)
                        {
                            runtimes.Add(parseVersion(stdOut.Text));
                        }
                        else if (stdOut.Text.StartsWith(@"Microsoft.WindowsDesktop.App") && desktopVersion)
                        {
                            runtimes.Add(parseVersion(stdOut.Text));
                        }
                        break;
                    case StandardErrorCommandEvent stdErr:
                        break;
                    case ExitedCommandEvent exited:
                        break;
                }
            }

            return runtimes.ToArray();
        }

        private static Version parseVersion(string stdOutText)
        {
            var split = stdOutText.Split(' ');
            return Version.Parse(split[1]); // 0 = SDK name, 1 = version, 2+ = path parts
        }
    }
}

Upvotes: 4

Enrique Mingyar Torrez Hinojos
Enrique Mingyar Torrez Hinojos

Reputation: 167

--On CMD

For .Net Framework

wmic product get description | findstr /C:".NET Framework

For .Net Core

dotnet --info

Upvotes: 10

Simon Stanford
Simon Stanford

Reputation: 491

On windows I've checked the registry key:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\ASP.NET Core\Shared Framework\v5.0\5.0.12

Upvotes: 2

Slogmeister Extraordinaire
Slogmeister Extraordinaire

Reputation: 3171

This method works only on Windows and may be a bit of overkill.

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
    $Results=@()

    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 }

    $RegPath=@("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 }
      $InstallKeys=@($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

Upvotes: 2

ISK
ISK

Reputation: 99

You can use Run> command > dotnet --version enter image description here

Upvotes: 0

Amar Anondo
Amar Anondo

Reputation: 742

dotnet --info

OR

dotnet --version

write the above command(s) on your CMD or Terminal. Then it will show something like bellow enter image description here

Or

enter image description here

Upvotes: 3

SOUVIK SAHA
SOUVIK SAHA

Reputation: 191

You can see which versions of the .NET Core SDK are currently installed with a terminal. Open a terminal and run the following command.

dotnet --list-sdks

Upvotes: 3

ElasticCode
ElasticCode

Reputation: 7867

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.

It's installed to a standard folder if you didn't change it during the instillation

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

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

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

For more details check How to check that .NET Core is already installed page at .NET documentation

Upvotes: 1

Rajdeep D
Rajdeep D

Reputation: 3910

Run this command

dotnet --list-sdks

enter image description here

Upvotes: 3

Sean
Sean

Reputation: 8787

Great question, and the answer is not a simple one. There is no "show me all .net core versions" command, but there's hope.

EDIT:

I'm not sure when it was added, but the info command now includes this information in its output. It will print out the installed runtimes and SDKs, as well as some other info:

dotnet --info

If you only want to see the SDKs: dotnet --list-sdks

If you only want to see installed runtimes: dotnet --list-runtimes

I'm on Windows, but I'd guess that would work on Mac or Linux as well with a current version.

Also, you can reference the .NET Core Download Archive to help you decipher the SDK versions.

OLDER INFORMATION: Everything below this point is old information, which is less relevant, but may still be useful.

See installed Runtimes:

Open C:\Program Files\dotnet\shared\Microsoft.NETCore.App in Windows Explorer

See installed SDKs:

Open C:\Program Files\dotnet\sdk in Windows Explorer

(Source for the locations: A developer's blog)

In addition, you can see the latest Runtime and SDK versions installed by issuing these commands at the command prompt:

dotnet Latest Runtime version is the first thing listed. DISCLAIMER: This no longer works, but may work for older versions.

dotnet --version Latest SDK version DISCLAIMER: Apparently the result of this may be affected by any global.json config files.

On macOS you could check .net core version by using below command.

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

On Ubuntu or Alpine:

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

It will list down the folder with installed version name.

Upvotes: 535

Andriy Tolstoy
Andriy Tolstoy

Reputation: 6090

Using Powershell:

Runtimes:

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

SDKs:

(dir (Get-Command dotnet).Path.Replace('dotnet.exe', 'sdk')).Name

Upvotes: 230

Zeus
Zeus

Reputation: 3357

Alternatively you can just look inside

C:\Program Files\dotnet\sdk

Upvotes: 1

Robert Paulsen
Robert Paulsen

Reputation: 5141

You can check if dotnet.exe is available:

where dotnet

You can then check the version:

dotnet --version

UPDATE: There is now a better way of doing this, which is well explained in many other answers:

dotnet --info

Upvotes: 126

Baruch Atta
Baruch Atta

Reputation: 431

After all the other answers, this might prove useful.

Open your application in Visual Studio. In Solutions Explorer, right click your project. Click Properties. Click Application. Under "Target Framework" click the dropdown button and there you are, all of the installed frameworks.

BTW - you may now choose which framework you want.

Upvotes: 0

Manfred
Manfred

Reputation: 5666

The following commands are available with .NET Core SDK 2.1 (v2.1.300):

To list all installed .NET Core SDKs use: dotnet --list-sdks

To list all installed .NET Core runtimes use dotnet --list-runtimes

(tested on Windows as of writing, 03 Jun 2018, and again on 23 Aug 2018)

Update as of 24 Oct 2018: Better option is probably now dotnet --info in a terminal or PowerShell window as already mentioned in other answers.

Upvotes: 14

jaycer
jaycer

Reputation: 3111

Look in C:\Program Files\dotnet\shared\Microsoft.NETCore.App to see which versions of the runtime have directories there. Source.

A lot of the answers here confuse the SDK with the Runtime, which are different.

Upvotes: 1

Eli Dagan
Eli Dagan

Reputation: 848

On windows, You only need to open the command prompt and type:

dotnet --version

If the .net core framework installed you will get current installed version

see screenshot:

enter image description here

Upvotes: 8

Hiren Parghi
Hiren Parghi

Reputation: 1895

(1) If you are on the Window system.

Open the command prompt.

 dotnet --version

(2) Run the below command If you are on Linux system.

dotnet --version

dotnet --info

Upvotes: 22

Hakan &#199;elik Mk1
Hakan &#199;elik Mk1

Reputation: 429

I work primarily with Windows development machines and servers.

I just wanted to point out (at least for NET.Core 2.0 and above) the only thing needed is to execute dotnet --info in a command prompt to get information about the latest version installed. If .NET Core is installed you will get some response.

On my development machine (Windows 10) the result is as follows. SDK is 2.1.2 and runtime is 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

On one of my servers running Windows Server 2016 with Windows Server Hosting pack (no SDK) result is as follows. No SDK, runtime is 2.0.3.

Microsoft .NET Core Shared Framework Host

Version  : 2.0.3
Build    : a9190d4a75f4a982ae4b4fa8d1a24526566c69df

Cheers !

Upvotes: 16

Chiramisu
Chiramisu

Reputation: 4726

The correct answer for runtime-only environments without the SDK, such as a server with the Windows Hosting package installed, is to run PowerShell with the following command:

dotnet --info

Per the official documentation:

  • The --version option "Prints out the version of the .NET Core SDK in use." and therefore doesn't work if the SDK is not installed. Whereas...
  • The --info option "Prints out detailed information about the CLI tooling and the environment, such as the current operating system, commit SHA for the version, and other information."

Here's another official article explaining how .NET Core versioning works. :)

Upvotes: 186

Xameer
Xameer

Reputation: 31237

One of the dummies ways to determine if .NET Core is installed on Windows is:

  • Press Windows + R
  • Type cmd
  • On the command prompt, type dotnet --version

dotnet --version

If the .NET Core is installed, we should not get any error in the above steps.

Upvotes: 54

Related Questions