Question [Astuce]Cmt savoir si 1 objet est une collection ?

$Tab=@(1,2)
$I=10
#Est-ce que l'object est une collection ? (On teste si l'objet implémente l'interface IEnumerable)
$Tab -is [System.Collections.IEnumerable]
$I -is [System.Collections.IEnumerable]

 #Test si $Str implémente System.IEquatable<String>
$Str="Test"
$Str -is [System.IEquatable``1[System.String]]
#True
#Test si $Str implémente System.IEquatable<Int32>
$Str -is [System.IEquatable``1[System.Int32]]
#False
#Liste des interfaces supportées par le type de la variable $Str
$Str.GetType().GetInterfaces()

#Collection indexée
[system.array].GetInterfaces()
#Collection indexé
[object[]].GetInterfaces()
#Collection sans index
[System.Management.ManagementObjectCollection].GetInterfaces()

function Test-AccessedByIndex($Object)
{ #Renvoi true si $Object est une collection accessible par un index

    if ($object -is [type])
    {
      #Object =[System.Array]
      $Interfaces=$Object.GetInterfaces()
    }
    else
    {
      #Object ="String"
      $Interfaces=$Object.GetType().GetInterfaces()
    }
    #on force le résultat en un tableau
    @($Interfaces|Where-Object {$_.name -match "IList"}).count -gt 0
}

$a=@(1,2,3)
Test-AccessedByIndex $a
#True

Test-AccessedByIndex [system.Array]
#False

Test-AccessedByIndex ([system.Array] -as [type])
#True

#ou
Test-AccessedByIndex ("system.Array" -as [type])
$T="system.Array"
Test-AccessedByIndex ($T -as [type])

[System.array],[object[]],[System.Management.ManagementObjectCollection]|
% { "Le type {0} est-il une collection indexée ? {1}" -F $_.Name, (Test-AccessedByIndex $_)}
# Le type Array est-il une collection indexée ? True
# Le type Object[] est-il une collection indexée? True
# Le type ManagementObjectCollection est-il une collection indexée ? False

${Function:Test-GenericIEnumerable}=.{
    #On recherche le type ouvert de l'interface générique IEnumerable
    $GenericIEnumerable=[Type]'System.Collections.Generic.IEnumerable`1'

    Return {
     #La variable $InputObject implémente-t-elle l'interface générique IEnumerable ?
      param(
        [ValidateNotNull()]
        $InputObject
      )
        foreach ($Interface in $InputObject.GetType().GetInterfaces())
        {
           if ($Interface.IsGenericType)
           {
                 #On suppose une seule implémentation de l'interface générique IEnumerable (https://stackoverflow.com/a/7852650)
               if ($Interface.GetGenericTypeDefinition() -eq $GenericIEnumerable)
               {return $true}
           }
        }
        return $false
    }.GetNewClosure()
}

$script:GenericIEnumerable=[Type]'System.Collections.Generic.IEnumerable`1'

Function Test-GenericIEnumerable{
#La variable $InputObject implémente-t-elle l'interface générique IEnumerable ?
 param(
   [ValidateNotNull()]
  $InputObject
 )

 foreach ($Interface in $InputObject.GetType().GetInterfaces())
 {
    if ($Interface.IsGenericType)
    {
          #On suppose une seule implémentation de l'interface générique IEnumerable (https://stackoverflow.com/a/7852650)
        if ($Interface.GetGenericTypeDefinition() -eq $GenericIEnumerable)
        {return $true}
    }
  }
    return $false
}

[void][Reflection.Assembly]::LoadWithPartialName("System.Data.DataSetExtensions");
$Dt = New-Object System.Data.DataTable
[void]$Dt.Columns.Add( 'C1')
[void]$Dt.Columns.Add( 'C2')
[void]$Dt.Rows.Add( '1','2')
[void]$Dt.Rows.Add( 'Y','Z')

$Dt.Rows -is [System.Collections.IEnumerable]
Test-GenericIEnumerable $Dt.Rows

$A = New-Object System.Collections.ArrayList
$A.Addrange((1..5))
$A -is [System.Collections.IEnumerable]

Test-GenericIEnumerable $A

$H=@{'A'=1;'B'=2}
$H -is [System.Collections.IEnumerable]

Test-GenericIEnumerable $H

#----

$T=1..5
$T -is [System.Collections.IEnumerable]

Test-GenericIEnumerable $T

$SL = new-object 'system.collections.Generic.SortedList[String,Int]'
$SL.Add("Un", 1)
$SL.Add("Deux", 2)
$SL.Add("Trois", 3)

$SL -is [System.Collections.IEnumerable]

Test-GenericIEnumerable $SL

Import-Module ExtensionMethod
 #recherche les méthodes d'extension LINQ génériques ou pas
$t=[Linq.Enumerable].Assembly.ExportedTypes|Find-ExtensionMethod

#On recherche les méthodes d'extension 'Where'
$l=$t|? {$_.IsGenericMethod -and $_.name -eq 'Where'}

#Ici l'élément 2 est la méthode Where envoyant un IEnumerable`1
"$($l[2])"
#System.Collections.Generic.IEnumerable`1[TSource] Where[TSource](System.Collections.Generic.IEnumerable`1[TSource], System.Func`2[TSource,System.Boolean])

#Teste le type et pas l'objet Method
$l[2].ReturnType.GetGenericTypeDefinition() -eq $GenericIEnumerable
#True

$Methods=Foreach ($Method in $t)
{ 
    $ReturnType=$Method.ReturnType
    if ($Method.IsGenericMethod  -and $ReturnType.IsGenericType -and $ReturnType.GetGenericTypeDefinition() -eq $GenericIEnumerable)
    {Write-Output $Method}
}
$Groups=$Methods|Group-Object -Property Name
$Groups[0].Group.foreach({$_.tostring()})
#System.Collections.Generic.IEnumerable`1[TSource] Where[TSource](System.Collections.Generic.IEnumerable`1[TSource], System.Func`2[TSource,System.Boolean])
#System.Collections.Generic.IEnumerable`1[TSource] Where[TSource](System.Collections.Generic.IEnumerable`1[TSource], System.Func`3[TSource,System.Int32,System.Boolean])
$Groups