Was wäre ein PowerShell-Skript, um Versionen von .NET Framework auf einem Computer zurückzugeben?

Meine erste Vermutung betrifft WMI. Gibt es etwas besseres?

Es sollte ein Einzeiler sein, für jede Installation von .NET [in jeder Zeile] nur die neueste Version zurückzugeben.

Wenn Sie die Registrierung verwenden möchten, müssen Sie einen Rekurs durchführen, um die Vollversion für das 4.x Framework zu erhalten. Die früheren Antworten geben beide die Stammnummer auf meinem System für .NET 3.0 zurück (wobei die WCF- und WPF-Nummern, die unter 3.0 verschachtelt sind, höher sind - das kann ich nicht erklären) und geben für 4.0 nichts zurück. .

BEARBEITEN: Für .Net 4.5 und höher hat sich dies wieder leicht geändert, daher gibt es hier jetzt einen schönen MSDN-Artikel, in dem erklärt wird, wie das Release konvertiert wird Wert in eine .Net-Versionsnummer wird. Es handelt sich um ein totales Zugunglück :-(

Das sieht für mich richtig aus (beachten Sie, dass es separate Versionsnummern für WCF & WPF unter 3.0 ausgibt. Ich weiß nicht, worum es geht). Es gibt auch sowohl Client als auch Full unter 4.0 aus (wenn Sie beide installiert haben):

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

Basierend auf dem MSDN-Artikel können Sie eine Nachschlagetabelle erstellen und die Versionsnummer des Marketingprodukts für Releases nach 4.5 zurückgeben:

$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

Da ich diese Antwort ständig aktualisieren muss, finden Sie hier ein Skript zum Generieren des obigen Skripts (mit einem kleinen Extra) aus der Markdown-Quelle für diese Webseite. Dies wird wahrscheinlich irgendwann kaputt gehen, also behalte ich die aktuelle Kopie oben.

# 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

Diese Antwort gibt nicht 4.5 zurück, wenn das installiert ist. Die Antwort unten von @Jaykul und die Verwendung von recurse tut es.

Unterstützung für v4.8 zum Skript hinzugefügt:

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

Gibt Ihnen eine Instanz Versionfür die CLR, die die aktuelle Kopie von PSH verwendet (wie hier dokumentiert ).

Richtige Syntax:

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

Die GetSystemVersionFunktion gibt eine Zeichenfolge wie folgt zurück:

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

oder so

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

$PSVersionTableist ein schreibgeschütztes Objekt. Die CLRVersion-Eigenschaft ist eine strukturierte Versionsnummer wie folgt:

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

Ich fand dies durch Tab-Vervollständigung in Powershell für Osx:

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

Es gibt keine zuverlässige Möglichkeit, dies für alle Plattformen und Architekturen mithilfe eines einfachen Skripts zu tun. Wenn Sie lernen möchten, wie dies zuverlässig funktioniert, beginnen Sie mit dem Blogbeitrag. Aktualisierter Beispiel-.NET Framework-Erkennungscode, der eine eingehendere Überprüfung durchführt .

Auf der Seite Skript finden Sie Informationen dazu , welche .NET-Versionen auf Remote-Workstations installiert sind .

Das dortige Skript kann hilfreich sein, um die .NET-Version für mehrere Computer in einem Netzwerk zu finden.

Schöne Lösung

Versuchen Sie es mit dem herunterladbaren DotNetVersionLister- Modul (basierend auf Registrierungsinformationen und einer Nachschlagetabelle von Version zu Marketing-Version).

Welches würde so verwendet werden:

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        :

Oder so, wenn Sie es nur für ein .NET Framework testen möchten > = 4. * :

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

Aber es wird nicht funktionieren (installieren / importieren), zB mit PS v2.0 ( Win 7 , Win Server 2010 Standard) wegen Inkompatibilität ...

Motivation für "Legacy" -Funktionen unten

(Sie können das Lesen überspringen und den folgenden Code verwenden.)

Wir mussten auf einigen Computern mit PS 2.0 arbeiten und konnten den obigen DotNetVersionLister nicht installieren / importieren .
Auf anderen Computern wollten wir (von PS 2.0 ) auf PS 5.1 (das wiederum .NET Framework> = 4.5 benötigt ) mit Hilfe von zwei firmeneigenen Install-DotnetLatestCompanyund aktualisieren Install-PSLatestCompany.
Um Administratoren gut durch den Installations- / Aktualisierungsprozess zu führen, müssten wir die .NET-Version in diesen Funktionen auf allen vorhandenen Computern und PS-Versionen ermitteln.
Daher haben wir auch die folgenden Funktionen verwendet, um sie in allen Umgebungen sicherer zu bestimmen ...

Funktionen für ältere PS-Umgebungen (z. B. PS v2.0 )

Der folgende Code und die folgenden (extrahierten) Verwendungsbeispiele sind hier nützlich (basierend auf anderen Antworten hier):

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 } }
}

Anwendungsbeispiel:

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

Nicht hübsch. Auf jeden Fall nicht schön:

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

Dies kann funktionieren oder nicht. Für die neueste Version sollte dies jedoch ziemlich zuverlässig sein, da es im Wesentlichen leere Ordner für alte Versionen (1.0, 1.1) gibt, aber keine neueren - diese werden erst angezeigt, wenn das entsprechende Framework installiert ist.

Trotzdem vermute ich, dass es einen besseren Weg geben muss.

Wenn Sie Visual Studio auf Ihrem Computer installiert haben, öffnen Sie die Eingabeaufforderung für Visual Studio Developer und geben Sie den folgenden Befehl ein: clrver

Es werden alle auf diesem Computer installierten Versionen von .NET Framework aufgelistet.

Hier ist meine Meinung zu dieser Frage gemäß der MSFT-Dokumentation :

$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.' }
    }
)"

Dieses Beispiel funktioniert mit allen PowerShell-Versionen und funktioniert auf Dauer, da 4.8 die letzte .NET Framework-Version ist.

Hier ist die allgemeine Idee:

Rufen Sie untergeordnete Elemente im .NET Framework-Verzeichnis ab, bei denen es sich um Container handelt, deren Namen mit der Punktnummer des Musters v übereinstimmen . Sortieren Sie sie nach absteigendem Namen, nehmen Sie das erste Objekt und geben Sie die Eigenschaft name zurück.

Hier ist das Skript:

(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

Ich würde dieses in PowerShell versuchen: Arbeitete für mich!

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

Ich bin mit meiner PowerShell-Syntax nicht vertraut , aber ich denke, Sie könnten einfach System.Runtime.InteropServices.RuntimeEnvironment.GetSystemVersion () aufrufen. . Dies gibt die Version als Zeichenfolge zurück (so etwas wiev2.0.50727 , denke ich).

Dies ist ein Derivat des vorherigen Beitrags, aber dies bringt die neueste Version des .net Framework 4 in meinen Tests.

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

Damit können Sie den Befehl auf dem Remote-Computer aufrufen:

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

Was diese Möglichkeit mit ADModule und Namenskonventionspräfix einrichtet:

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