Script di PowerShell per restituire versioni di .NET Framework su una macchina?


182

Quale sarebbe uno script di PowerShell per restituire le versioni di .NET Framework su una macchina?

La mia prima ipotesi è qualcosa che coinvolge WMI. C'è qualcosa di meglio?

Dovrebbe essere un liner per restituire solo l'ultima versione per ogni installazione di .NET [su ogni riga].


7
Una macchina può (e avrà) più versioni di Fx. Come vuoi gestirlo? E poi c'è il pasticcio Fx2 .. Fx3.5SP1. Quale versione vuoi ascoltare?
Henk Holterman,

Suppongo che sarebbe necessario restituire il numero di versione completo per ogni installazione.
MattUebel,

1
Non c'è un modo per farlo tramite WMI?
Mark Richman,

Hai chiesto PowerShell, ho realizzato qualcosa per C # (applicazione console). Se sei interessato, eccolo qui ...
Matt,

È davvero incredibile che non ci sia qualcosa di simile:asp.net -v
Altimus Prime il

Risposte:


354

Se si intende utilizzare il registro, è necessario ricorrere per ottenere la versione completa per il framework 4.x. Le risposte precedenti restituiscono entrambe il numero di root sul mio sistema per .NET 3.0 (dove i numeri WCF e WPF, che sono nidificati sotto 3.0, sono più alti - non posso spiegarlo), e non riescono a restituire nulla per 4.0 .. .

EDIT: per .Net 4.5 e versioni successive, questo è leggermente cambiato di nuovo, quindi ora c'è un bell'articolo MSDN che spiega come convertire il valore di rilascio in un numero di versione .Net, è un disastro totale del treno :-(

Questo mi sembra giusto (nota che genera numeri di versione separati per WCF e WPF su 3.0. Non so di cosa si tratti). Emette anche Client e Full su 4.0 (se li hai entrambi installati):

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

Sulla base dell'articolo MSDN, è possibile creare una tabella di ricerca e restituire il numero di versione del prodotto di marketing per le versioni successive alla 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

In effetti, dato che continuo ad aggiornare questa risposta, ecco uno script per generare lo script sopra (con un piccolo extra) dalla fonte di markdown per quella pagina web. Questo probabilmente si interromperà ad un certo punto, quindi mantengo la copia corrente sopra.

# 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 }}
"@

Anche questo è esattamente quello che cerco, ma faccio fatica a pensare a cosa sta facendo esattamente. Da quello che ho capito, sta uscendo nel registro NDP e cercando ricorsivamente in ogni cartella adatta al '^(?!S)\p{L}'regex e ottenendo le informazioni sulla versione e sulla versione. Cos'è esattamente l'espressione regolare che cerca di qualificarsi?
Johnrad,

2
@Johnrad PSChildNameè il nome foglia della chiave di registro. \p{L}è il carattere qualsiasi nella categoria "lettera" Unicode. (?!S)è uno sguardo negativo in giro, ed ^è l'inizio della stringa. Quindi deve iniziare con una lettera diversa da S. Quindi, se consideri solo ASCII, è lo stesso di $_.PSChildName -cmatch '^[A-RT-Za-z]'(nota il -cmatch). Quindi trova le chiavi in ​​cui il nome inizia con una lettera diversa da S. Non ho idea del perché ti interessi di non-ASCII se stai filtrando i nomi che iniziano con S... Sicuramente con te che sei così confuso.
jpmc26,

1
Ora sono più confuso su cosa diavolo Get-ItemProperty -name Version,Release -EA 0sta facendo. So che -EA 0è lo stesso di -ErrorAction SilentlyContinue, ma quale effetto avrebbe Get-ItemProperty -name Version,Releasese si eseguisse il piping di tutti i risultati? Non sembra eliminare alcuna variabile dall'oggetto, poiché altri vengono utilizzati nei comandi successivi nella pipeline. Viene eseguito, viene visualizzato un errore quando manca il nome Versiono Releasedalla chiave e quindi passa gli oggetti in cui è riuscito al comando successivo nella pipeline?
jpmc26,

3
Get-ChildItem restituisce TUTTE le sottochiavi del registro (le sottocartelle, se lo desideri). Get-ItemProperty restituisce i valori (in particolare: "Versione" e "Rilascio"): ignoriamo gli errori perché non ci importa delle cartelle che non hanno tali valori. Quindi sì, fondamentalmente troviamo OGNI sottocartella e quindi cerchiamo Versione o Rilascio (qualsiasi cartella senza una o entrambe quelle viene ignorata).
Jaykul,

3
Eccezionale! Ho modificato la (?!S)clausola solo (?![SW])per escludere ulteriormente le voci "Windows *". Questo può essere fatto anche (?=[vCF])dal momento che le uniche chiavi a cui teniamo davvero sono le versioni root e le chiavi "Full" e "Client" per .NET 4.0+. ;)
Chiramisu,

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

Questa risposta non restituisce 4.5 se è installato. La risposta di seguito da @Jaykul e l'utilizzo di recurse fa.


5
gci 'HKLM: \ SOFTWARE \ Microsoft \ NET Framework Setup \ NDP' | ordina pschildname -des | foreach-object {$ _. name; $ _. GetValue ("Versione");}
MattUebel,

per me la risposta è ora in cima quindi ecco un link ad esso :-): stackoverflow.com/a/3495491/1747983
Tilo

1
Avendo installato .NET 4.7.1 su Windows 10, questo restituisce ancora v4.0.
Matt,

24

Aggiunto supporto v4.8 allo 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" }
      }
    }
}

21
[environment]::Version

Ti dà un'istanza di Versionper il CLR che la copia corrente di PSH sta usando (come documentato qui ).


3
Ho installato .NET 4 ma PowerShell utilizzerà solo il runtime 2.0. Quindi non è di grande aiuto qui.
Joey,

@Johannes: vedi il commento sulla tua Q, devi essere esplicito su ciò che vuoi.
Richard,

9
Per Powershell 2.0, puoi anche utilizzare $PSVersionTableper trovare la versione di CLR su cui è in esecuzione PowerShell.
Keith Hill,

6
Che ne dici di versioni successive? Ora ho .NET 4.7.1 e lo script restituisce sempre 4.0.30319 Rev. 42000.
Matt

@Matt dovrai tradurre la parte minore della versione ... e nota che, a seconda di ciò che è impostato nella configurazione di Powershell, potrebbe non essere in uso l'ultima versione minore / patch.
Richard,

13

Sintassi corretta:

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

La GetSystemVersionfunzione restituisce una stringa come questa:

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

o così

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

$PSVersionTableè un oggetto di sola lettura. La proprietà CLRVersion è un numero di versione strutturato come questo:

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

1
Ho provato questo su Win8, non restituisce nulla. Su Windows 7, restituisce 2 mentre 4.5.1 è già installato. Non so perché questo non sia utilizzabile su nuove piattaforme. Su win sesrver 2008, funziona.
massimo

La prima opzione funziona su Windows 8, ambiente a 64 bit. La seconda opzione funziona, ma penso che mostri solo la versione .NET in cui è in esecuzione l'attuale istanza di PowerShell, che è quasi sempre l'ultima. (Modifica: forse lo fanno entrambi.)
Vimes

anch'io. su Windows 7 ho sia .net 2.0 che 4.0 ma il comando mostra solo v2.0.50727. Usa l'approccio di Jaykul.
massimo

La versione di Clr non è uguale alla versione del framework, 4+ framework sono tutti basati su 4 clr
janv8000,

Che ne dici di versioni successive? Ora ho .NET 4.7.1 e lo script restituisce sempre 4.0.30319 Rev. 42000.
Matt

11

Ho trovato questo attraverso il completamento della scheda in PowerShell per OSX:

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


1
Sì, restituisce .NET Framework 4.7.2558.0 , ma come si può distinguere 4.7 da 4.7.1 (ho 4.7.1 sul mio computer con Windows 10).
Matt,

1
[version]([Runtime.InteropServices.RuntimeInformation]::FrameworkDescription -replace '^.[^\d.]*','')
Rabash



2

Bella soluzione

Prova a utilizzare il modulo DotNetVersionLister scaricabile (basato su informazioni di registro e alcune tabelle di ricerca da versione a versione di marketing).

Quale sarebbe usato in questo modo:

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        :

O in questo modo se si desidera solo testarlo per alcuni framework .NET> = 4. * :

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

Ma non funzionerà (installa / importa) ad es. Con PS v2.0 ( Win 7 , Win Server 2010 standard) a causa dell'incompatibilità ...

Di seguito le motivazioni delle funzioni "legacy"

(Potresti saltare la lettura di questo e usare il codice qui sotto)

Abbiamo dovuto lavorare con PS 2.0 su alcune macchine e non è stato possibile installare / importare il DotNetVersionLister sopra .
Su altre macchine volevamo aggiornare (da PS 2.0 ) a PS 5.1 (che a sua volta necessita di .NET Framework> = 4.5 ) con l'aiuto di due società personalizzate Install-DotnetLatestCompanye Install-PSLatestCompany.
Per guidare bene gli amministratori attraverso il processo di installazione / aggiornamento, dovremmo determinare la versione .NET in queste funzioni su tutte le macchine e le versioni PS esistenti.
Quindi abbiamo usato anche le seguenti funzioni per determinarle in modo più sicuro in tutti gli ambienti ...

Funzioni per ambienti PS legacy (ad es. PS v2.0 )

Quindi il seguente codice e gli esempi di utilizzo (estratti) di seguito sono utili qui (sulla base di altre risposte qui):

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

Esempio di utilizzo:

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

Per non vedere i tempi usare(Get-DotNetVersion -LocalHost -nosummary).">=4.x"
ΩmegaMan il

@ ΩmegaMan: thx - aggiornata la tua buona raccomandazione nella risposta sopra :)
Andreas Dietrich

1

Non carino. Sicuramente non carino:

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

Questo potrebbe funzionare o meno. Ma per quanto riguarda l'ultima versione, questo dovrebbe essere abbastanza affidabile, poiché ci sono essenzialmente cartelle vuote per le vecchie versioni (1.0, 1.1) ma non quelle più recenti - quelle appaiono solo una volta installato il framework appropriato.

Tuttavia, sospetto che ci debba essere un modo migliore.


Devi filtrare un po 'di più, "V [.0-9] +" dovrebbe limitare la corrispondenza alle cartelle .NET (ho alcune altre cartelle lì). E poi controlla che ci sia una vera installazione ... WMI sui componenti installati potrebbe essere più semplice.
Richard,

Hm, giusto ... su questa macchina ci sono anche alcune altre cartelle - avevo solo un sacco di altri file sull'altra mia macchina. Tutta questa risposta è stata più che altro un caso di "funziona per me". Sono sicuro che esiste un modo affidabile e inteso per ottenere tali informazioni.
Joey,

6
psake (build automation tool) adotta un approccio simile e lo usa con successo (o almeno nessuno lo ha cambiato a causa di un problema). Ma è vero che non hanno bisogno della versione full framework ... Per il mio computer questo si avvicina:ls $Env:windir\Microsoft.NET\Framework | ? { $_.PSIsContainer -and $_.Name -match '^v\d.[\d\.]+' } | % { $_.Name.TrimStart('v') }
stej

Di tutti i one-liner nelle risposte, quello fornito da Stej è il più pulito e funziona come previsto. Se fosse una risposta, avrei votato a favore.
Bratch

Sfortunatamente, non è affidabile. Ora ho .NET 4.7.1 e lo script restituisce
Matt,

0

Se hai installato Visual Studio sul tuo computer, apri il Prompt dei comandi per gli sviluppatori di Visual Studio e digita il comando seguente: clrver

Elencherà tutte le versioni installate di .NET Framework su quella macchina.


Questo comando ottiene la versione CLR, non la versione .NET Framework, che è diversa.
user11909

0

Ecco la mia opinione su questa domanda che segue la documentazione di 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.' }
    }
)"

Questo esempio funziona con tutte le versioni di PowerShell e funzionerà in modo perpetuo poiché 4.8 è l'ultima versione di .NET Framework.


-1

Ecco l'idea generale:

Ottieni elementi figlio nella directory di .NET Framework che sono contenitori i cui nomi corrispondono al modello punto v numero punto numero . Ordinarli per nome decrescente, prendere il primo oggetto e restituire la proprietà name.

Ecco la sceneggiatura:

(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

Ho installato 4.6.1 ma il tuo script restituisce v4.0.30319
rob

Non funziona sulla mia macchina (ho installato 4.7.1). Esso stampa v4.0.30319
Matt

-1

Vorrei provare questo in PowerShell: ha funzionato per me!

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


Questo non ti dice la verità. Il numero della versione verrà indicato, ad esempio 4.7.03056 quando la versione del prodotto è 4.7.2
Jaykul,

-2

Non sono in sintonia con la mia sintassi di PowerShell, ma penso che potresti semplicemente chiamare System.Runtime.InteropServices.RuntimeEnvironment.GetSystemVersion () . Questo restituirà la versione come una stringa (qualcosa di simile v2.0.50727, penso).


2
Per il runtime attualmente in esecuzione, non necessariamente l'ultimo installato.
Joey,

Per PowerShell, la sintassi corretta è [System.Runtime.InteropServices.RuntimeEnvironment]::GetSystemVersion():, ma restituisce solo v4.0.30319, anche se la v4.6 è installata nel mio caso.
Matt

@matt 4.0.30319 è la versione CLR da .Net Framework 4.0 a .Net Framework 4.7.1. Quindi il tuo framework v4.6 effettivamente utilizza 4.0.30319 come versione CLR. Si noti che solo la parte Revision della versione è la differenza tra tutti i frame .Net. Vedi anche: Versioni e dipendenze di .NET Framework - Microsoft Docs
walterlv,

@walterlv - Grazie per il link. Sì, ne sono consapevole. Microsoft ha fatto un grosso errore nel farlo, non è facile connettersi in remoto a un server e scoprire quale versione .net è effettivamente installata lì. Un altro grosso mal di testa per amministratori e sviluppatori.
Matt,

E questo potrebbe aiutare anche: Microsoft: come determinare le versioni e i livelli di service pack di .NET Framework . Mostra anche quanto sia diventato complicato scoprire esattamente cosa è installato sul tuo computer ... :-(
Matt,

-2

Questo è un derivato del post precedente, ma nei miei test ottiene l'ultima versione di .net framework 4.

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

Che ti consentirà di invocare il comando sul computer remoto:

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

Che imposta questa possibilità con ADModule e il prefisso della convenzione di denominazione:

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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.