Question PowerShell et le framework dotnet 3.5

Comme l'usage de Out-GridView nécessite le framework 3.5, on peut utiliser des classes intéressantes.
Par exemple la classe ObservableCollection qui représente une collection de données dynamiques, fournit des notifications lorsque des éléments sont ajoutés, supprimés ou lorsque la liste entière est actualisée.

[code:1] #Nécessite le framework 3.5, si Out-GridView fonctionne alors c'est OK.
Add-Type -AssemblyName Windowsbase
#Représente une collection de données dynamiques qui fournit des notifications
# lorsque des éléments sont ajoutés, supprimés, remplacés, déplacés
#ou lorsque la liste entière est actualisée.
$ObservableCol = new-object System.Collections.ObjectModel.ObservableCollection[Int]
#Classe générique, accés aux membres via psbase
$ObservableCol.psbase|gm -type event

Function Write-Detail($EventArgs,$Comment)
{
Write-Warning $Comment
#NewItems : Obtient la liste des nouveaux éléments impliqués dans la modification.
Write-host \"Liste $($EventArgs.NewItems)\"
#NewStartingIndex : Obtient l'index auquel la modification s'est produite.
Write-host \"Index $($EventArgs.NewStartingIndex)\"
#OldItems : Obtient la liste des éléments affectés par une action Replace, Remove ou Move.
Write-host \"Eléments affectés $($EventArgs.OldItems)\"
#OldStartingIndex : Obtient l'index sur lequel une action Move, Remove ou Replace s'est produite.
Write-host \"Index de l'éléments affecté $($EventArgs.OldStartingIndex)\"
}

Register-ObjectEvent $ObservableCol CollectionChanged -SourceIdentifier ChangeCollection –Action {
Write-Detail $EventArgs $EventArgs.Action }

# Switch ($EventArgs.Action) # Obtient l'action qui a déclenché l'événement.
# {
# # Un ou plusieurs éléments ont été ajoutés à la collection.
# \"Add\" {
# Write-Detail $EventArgs \"Add\"
# }
# # Un ou plusieurs éléments ont été supprimés de la collection.
# \"Remove\" {
# Write-Detail $EventArgs \"Remove\"
# }
# # Un ou plusieurs éléments ont été remplacés dans la collection.
# \"Replace\" {
# Write-Detail $EventArgs \"Replace\"
# }
# # Un ou plusieurs éléments ont été déplacés dans la collection.
# \"Move\" {
# Write-Detail $EventArgs \"Move\"
# }
# # Le contenu de la collection a changé de manière significative.
# \"Reset\" {
# Write-Detail $EventArgs \"Reset\"
# }
# }
# }[/code:1]
Quelques exemples d'utilisation et des événements générés
[code:1]
$ObservableCol.Add(-99)
# AVERTISSEMENT : Add
# Liste -99
# Index 0
# Eléments affectés
# Index de l'éléments affecté -1

$ObservableCol[0]=-59
# AVERTISSEMENT : Replace
# Liste -59
# Index 0
# Eléments affectés -99
# Index de l'éléments affecté 0

$ObservableCol.Add(10)
# AVERTISSEMENT : Add
# Liste 10
# Index 1
# Eléments affectés
# Index de l'éléments affecté -1

\"$ObservableCol\"
# -59 10

$ObservableCol.Insert(1,6)
# AVERTISSEMENT : Add
# Liste 6
# Index 1
# Eléments affectés
# Index de l'éléments affecté -1

\"$ObservableCol\"
# -59 6 10

$ObservableCol.Move(0,($ObservableCol.Count-1))
# AVERTISSEMENT : Move
# Liste -59
# Index 2
# Eléments affectés -59
# Index de l'éléments affecté 0

\"$ObservableCol\"
# 6 10 -59

$ObservableCol.Remove(6)
# True
# AVERTISSEMENT : Remove
# Liste
# Index -1
# Eléments affectés 6
# Index de l'éléments affecté 0

$ObservableCol.Remove(10)
# True
# AVERTISSEMENT : Remove
# Liste
# Index -1
# Eléments affectés 10
# Index de l'éléments affecté 0

$ObservableCol.Remove(-59)
# True
# AVERTISSEMENT : Remove
# Liste
# Index -1
# Eléments affectés -59
# Index de l'éléments affecté 0

\"$ObservableCol\"
# ras

$ObservableCol.Clear()
# AVERTISSEMENT : Reset
# Liste
# Index -1
# Eléments affectés
# Index de l'éléments affecté -1

\"$ObservableCol\"
#ras
[/code:1]<br><br>Message édité par: Laurent Dardenne, à: 2/06/10 19:52

La classe hashset propose des opérations d'ensembles comme l'union, l'intersection ou la différence symétrique.

Voici une conversion d'une partie des exemples du tutoriel :
[code:1]
$hset = new-object System.Collections.Generic.HashSet[int]
#Les ajouts suivants renvoient tous $true
1..4|% {$hset.Add($_)}
#Les ajouts suivants renvoient tous $false
#car les valeurs existent déjà dans la collection.
1..4|% {$hset.Add($_)}

#UNION
#Constructeur, cast le tableau en un tableau d'entier et émet un
#seul objet, le tableau
$hset = new-object System.Collections.Generic.HashSet[int]( ,[int[]]@(1,2,3,4) )
$hset2 = new-object System.Collections.Generic.HashSet[int]( ,[int[]]@(1,4,5,7) )

$hset.UnionWith($hset2);
\&quot;$hset\&quot;
#hset contient maintenant 1,2,3,4,5,7

$liste = new-object System.Collections.Generic.List[int]( ,[int[]]@(1,5,11,8,3) )
$hset.UnionWith($liste);
\&quot;$hset\&quot;
#$hset contient maintenant 1,2,3,4,5,7,11,8

[int[]] $tab = @(2, 7, 15, 0)
$hset.UnionWith($tab);
\&quot;$hset\&quot;
#$hset contient maintenant 1,2,3,4,5,7,11,8,15,0

#INTERSECTION
$hset = new-object System.Collections.Generic.HashSet[int]( ,[int[]]@(1,3,5,7,8) )

#Methode, la présence de la virgule
# n'est pas nécessaire.
$hset.IntersectWith([int[]]@(1,6,12,8,3))
\&quot;$hset\&quot;
#$hset contient maintenant 1,3,8

#LA DIFFÉRENCE
$hset = new-object System.Collections.Generic.HashSet[int]( ,[int[]]@(1,3,5,7,8) )
$hset.ExceptWith( [int[]]@(3,7,9) )
\&quot;$hset\&quot;
#$hset contient maintenant 1,5,8

#LA DIFFÉRENCE SYMÉTRIQUE
# La méthode SymmetricExceptWith modifie le HashSet pour qu'il contienne
# tous les éléments contenus par
# soit la classe HashSet,
# soit la collection passée en paramètre, mais pas les deux.

$hset = new-object System.Collections.Generic.HashSet[int]( ,[int[]]@(1,3,5,7,8) )
$hset.SymmetricExceptWith([int[]]@(2,3,8,9))
\&quot;$hset\&quot;
#$hset contient maintenant 1,5,7,2,9

#SOUS-ENSEMBLE
# La méthode IsSubsetOf permet de savoir si un HashSet est un sous-ensemble d'un ensemble donné.
$hset = new-object System.Collections.Generic.HashSet[int]( ,[int[]]@(1,3,5 ))
$isSubsetOf = $hset.IsSubsetOf([int[]]@(1,2,3,8,9,5));
$isSubsetOf
#$isSubsetOf vaut vrai car $hset est un sous-ensemble du tableau

$hset = new-object System.Collections.Generic.HashSet[int]( ,[int[]]@(1,3,5,4))
$isSubsetOf = $hset.IsSubsetOf([int[]]@(1,3,6,5 ))
$isSubsetOf
#$isSubsetOf vaut faux car $hset n'est pas un sous-ensemble du tableau

$hset = new-object System.Collections.Generic.HashSet[int]( ,[int[]]@(1,3,5,6))
$isSubsetOf = $hset.IsSubsetOf([int[]]@(1,3,6,5))
$isSubsetOf
#$isSubsetOf vaut vrai car $hset est un sous-ensemble du tableau

#SUR-ENSEMBLE
....
[/code:1]
Le portage du chapitre XI, L'unicité dans un HashSet, nécessite un peu de réflexions

Richard Lazaro écrit:

L'observable Collection est très utile lors de la création d'interface en WPF.

De mon coté, je pensais l'utiliser sous PS plutot avec des jobs, mais je n'ai pas encore trouvé d'exemple convainquant.

Voici une possible adaptation du chapitre XI, L'unicité dans un HashSet,:
[code:1]
Add-type @\&quot;
//Inspiré de huddledmasses.org/custom-icomparers-in-p...and-add-type-for-v1/
using System;
using System.Collections.Generic;
using System.Management.Automation;
public sealed class ScriptBlockEqualityComparer: IEqualityComparer&lt;System.Management.Automation.PSObject&gt;
{
ScriptBlock _EqualityComparer;
ScriptBlock _GetHashCode;

//Scriptblock du code de la méthode Equals
public ScriptBlock EqualityComparerScript
{
get { return _EqualityComparer; }
set { _EqualityComparer = value; }
}

//Scriptblock du code de la méthode GetHashCode
public ScriptBlock GetHashCodeScript
{
get { return _GetHashCode; }
set { _GetHashCode = value; }
}

public ScriptBlockEqualityComparer(ScriptBlock EqualityComparer,ScriptBlock GetHashCode)
{
EqualityComparerScript = EqualityComparer;
GetHashCodeScript = GetHashCode;
}

public bool Equals(PSObject x, PSObject y)
{ //Le code contenu dans le scriptblock ne doit pas faire d'appel de création d'exception
try {
return (bool)EqualityComparerScript.Invoke(x, y)[0].BaseObject;
} catch(Exception ex) {
throw new InvalidOperationException(\&quot;IEqualityComparer: Equals Script failed to return an boolean.\&quot;, ex);
}
}

public int GetHashCode(PSObject p)
{ //Le code contenu dans le scriptblock ne doit pas faire d'appel de création d'exception
try {
return (int)GetHashCodeScript.Invoke(p)[0].BaseObject;
} catch(Exception ex) {
throw new InvalidOperationException(\&quot;IEqualityComparer: GetHashCode Script failed to return an integer.\&quot;, ex);
}
}

}
\&quot;@


$p1 = new-object PSObject @{Id = 1;Nom = \&quot;Toto\&quot; } #une 1ère personne
$p2 = new-object PSObject @{Id = 2;Nom = \&quot;Titi\&quot; } #une 2ème personne avec le même nom
$p3 = new-object PSObject @{Id = 2;Nom = \&quot;Titi\&quot; } #la même personne que $p2
$p4 = new-object PSObject @{Id = 3;Nom = \&quot;Loulou\&quot; } #une 3ème personne avec un nom et un id différent
$p5 = new-object PSObject @{Id = 1;Nom = \&quot;Riri\&quot; } #la même ID que $p1

$sbEquals={
#Le code contenu dans le scriptblock ne doit pas faire d'appel de création d'exception
Param([PSObject]$pso1, [PSObject]$pso2)
#deux personnes sont égales si elles ont le même Id
return ($pso1.Id -eq $pso2.Id);
}

$sbGetHashCode={
#Le code contenu dans le scriptblock ne doit pas faire d'appel de création d'exception
#note msdn :
# l'implémentation de la méthode GetHashCode fournie par la classe String retourne
# des codes de hachage uniques pour des valeurs de chaîne uniques.
# Par conséquent, deux objets String retournent le même code de hachage
# s'ils représentent la même valeur de chaîne.
Param([PSObject]$pso)
return ($pso.Id.GetHashCode()+$pso.Nom.GetHashCode())
}

$listePersonnes = new-object System.Collections.Generic.HashSet[PSObject]((new-object ScriptBlockEqualityComparer($sbEquals,$sbGetHashCode)))
[void]$listePersonnes.Add($p1)
[void]$listePersonnes.Add($p2)
[void]$listePersonnes.Add($p3)
[void]$listePersonnes.Add($p4)
[void]$listePersonnes.Add($p5)

$listePersonnes
$listePersonnes.count
#erreur
$p6 = new-object PSObject @{Id = $null;Nom = \&quot;Riri\&quot; }
[void]$listePersonnes.Add($p6)
#erreur
$p7 = new-object PSObject @{Id = 7;Nom =$null }
[void]$listePersonnes.Add($p7)
#Ok
[void]$listePersonnes.Add($null)
$listePersonnes.count
[/code:1]