Script PowerShell pour renvoyer des versions de .NET Framework sur une machine?


182

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].


7
Une machine peut (et aura) plusieurs versions du Fx. Comment voulez-vous gérer cela? Et puis il y a le désordre Fx2 .. Fx3.5SP1. Quelle version voulez-vous entendre?
Henk Holterman

Je suppose qu'il serait nécessaire de renvoyer le numéro de version complet pour chaque installation.
MattUebel

1
N'y a-t-il pas un moyen de le faire via WMI?
Mark Richman

Vous avez demandé PowerShell, j'ai fait quelque chose pour C # (application console). Si cela vous intéresse, la voici ...
Matt

C'est vraiment incroyable qu'il n'y ait pas quelque chose comme:asp.net -v
Altimus Prime

Réponses:


354

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

C'est exactement ce que je recherche également, mais j'ai du mal à comprendre ce que cela fait exactement. D'après ce que j'ai compris, il est envoyé au registre du NPD et fait une recherche récursive dans chaque dossier qui correspond à l' '^(?!S)\p{L}'expression régulière et obtient les informations sur la version et la version. Quelle est exactement cette expression régulière essayant de qualifier?
Johnrad

2
@Johnrad PSChildNameest le nom de feuille de la clé de registre. \p{L}est le caractère quelconque de la catégorie Unicode "lettre". (?!S)est un regard négatif autour, et ^est le début de la chaîne. Il faut donc commencer par une lettre autre que S. Donc, si vous considérez uniquement ASCII, c'est la même chose que $_.PSChildName -cmatch '^[A-RT-Za-z]'(notez le -cmatch). Il trouve donc des clés dont le nom commence par une lettre autre que S. Je n'ai aucune idée de la raison pour laquelle vous vous souciez du non-ASCII si vous filtrez les noms commençant par S... Certainement avec vous, c'est si déroutant.
jpmc26

1
Maintenant, je suis plus confus sur ce que diable Get-ItemProperty -name Version,Release -EA 0fait. Je sais que -EA 0c'est la même chose que -ErrorAction SilentlyContinue, mais quel effet aurait Get-ItemProperty -name Version,Release-il en lui transmettant tous les résultats? Il ne semble pas supprimer les variables de l'objet, car d'autres sont utilisées dans les commandes ultérieures du pipeline. Exécute-t-il une erreur lorsque le nom Versionou Releaseest absent de la clé, puis transmet les objets là où il a réussi à la commande suivante du pipeline?
jpmc26

3
Le Get-ChildItem renvoie TOUTES les sous-clés de Registre (les sous-dossiers, si vous voulez). Get-ItemProperty renvoie les valeurs (en particulier: "Version" et "Release") - nous ignorons les erreurs car nous ne nous soucions pas des dossiers qui n'ont pas ces valeurs. Donc oui, en gros, nous trouvons CHAQUE sous-dossier, puis recherchons Version ou Release (tous les dossiers sans l'un ou les deux sont ignorés).
Jaykul

3
Impressionnant! J'ai seulement modifié la (?!S)clause pour (?![SW])exclure davantage les entrées "Windows *". Cela peut également être fait (?=[vCF])car les seules clés qui nous intéressent vraiment sont les racines de la version et les clés "Complète" et "Client" pour .NET 4.0+. ;)
Chiramisu

27
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.


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

pour moi, la réponse est maintenant au top donc voici un lien vers elle :-): stackoverflow.com/a/3495491/1747983
Tilo

1
Après avoir installé .NET 4.7.1 sur Windows 10, cela renvoie toujours la v4.0.
Matt

24

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

21
[environment]::Version

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


3
J'ai .NET 4 installé mais PowerShell n'utilisera que le runtime 2.0. Ce n'est donc pas vraiment utile ici.
Joey

@Johannes: Voir le commentaire sur votre Q, vous devez être explicite sur ce que vous voulez.
Richard

9
Pour Powershell 2.0, vous pouvez également utiliser $PSVersionTablepour rechercher la version du CLR PowerShell sur lequel s'exécute.
Keith Hill

6
Et les versions supérieures? J'ai .NET 4.7.1 maintenant, et le script renvoie toujours 4.0.30319 Rev.42000.
Matt

@Matt, vous devrez traduire la partie mineure de la version ... et notez qu'en fonction de ce qui est défini dans la configuration de Powershell, il se peut qu'il n'utilise pas la dernière version mineure / corrective.
Richard

13

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   

1
J'ai essayé ça sur win8, ça ne retourne rien. Sous Windows 7, il renvoie 2 alors que 4.5.1 est déjà installé. Je ne sais pas pourquoi ce n'est pas utilisable sur les nouvelles plates-formes. Sur win sesrver 2008, cela fonctionne.
max

La première option fonctionne sur mon environnement Windows 8, 64 bits. La deuxième option fonctionne, mais je pense que cela montre simplement la version .NET dans laquelle l'instance actuelle de PowerShell s'exécute, qui est presque toujours la dernière. (Edit: Peut-être qu'ils le font tous les deux.)
Vimes

pareil ici. sous Windows 7, j'ai à la fois .net 2.0 et 4.0 mais la commande ne montre que v2.0.50727. Utilisez l'approche de Jaykul.
max

La version Clr n'égale pas la version du framework, 4+ frameworks sont tous basés sur 4 clr
janv8000

Et les versions supérieures? J'ai .NET 4.7.1 maintenant, et le script renvoie toujours 4.0.30319 Rev.42000.
Matt

11

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


1
Oui, il renvoie .NET Framework 4.7.2558.0 - mais comment distinguer 4.7 de 4.7.1 (j'ai 4.7.1 sur ma machine Windows 10).
Matt

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



2

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

Pour ne pas voir les horaires, utilisez(Get-DotNetVersion -LocalHost -nosummary).">=4.x"
ΩmegaMan

@ ΩmegaMan: merci - a mis à jour votre bonne recommandation dans la réponse ci-dessus :)
Andreas Dietrich

1

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.


Vous devez filtrer un peu plus, "V [.0-9] +" devrait limiter la correspondance aux dossiers .NET (j'ai quelques autres dossiers là-bas). Et puis vérifiez qu'il y a une vraie installation ... WMI sur les composants installés pourrait être plus facile.
Richard

Hm, c'est vrai ... sur cette machine, il y a aussi quelques autres dossiers - je n'avais qu'un tas d'autres fichiers sur mon autre machine. Toute cette réponse était plus un cas de «fonctionne pour moi», cependant. Je suis sûr qu'il existe un moyen fiable et prévu d'obtenir ces informations.
Joey

6
psake (outil d'automatisation de construction) adopte une approche similaire et l'utilise avec succès (ou du moins personne ne l'a changé à cause d'un problème). Mais c'est vrai qu'ils n'ont pas besoin de la version complète du framework ... Pour mon ordinateur, cela se rapproche:ls $Env:windir\Microsoft.NET\Framework | ? { $_.PSIsContainer -and $_.Name -match '^v\d.[\d\.]+' } | % { $_.Name.TrimStart('v') }
stej

De tous les one-liners dans les réponses, celui fourni par stej est le plus propre et fonctionne comme prévu. Si c'était une réponse, j'aurais voté pour.
Bratch

Malheureusement, ce n'est pas fiable. J'ai .NET 4.7.1 maintenant, et le script renvoie
Matt

0

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.


Cette commande obtient la version CLR, pas la version .NET Framework - qui est différente.
user11909 le

0

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.


-1

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'ai 4.6.1 installé mais votre script renvoie la v4.0.30319
rob

Cela ne fonctionne pas sur ma machine (j'ai installé 4.7.1). Il imprime v4.0.30319
Matt

-1

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

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


Cela ne vous dit pas la vérité. Le numéro de version y sera indiqué, par exemple 4.7.03056 lorsque la version du produit est 4.7.2
Jaykul

-2

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).


2
Pour le runtime en cours d'exécution, pas nécessairement le dernier installé.
Joey

Pour le PowerShell, la syntaxe correcte est [System.Runtime.InteropServices.RuntimeEnvironment]::GetSystemVersion():, mais elle renvoie simplement la v4.0.30319, même si la v4.6 est installée dans mon cas.
Matt

@matt 4.0.30319 est la version CLR de .Net Framework 4.0 à .Net Framework 4.7.1. Ainsi, votre framework v4.6 utilise réellement 4.0.30319 comme version CLR. Notez que seule la partie Révision de la Version fait la différence entre tous les Frameworks .Net. Voir aussi: Versions et dépendances de .NET Framework - Microsoft Docs
walterlv

@walterlv - Merci pour le lien. Oui, j'en suis conscient. Microsoft a fait une grosse erreur en faisant cela, il n'est pas facile de se connecter à distance à un serveur et de savoir quelle version .net y est réellement installée. Un autre gros casse-tête pour les administrateurs et les développeurs.
Matt

Et cela pourrait également aider: Microsoft: Comment déterminer les versions et les niveaux de service pack de .NET Framework . Cela montre également à quel point il est devenu compliqué de savoir ce qui est exactement installé sur votre machine ... :-(
Matt

-2

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
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.