O que seria um script do PowerShell para retornar versões do .NET Framework em uma máquina?

Meu primeiro palpite é algo que envolve o WMI. Existe algo melhor?

Deve ser uma linha única retornar apenas a versão mais recente para cada instalação do .NET [em cada linha].

Se você for usar o registro, precisará recursar para obter a versão completa do Framework 4.x. As respostas anteriores retornam o número raiz no meu sistema para o .NET 3.0 (onde os números WCF e WPF, que estão aninhados no 3.0, são mais altos - não posso explicar isso) e falham em retornar qualquer coisa para o 4.0. .

EDIT: Para .Net 4.5 e superior, isso mudou um pouco novamente, então agora há um bom artigo do MSDN explicando como converter a versão versões valor em um número de versão .Net, é uma destruição total de trens :-(

Isso parece correto para mim (observe que ele gera números de versão separados para o WCF e o WPF no 3.0. Não sei do que se trata). Ele também gera o Client e Full no 4.0 (se você os tiver instalado):

Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP' -recurse |
Get-ItemProperty -name Version,Release -EA 0 |
Where { $_.PSChildName -match '^(?!S)\p{L}'} |
Select PSChildName, Version, Release

Com base no artigo do MSDN, você pode criar uma tabela de pesquisa e retornar o número da versão do produto de marketing para lançamentos após a versão 4.5:

$Lookup = @{
    378389 = [version]'4.5'
    378675 = [version]'4.5.1'
    378758 = [version]'4.5.1'
    379893 = [version]'4.5.2'
    393295 = [version]'4.6'
    393297 = [version]'4.6'
    394254 = [version]'4.6.1'
    394271 = [version]'4.6.1'
    394802 = [version]'4.6.2'
    394806 = [version]'4.6.2'
    460798 = [version]'4.7'
    460805 = [version]'4.7'
    461308 = [version]'4.7.1'
    461310 = [version]'4.7.1'
    461808 = [version]'4.7.2'
    461814 = [version]'4.7.2'
    528040 = [version]'4.8'
    528049 = [version]'4.8'
}

# For One True framework (latest .NET 4x), change the Where-Object match 
# to PSChildName -eq "Full":
Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP' -Recurse |
  Get-ItemProperty -name Version, Release -EA 0 |
  Where-Object { $_.PSChildName -match '^(?!S)\p{L}'} |
  Select-Object @{name = ".NET Framework"; expression = {$_.PSChildName}}, 
@{name = "Product"; expression = {$Lookup[$_.Release]}}, 
Version, Release

De fato, como eu continuo tendo que atualizar esta resposta, aqui está um script para gerar o script acima (com um pouco mais) da fonte de remarcação da página da web. Provavelmente isso será interrompido em algum momento, por isso estou mantendo a cópia atual acima.

# Get the text from github
$url = "https://raw.githubusercontent.com/dotnet/docs/master/docs/framework/migration-guide/how-to-determine-which-versions-are-installed.md"
$md = Invoke-WebRequest $url -UseBasicParsing
$OFS = "`n"
# Replace the weird text in the tables, and the padding
# Then trim the | off the front and end of lines
$map = $md -split "`n" -replace " installed [^|]+" -replace "\s+\|" -replace "\|$" |
    # Then we can build the table by looking for unique lines that start with ".NET Framework"
    Select-String "^.NET" | Select-Object -Unique |
    # And flip it so it's key = value
    # And convert ".NET FRAMEWORK 4.5.2" to  [version]4.5.2
    ForEach-Object { 
        [version]$v, [int]$k = $_ -replace "\.NET Framework " -split "\|"
        "    $k = [version]'$v'"
    }

# And output the whole script
@"
`$Lookup = @{
$map
}

# For extra effect we could get the Windows 10 OS version and build release id:
try {
    `$WinRelease, `$WinVer = Get-ItemPropertyValue "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion" ReleaseId, CurrentMajorVersionNumber, CurrentMinorVersionNumber, CurrentBuildNumber, UBR
    `$WindowsVersion = "`$(`$WinVer -join '.') (`$WinRelease)"
} catch {
    `$WindowsVersion = [System.Environment]::OSVersion.Version
}

Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP' -Recurse |
    Get-ItemProperty -name Version, Release -EA 0 |
    # For The One True framework (latest .NET 4x), change match to PSChildName -eq "Full":
    Where-Object { `$_.PSChildName -match '^(?!S)\p{L}'} |
    Select-Object @{name = ".NET Framework"; expression = {`$_.PSChildName}}, 
                @{name = "Product"; expression = {`$Lookup[`$_.Release]}}, 
                Version, Release,
    # Some OPTIONAL extra output: PSComputerName and WindowsVersion
    # The Computer name, so output from local machines will match remote machines:
    @{ name = "PSComputerName"; expression = {`$Env:Computername}},
    # The Windows Version (works on Windows 10, at least):
    @{ name = "WindowsVersion"; expression = { `$WindowsVersion }}
"@

gci 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP' |
sort pschildname -des                                  |
select -fi 1 -exp pschildname

Esta resposta não retorna 4.5 se estiver instalada. A resposta abaixo de @Jaykul e usando recurse faz.

Adicionado suporte v4.8 ao script:

Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP' -recurse |
Get-ItemProperty -name Version,Release -EA 0 |
Where { $_.PSChildName -match '^(?![SW])\p{L}'} |
Select PSChildName, Version, Release, @{
  name="Product"
  expression={
      switch -regex ($_.Release) {
        "378389" { [Version]"4.5" }
        "378675|378758" { [Version]"4.5.1" }
        "379893" { [Version]"4.5.2" }
        "393295|393297" { [Version]"4.6" }
        "394254|394271" { [Version]"4.6.1" }
        "394802|394806" { [Version]"4.6.2" }
        "460798|460805" { [Version]"4.7" }
        "461308|461310" { [Version]"4.7.1" }
        "461808|461814" { [Version]"4.7.2" }
        "528040|528049" { [Version]"4.8" }
        {$_ -gt 528049} { [Version]"Undocumented version (> 4.8), please update script" }
      }
    }
}

[environment]::Version

Fornece uma instância do VersionCLR que a cópia atual do PSH está usando (conforme documentado aqui ).

Sintaxe correta:

[System.Runtime.InteropServices.RuntimeEnvironment]::GetSystemVersion()
#or
$PSVersionTable.CLRVersion

A GetSystemVersionfunção retorna uma string como esta:

v2.0.50727        #PowerShell v2.0 in Win 7 SP1

ou assim

v4.0.30319        #PowerShell v3.0 (Windows Management Framework 3.0) in Win 7 SP1

$PSVersionTableé um objeto somente leitura. A propriedade CLRVersion é um número de versão estruturada como este:

Major  Minor  Build  Revision
-----  -----  -----  --------
4      0      30319  18444   

Eu encontrei isso através da conclusão da guia no powershell para osx:

[System.Runtime.InteropServices.RuntimeInformation]::get_FrameworkDescription() .NET Core 4.6.25009.03

Não há uma maneira confiável de fazer isso para todas as plataformas e arquiteturas usando um script simples. Se você quiser aprender como fazê-lo de maneira confiável, comece na postagem do blog Exemplo de código de detecção do .NET Framework atualizado que faz uma verificação mais aprofundada .

Consulte a página Script para descobrir quais versões do .NET estão instaladas em estações de trabalho remotas .

O script pode ser útil para encontrar a versão do .NET para várias máquinas em uma rede.

Nice solution

Tente usar o módulo DotNetVersionLister que pode ser baixado (com base em informações do registro e em alguma tabela de pesquisa de versão para marketing).

Qual seria usado assim:

PS> Get-DotNetVersion -LocalHost -nosummary


ComputerName : localhost
>=4.x        : 4.5.2
v4\Client    : Installed
v4\Full      : Installed
v3.5         : Installed
v3.0         : Installed
v2.0.50727   : Installed
v1.1.4322    : Not installed (no key)
Ping         : True
Error        :

Ou assim, se você quiser testá-lo para alguma estrutura .NET> = 4. * :

PS> (Get-DotNetVersion -LocalHost -nosummary).">=4.x"
4.5.2

Mas não funcionará (instalar / importar), por exemplo, com o PS v2.0 ( Win 7 , Win Server 2010 padrão) devido a incompatibilidade ...

Motivação para as funções "herdadas" abaixo

(Você pode pular a leitura e usar o código abaixo)

Tivemos que trabalhar com o PS 2.0 em algumas máquinas e não foi possível instalar / importar o DotNetVersionLister acima .
Em outras máquinas que queríamos para atualizar (do PS 2.0 ) para PS 5.1 (que por sua vez precisa .NET Framework> = 4,5 ) com a ajuda de duas empresas sob medida Install-DotnetLatestCompanye Install-PSLatestCompany.
Para orientar bem os administradores no processo de instalação / atualização, teríamos que determinar a versão .NET nessas funções em todas as máquinas e versões PS existentes.
Assim, usamos também as funções abaixo para determiná-las com mais segurança em todos os ambientes ...

Funções para ambientes PS herdados (por exemplo, PS v2.0 )

Portanto, o código a seguir e os exemplos de uso abaixo (extraídos) são úteis aqui (com base em outras respostas aqui):

function Get-DotNetVersionByFs {
  <#
    .SYNOPSIS
      NOT RECOMMENDED - try using instead:
        Get-DotNetVersion 
          from DotNetVersionLister module (https://github.com/EliteLoser/DotNetVersionLister), 
          but it is not usable/importable in PowerShell 2.0 
        Get-DotNetVersionByReg
          reg(istry) based: (available herin as well) but it may return some wrong version or may not work reliably for versions > 4.5 
          (works in PSv2.0)
      Get-DotNetVersionByFs (this):  
        f(ile) s(ystem) based: determines the latest installed .NET version based on $Env:windir\Microsoft.NET\Framework content
        this is unreliable, e.g. if 4.0* is already installed some 4.5 update will overwrite content there without
        renaming the folder
        (works in PSv2.0)
    .EXAMPLE
      PS> Get-DotnetVersionByFs
      4.0.30319
    .EXAMPLE
      PS> Get-DotnetVersionByFs -All
      1.0.3705
      1.1.4322
      2.0.50727
      3.0
      3.5
      4.0.30319
    .NOTES
      from https://stackoverflow.com/a/52078523/1915920
  #>
    [cmdletbinding()]
  param(
    [Switch]$All  ## do not return only latest, but all installed
  )
  $list = ls $Env:windir\Microsoft.NET\Framework |
    ?{ $_.PSIsContainer -and $_.Name -match '^v\d.[\d\.]+' } |
    %{ $_.Name.TrimStart('v') }
  if ($All) { $list } else { $list | select -last 1 }
}


function Get-DotNetVersionByReg {
  <#
    .SYNOPSIS
      NOT RECOMMENDED - try using instead:
        Get-DotNetVersion
          From DotNetVersionLister module (https://github.com/EliteLoser/DotNetVersionLister), 
          but it is not usable/importable in PowerShell 2.0. 
          Determines the latest installed .NET version based on registry infos under 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP'
    .EXAMPLE
        PS> Get-DotnetVersionByReg
        4.5.51209
    .EXAMPLE
        PS> Get-DotnetVersionByReg -AllDetailed
        PSChildName                                          Version                                             Release
        -----------                                          -------                                             -------
        v2.0.50727                                           2.0.50727.5420
        v3.0                                                 3.0.30729.5420
        Windows Communication Foundation                     3.0.4506.5420
        Windows Presentation Foundation                      3.0.6920.5011
        v3.5                                                 3.5.30729.5420
        Client                                               4.0.0.0
        Client                                               4.5.51209                                           379893
        Full                                                 4.5.51209                                           379893
    .NOTES
      from https://stackoverflow.com/a/52078523/1915920
  #>
    [cmdletbinding()]
    param(
        [Switch]$AllDetailed  ## do not return only latest, but all installed with more details
    )
    $Lookup = @{
        378389 = [version]'4.5'
        378675 = [version]'4.5.1'
        378758 = [version]'4.5.1'
        379893 = [version]'4.5.2'
        393295 = [version]'4.6'
        393297 = [version]'4.6'
        394254 = [version]'4.6.1'
        394271 = [version]'4.6.1'
        394802 = [version]'4.6.2'
        394806 = [version]'4.6.2'
        460798 = [version]'4.7'
        460805 = [version]'4.7'
        461308 = [version]'4.7.1'
        461310 = [version]'4.7.1'
        461808 = [version]'4.7.2'
        461814 = [version]'4.7.2'
    }
    $list = Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP' -Recurse |
        Get-ItemProperty -name Version, Release -EA 0 |
        # For One True framework (latest .NET 4x), change match to PSChildName -eq "Full":
        Where-Object { $_.PSChildName -match '^(?!S)\p{L}'} |
        Select-Object `
           @{
               name = ".NET Framework" ; 
               expression = {$_.PSChildName}}, 
           @{  name = "Product" ; 
               expression = {$Lookup[$_.Release]}}, 
           Version, Release
    if ($AllDetailed) { $list | sort version } else { $list | sort version | select -last 1 | %{ $_.version } }
}

Exemplo de uso:

PS> Get-DotNetVersionByFs
4.0.30319

PS> Get-DotNetVersionByFs -All
1.0.3705
1.1.4322
2.0.50727
3.0
3.5
4.0.30319

PS> Get-DotNetVersionByReg
4.5.51209

PS> Get-DotNetVersionByReg -AllDetailed

.NET Framework                   Product Version        Release
--------------                   ------- -------        -------
v2.0.50727                               2.0.50727.5420
v3.0                                     3.0.30729.5420
Windows Communication Foundation         3.0.4506.5420
Windows Presentation Foundation          3.0.6920.5011
v3.5                                     3.5.30729.5420
Client                                   4.0.0.0
Client                           4.5.2   4.5.51209      379893
Full                             4.5.2   4.5.51209      379893

Feio. Definitivamente não é bonito:

ls $Env:windir\Microsoft.NET\Framework | ? { $_.PSIsContainer } | select -exp Name -l 1

Isso pode ou não funcionar. Mas, no que diz respeito à versão mais recente, isso deve ser bastante confiável, pois existem pastas vazias para versões antigas (1.0, 1.1), mas não para as mais recentes - essas aparecem apenas quando a estrutura apropriada é instalada.

Ainda assim, suspeito que deve haver uma maneira melhor.

Se você instalou o Visual Studio em sua máquina, abra o prompt de comando do Visual Studio Developer e digite o seguinte comando: clrver

Ele listará todas as versões instaladas do .NET Framework nessa máquina.

Aqui está minha opinião sobre esta questão, seguindo a documentação do msft :

$gpParams = @{
    Path        = 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full'
    ErrorAction = 'SilentlyContinue'
}
$release = Get-ItemProperty @gpParams | Select-Object -ExpandProperty Release

".NET Framework$(
    switch ($release) {
        ({ $_ -ge 528040 }) { ' 4.8'; break }
        ({ $_ -ge 461808 }) { ' 4.7.2'; break }
        ({ $_ -ge 461308 }) { ' 4.7.1'; break }
        ({ $_ -ge 460798 }) { ' 4.7'; break }
        ({ $_ -ge 394802 }) { ' 4.6.2'; break }
        ({ $_ -ge 394254 }) { ' 4.6.1'; break }
        ({ $_ -ge 393295 }) { ' 4.6'; break }
        ({ $_ -ge 379893 }) { ' 4.5.2'; break }
        ({ $_ -ge 378675 }) { ' 4.5.1'; break }
        ({ $_ -ge 378389 }) { ' 4.5'; break }
        default { ': 4.5+ not installed.' }
    }
)"

Este exemplo funciona com todas as versões do PowerShell e funcionará permanentemente, pois 4.8 é a última versão do .NET Framework.

Aqui está a ideia geral:

Obtenha itens filho no diretório .NET Framework que são contêineres cujos nomes correspondem ao padrão v number number number . Classifique-os por nome descendente, pegue o primeiro objeto e retorne sua propriedade name.

Aqui está o script:

(Get-ChildItem -Path $Env:windir\Microsoft.NET\Framework | Where-Object {$_.PSIsContainer -eq $true } | Where-Object {$_.Name -match 'v\d\.\d'} | Sort-Object -Property Name -Descending | Select-Object -First 1).Name

Eu tentaria este no PowerShell: Funcionou para mim!

(Get-ItemProperty "HKLM: Software \ Microsoft \ NET Framework Setup \ NDP \ v4 \ Full"). Versão

Não estou familiarizado com a sintaxe do PowerShell, mas acho que você poderia chamar System.Runtime.InteropServices.RuntimeEnvironment.GetSystemVersion () . Isso retornará a versão como uma string (algo como v2.0.50727, eu acho).

Este é um derivado do post anterior, mas obtém a versão mais recente do .net framework 4 em meus testes.

get-itemproperty -name version,release "hklm:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\FULL"

O que permitirá que você invoque o comando na máquina remota:

invoke-command -computername server01 -scriptblock {get-itemproperty -name version,release "hklm:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\FULL" | select pscomputername,version,release} 

O que configura essa possibilidade com o ADModule e o prefixo da convenção de nomenclatura:

get-adcomputer -Filter 'name -like "*prefix*"' | % {invoke-command -computername $_.name -scriptblock {get-itemproperty -name version,release "hklm:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\FULL" | select pscomputername,version,release} | ft