Question [Fonction]Enregistrement de ressource

Cette fonction enregistre dans un fichier les ressources précédement créé par via ConvertTo-Resource.
[code:1]
################################################################################
#
# Nom : Create-Resource.ps1
# Ecrit des ressources dans un nouveau fichier.
# Les types ayant un traitement particulier sont les types string et byte[].
# Tous les autres types sont traités comme étant du type object.
#
# On peut avoir un fichier de ressources valide mais \"vide\".
# $null|Create-Resource (join-path $pwd Tst1.resources)
# Version : 0.1
# Auteur : Laurent Dardenne
# Date : le 27/05/2008
#
################################################################################
Function Create-Resource([string] $FileName=$(throw \"Le nom de fichier doit être renseigné.\"«»))
{

begin
{
function InsertResource($Item)
{
$script:IndexObjet++
if ($Item -eq $null)
# Dans ce cas on ne peut rien faire, au suivant...
{
$LocalInvocation=[System.IO.Path]::GetFilenameWithoutExtension( $MyInvocation.ScriptName )
Write-Warning (\"[{0}:{1}] {2}\" -F ($LocalInvocation,$MyInvocation.InvocationName,,\"Un objet est à `$Null.\"«»))
}
else
{
write-Debug (\"`tIndexObjet : {0}\" -F $IndexObjet)
write-Debug (\"`tType, Guid : {0} {1}\" -F ($Item.GetType(),$Item.ClassGuid))
if (($Item -is [System.Management.Automation.PSObject] ) -and ($Item.ClassGuid -eq \"18e85e6f-0982-4b8e-b74f-0a096fc44436\"«») )
{
if (($Item.Name -eq $null) -or ($Item.Name -eq [String]::Empty))
{
Write-Error (\"Le nom de la ressource doit être renseignée pour l'objet suivant: {0}\" -f $Item)
$Writer.Close()
#Erreur fatale
Break
}
write-Debug (\"`tNom de la ressource : {0}\" -F $Item.Name)
#Détermine la méthode AddResource à appeler d'après le type de la ressource
Switch (&$sbGetTypeName $Item)
{
\"string\" {
write-Debug \"`tCall AddResource string\"
$Writer.AddResource($Item.Name, [string] $Item.Value)
}
\"byte[]\" {
write-Debug \"`tCall AddResource byte[]\";
$Writer.AddResource($Item.Name, [Byte[]] $Item.Value)
}
default {
write-Debug \"`tCall AddResource object : $_\"
#Un type objet n'est pas toujours sérialisable
#Les types PSVariable, PSReference, PSObject et ScriptBlock ne le sont pas.
#Mais pour certains leurs contenu peut l'être :
# ScriptBlock.ToString; PSVariable.Value; PSReference.Value
if ( ($Item.Value -eq $null) -or ($Item.Value.GetType().isSerializable))
{$Writer.AddResource($Item.Name, [object] $Item.Value)}
else
{Write-Warning (\"`t{0}\" -F \"L'objet $IndexObjet n'est pas sérialisable.\"«»)}
}#Default
}#Switch
}# if PSCustomObject
else
{Write-Error \"L'objet n'est pas un objet synthétique(PSCustomObject) de type Resource @{Name,Value}.\"}
}#Else $item not $null
}#InsertResource

$null=[Reflection.Assembly]::LoadWithPartialName(\"System.Resources\"«»)
write-Debug (\"[{0}] Begin : {1}\" -F ($MyInvocation.InvocationName,\"Création du fichier de ressource : $FileName\"«»))

#Si le fichier est en cours d'utilisation -> exception
# 11 cas d'exception pour le constructeur System.IO.FileStream
trap {break}

#Si le fichier existe, il est écrasé : [System.IO.FileMode]::Create
#On l'ouvre nécessairement en écriture : [System.IO.FileAccess]::Write
$FileStream = (new-object System.IO.FileStream($FileName, [System.IO.FileMode]::Create, [System.IO.FileAccess]::Write))
$Writer = new-object System.Resources.ResourceWriter $FileStream

#Détermine le nom du type d'une ressource d'après le contenu d'un objet
$sbGetTypeName={ param ($Obj)
if ($Obj.Value -eq $null)
{\"ResourceTypeCode.Null\"} #Nom de type privé issue de la BCL
else
{$obj.Value.GetType().Name}
}# $sbGetTypeName

#Numéro de l'objet reçu du pipe
$script:IndexObjet=-1;
}#End

process
{
#En cas d'erreur le fichier n'est pas enregistré car il n'y a pas d'appel à Generate()
# [System.ArgumentException] =Nom de ressource dupliquée.
trap {
write-Debug (\"[{0}] Process : {1}\" -F ($MyInvocation.InvocationName,\"Erreur: fermeture du fichier de ressource.\"«»))
$Writer.Close()
break; #Déclenche l'exception [System.Management.Automation.PipelineStoppedException]
}

write-Debug (\"[{0}] Process : {1}\" -F ($MyInvocation.InvocationName,\"Validation des prérequis.\"«»))
$Current=$_
#Est-ce que l'object est une collection ? (On teste si l'objet implémente l'interface IEnumerable)
if ($Current -is [System.Collections.IEnumerable])
{
write-Debug \"`tCollection détecté.\"
$Current.GetEnumerator()|% {InsertResource $_}
}
else
{ InsertResource $Current }
}#Process

end
{
write-Debug (\"[{0}] End\" -F $MyInvocation.InvocationName)

#Le fichier a pu être fermé précédemment (bloc exception de process).
trap [System.InvalidOperationException]
{continue}
$Writer.Generate()
$Writer.Close()
}#End
}
[/code:1]