Que serait un script PowerShell pour renvoyer des versions du .NET Framework sur une machine?

Ma première hypothèse est quelque chose impliquant WMI. Y a-t-il quelque chose de mieux?

Il devrait s'agir d'une seule ligne pour ne renvoyer que la dernière version pour chaque installation de .NET [sur chaque ligne].

Si vous comptez utiliser le registre, vous devez recurse pour obtenir la version complète du Framework 4.x. Les réponses précédentes renvoient à la fois le numéro racine de mon système pour .NET 3.0 (où les numéros WCF et WPF, qui sont imbriqués sous 3.0, sont plus élevés - je ne peux pas l'expliquer), et ne parviennent pas à renvoyer quoi que ce soit pour 4.0. .

EDIT: Pour .Net 4.5 et plus, cela a légèrement changé à nouveau, donc il y a maintenant un bel article MSDN ici expliquant comment convertir la valeur Release en un numéro de version .Net, c'est une épave totale de train :-(

Cela me semble correct (notez qu'il produit des numéros de version séparés pour WCF et WPF sur 3.0. Je ne sais pas de quoi il s'agit). Il génère également Client et Full sur 4.0 (si vous les avez tous deux installés):

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

Sur la base de l'article MSDN, vous pouvez créer une table de recherche et renvoyer le numéro de version du produit marketing pour les versions après 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

En fait, comme je continue à devoir mettre à jour cette réponse, voici un script pour générer le script ci-dessus (avec un peu plus) à partir de la source de démarquage de cette page Web. Cela va probablement casser à un moment donné, donc je garde la copie actuelle ci-dessus.

# 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

Cette réponse ne renvoie pas 4.5 si cela est installé. La réponse ci-dessous de @Jaykul et l'utilisation de recurse le font.

Ajout du support v4.8 au 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

Vous donne une instance de Versionpour le CLR que la copie actuelle de PSH utilise (comme documenté ici ).

Syntaxe correcte:

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

La GetSystemVersionfonction renvoie une chaîne comme celle-ci:

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

ou comme ça

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

$PSVersionTableest un objet en lecture seule. La propriété CLRVersion est un numéro de version structuré comme celui-ci:

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

J'ai trouvé cela grâce à la complétion des onglets dans PowerShell pour osx:

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

Il n'y a pas de moyen fiable de le faire pour toutes les plates-formes et architectures à l'aide d'un simple script. Si vous souhaitez apprendre à le faire de manière fiable, commencez par le billet de blog Exemple de code de détection .NET Framework mis à jour qui effectue une vérification plus approfondie .

Reportez-vous à la page Script pour savoir quelles versions de .NET sont installées sur les postes de travail distants .

Le script peut être utile pour trouver la version .NET de plusieurs machines sur un réseau.

Belle solution

Essayez d'utiliser le module téléchargeable DotNetVersionLister (basé sur les informations du registre et une table de recherche de version à version marketing).

Qui serait utilisé comme ceci:

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 comme ceci si vous voulez juste le tester pour un framework .NET> = 4. * :

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

Mais cela ne fonctionnera pas (installation / importation) par exemple avec PS v2.0 ( Win 7 , norme Win Server 2010 ) en raison d'incompatibilité ...

Motivation pour les fonctions «héritées» ci-dessous

(Vous pouvez sauter la lecture de ceci et utiliser le code ci-dessous)

Nous avons dû travailler avec PS 2.0 sur certaines machines et n'avons pas pu installer / importer le DotNetVersionLister ci-dessus .
Sur d'autres machines, nous voulions mettre à jour (à partir de PS 2.0 ) vers PS 5.1 (qui à son tour nécessite .NET Framework> = 4.5 ) à l'aide de deux fichiers personnalisés Install-DotnetLatestCompanyet Install-PSLatestCompany.
Pour bien guider les administrateurs tout au long du processus d'installation / de mise à jour, nous devrons déterminer la version .NET dans ces fonctions sur toutes les machines et versions PS existantes.
Ainsi, nous avons également utilisé les fonctions ci-dessous pour les déterminer de manière plus sûre dans tous les environnements ...

Fonctions pour les anciens environnements PS (par exemple PS v2.0 )

Ainsi, le code suivant et les exemples d'utilisation ci-dessous (extraits) sont utiles ici (basés sur d'autres réponses ici):

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

Exemple d'utilisation:

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

Pas beau. Certainement pas joli:

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

Cela peut ou non fonctionner. Mais en ce qui concerne la dernière version, cela devrait être assez fiable, car il y a essentiellement des dossiers vides pour les anciennes versions (1.0, 1.1) mais pas pour les plus récentes - ceux-ci n'apparaissent qu'une fois le framework approprié installé.

Pourtant, je soupçonne qu'il doit y avoir un meilleur moyen.

Si vous avez installé Visual Studio sur votre ordinateur, ouvrez l'invite de commande Visual Studio Developer et tapez la commande suivante: clrver

Il répertorie toutes les versions installées de .NET Framework sur cette machine.

Voici mon avis sur cette question à la suite de la documentation 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.' }
    }
)"

Cet exemple fonctionne avec toutes les versions de PowerShell et fonctionnera à perpétuité car 4.8 est la dernière version de .NET Framework.

Voici l'idée générale:

Obtenez les éléments enfants dans le répertoire .NET Framework qui sont des conteneurs dont les noms correspondent au modèle v number dot number . Triez-les par nom décroissant, prenez le premier objet et renvoyez sa propriété name.

Voici le 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

J'essaierais celui-ci dans PowerShell: a fonctionné pour moi!

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

Je ne suis pas au courant de ma syntaxe PowerShell, mais je pense que vous pouvez simplement appeler System.Runtime.InteropServices.RuntimeEnvironment.GetSystemVersion () . Cela renverra la version sous forme de chaîne (quelque chose comme v2.0.50727, je pense).

Ceci est un dérivé de l'article précédent, mais cela obtient la dernière version du framework .net 4 dans mes tests.

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

Ce qui vous permettra d'invoquer la commande sur une machine distante:

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

Ce qui met en place cette possibilité avec ADModule et le préfixe de convention de dénomination:

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