MessageBox TopMost (Csharp)

Aujourd'hui je vous propose de résoudre le problème suivant : "MessageBox" ne pop pas au premier plan !
Pour résoudre ce problème, je propose d'utiliser un script en Csharp inclu dans le code Powershell.

Dans Powershell : Je définit un type personnalisé (Add-Type) pour y inclure mon code Csharp.

Dans CSharp : La fonction "MessageBox" permet de déclarer le handle de la fenêtre parent.
Je vais donc attacher mon "MessageBox" à une nouvelle fenêtre que je vais forcer au premier plan.

A noter :
Les MessagesBox utilisent la Dll "SystemWindowsForms.dll".
Il faut penser à la déclarer le chemin de la Dll avec l'option "-ReferencedAssemblies".

 

#######################################################################
#                                                                     #
# MessageBox TopMost - V1.0.0                                         #
#                                                                     #
# Par Olivier DELORME                                                 #
# Site https://powershell.sekki.fr                                    #
#                                                                     #
#######################################################################


#Assembly
[void][reflection.assembly]::LoadWithPartialName("System.Windows.Forms")


#Csharp
try  { [void][Sekki.Csharp] }
catch{
       Add-Type -TypeDefinition @"
       using System;
       using System.Windows;
       using System.Windows.Forms;
       namespace Sekki
        {
          public class Csharp
           {
             public static void MessageBoxA(string message, string title, MessageBoxIcon iconbox)
              {
                MessageBox.Show(new Form(){TopMost=true, TopLevel=true}, message, title, MessageBoxButtons.OK, iconbox);
              }
             public static string MessageBoxB(string message, string title, MessageBoxButtons buttonbox, MessageBoxIcon iconbox)
              {
                DialogResult result;
                result = MessageBox.Show(new Form(){TopMost=true, TopLevel=true}, message, title, buttonbox, iconbox);
                if (result == System.Windows.Forms.DialogResult.Abort)    { return "Abort";   }
                if (result == System.Windows.Forms.DialogResult.Cancel)   { return "Cancel";  }
                if (result == System.Windows.Forms.DialogResult.Ignore)   { return "Ignore";  }
                if (result == System.Windows.Forms.DialogResult.No)       { return "No";      }
                if (result == System.Windows.Forms.DialogResult.OK)       { return "OK";      }
                if (result == System.Windows.Forms.DialogResult.Retry)    { return "Retry";   }
                if (result == System.Windows.Forms.DialogResult.Yes)      { return "Yes";     }
                return "None";
              }
           }
        }
"@ -Language CSharp -ReferencedAssemblies System.Windows.Forms
     }


#Exemple 1 :
$text = "Voulez-vous adopter un chat ?"
$BoutonBox = [Windows.Forms.MessageBoxButtons]::YesNo
$titre = "Sekki Powershell - Choix"
$IconBox = [windows.forms.MessageBoxIcon]::Question
[Sekki.Csharp]::MessageBoxB($text,$titre,$BoutonBox,$IconBox)


#Exemple 2 :
$text = "Attention chat adorable !"
$titre = "Sekki Powershell - Alerte"
$IconBox = [windows.forms.MessageBoxIcon]::Warning
[Sekki.Csharp]::MessageBoxA($text,$titre,$IconBox)

Watermark

Ce script permet d'inserer un watermark sur l'ensemble des images "jpg" et "png" d'un dossier.
1 - Copier le script dans le dossier d'image à traiter (ex: WaterMark.ps1).
2 - Créer le fichier "Watermark.png" à incruster.
3 - Dans le script, configurer l'option de position du watermark.
4 - Executer le script Powershell.

 

#######################################################################
#                                                                     #
# Watermark - V1.0.0                                                  #
#                                                                     #
# Par Olivier DELORME                                                 #
# Site https://powershell.sekki.fr                                    #
#                                                                     #
#######################################################################


#Assembly
[void][reflection.assembly]::LoadWithPartialName("System.Windows.Forms")
[void][reflection.assembly]::LoadWithPartialName("System.Drawing")


#Choisir la position :
#"Remplir", "En haut a gauche", "En haut a droite",
#"En bas a gauche", "En bas a droite", "Au centre".
$wmOption = "Remplir"


#Chemin courant.
$global:curPath = ""
if ($psISE) { $global:curPath = Split-Path -parent $psISE.CurrentFile.Fullpath }
else        { $global:curPath = Split-Path $MyInvocation.MyCommand.Path }


#Image model :
#1 - Créer une image avec un fond transparant.
#2 - Pour rendre l'image transluside, règler le paramêtre "Opacité" dans votre éditeur d'image.
#3 - Sauvegarder l'image sous le nom "watermark.png" (au format PNG).
$Watermark = $global:curpath + "\watermark.png"

#Verifier si le fichier "watermark.png" est présent dans le dossier.
if (!(Test-Path -path ($global:curpath + "\watermark.png"))) { Write-Host "Le fichier ""watermark.png"" est absent !!!"; return }

#Créer le dossier de destination pour les images marquées.
if (!(Test-Path -path ($global:curpath + "\Marked"))) { $rtn = New-Item -Path ($global:curpath + "\Marked") -ItemType directory -Force }


#Initialisation graphique.
$waterMk = New-Object System.Drawing.Bitmap($Watermark)
$srcRect = New-Object System.Drawing.Rectangle(0, 0, $waterMk.Width, $waterMk.Height)


#Traitement des fichiers dans le dossier du script.
$files = Get-ChildItem -Path $global:curpath | where {$_ -match "((.jpg)|(.png))$"}

#Verifier si il y a des fichiers à traiter.
if ($files.count -le 1)
  {
    Write-Host "Le script doit être dans le même dossier que les images à traiter."
    return
  }

#Début du traitement.
foreach($file in $files)
 {
   if ($file -notmatch "WaterMark")
     {
       $image = New-Object System.Drawing.Bitmap($file.fullname)
       $graph = [System.Drawing.Graphics]::FromImage($image)
       Switch ($wmOption)
        {
                   "Remplir" {
                               $dstRect = New-Object System.Drawing.Rectangle(0, 0, $image.Width, $image.Height)
                               $graph.DrawImage($waterMk,$dstRect,$srcRect,2)
                             }
          "En haut a gauche" { $graph.DrawImage($waterMk,0,0,$srcRect,2) }
          "En haut a droite" {
                               $dstRect = New-Object System.Drawing.Rectangle(($image.Width-$waterMk.Width), 0, $waterMk.Width, $waterMk.Height)
                               $graph.DrawImage($waterMk,$dstRect,$srcRect,2)
                             }
          "En bas a gauche" {
                               $dstRect = New-Object System.Drawing.Rectangle(0, ($image.Height-$waterMk.Height), $waterMk.Width, $waterMk.Height)
                               $graph.DrawImage($waterMk,$dstRect,$srcRect,2)
                             }
          "En bas a droite" {
                               $dstRect = New-Object System.Drawing.Rectangle(($image.Width-$waterMk.Width), ($image.Height-$waterMk.Height), $waterMk.Width, $waterMk.Height)
                               $graph.DrawImage($waterMk,$dstRect,$srcRect,2)
                             }
                "Au centre" {
                               $cx = [int](($image.Width-$waterMk.Width)/2)
                               $cy = [int](($image.Height-$waterMk.Height)/2)
                               $dstRect = New-Object System.Drawing.Rectangle($cx, $cy, $waterMk.Width, $waterMk.Height)
                                $graph.DrawImage($waterMk,$dstRect,$srcRect,2)
                            }
        }
       $image.Save($global:curpath + "\Marked\" + $file)
       Write-Host "Le fichier ""$file"" a été sauvegardé dans le dossier ""Marked""."
       $graph.Dispose()
       $image.Dispose()
     }
 }

#Fin.
$waterMk.Dispose()

Exemple :

Généralités VmWare

Nous allons voir ici les bases du module VmWare pour PowerShell (VMware.VimAutomation.Core). Cet article montre comment se connecter sur un serveur VmWare, obtenir des informations (comme la liste des VMs), et fermer la connexion.

 

#Variables PowerShell.
$ErrorActionPreference = "SilentlyContinue"   #Defaut = Continue
$ConfirmPreference     = "None"               #Defaut = High


#Import du module VmWare.
Import-Module -Name VMware.VimAutomation.Core -Scope Global
if ((Get-Module -Name VMware.VimAutomation.Core) -eq $null) { Return }


#Configuration du module VmWare : Supprimer l'alerte du certificat.
#Options : Fail, Ignore, Warn.
$null = Set-PowerCliConfiguration -InvalidCertificateAction Ignore

#Configuration du module VmWare : Désactive le CEIP.
#Options : $True, $False.
$null = Set-PowerCliConfiguration -ParticipateInCeip $false

#Configuration du module VmWare : Web Timout (défaut = 300s).
$null = Set-PowerCliConfiguration -WebOperationTimeoutSeconds 300

#Configuration du module VmWare : Proxy.
$null = Set-PowerCliConfiguration -ProxyPolicy NoProxy


#Initialisation.
$vSrv   = "monserveur.sekki.fr"   #Nom ou Ip du vCenter.
$vConn  = $null                   #Information de connection.
$Cred   = $null                   #Login et mot de passe pour la connection.
$delais = 500
$ping   = New-Object System.Net.NetworkInformation.Ping


#MessageBox.
function Alerte([string]$TEXT)
  {
    $MessageBox = [Windows.Forms.MessageBox]
    $BoutonBox = [Windows.Forms.MessageBoxButtons]::OK
    $IconBox = [windows.forms.MessageBoxIcon]::Warning
    $null = $MessageBox::show($TEXT,"MessageBox",$BoutonBox,$IconBox)
  }


#Enregistrer le login et mot de passe (Credential).
While ($Cred -eq $null)
 {
   $Cred = Get-Credential -Message "Login to VmWare."
 }


#Verifie si le serveur répond au ping.
Try   { $reply = $ping.Send($vSrv,$delais) }
Catch { Alerte "Le serveur ne repond pas."; Return }
if ($reply.Status -ne "Success") { Alerte "Le serveur ne repond pas."; Return }


#Connection au vCenter.
$vConn = Connect-VIServer -Server $vSrv -Credential $Cred -Port 443 -Protocol https -EA SilentlyContinue
if ($vConn -eq $null)
  {
    Alerte "Echec de la connection à VmWare."
    Return #Si on est pas connecté on sort.
  }


###### Get-VM ######


#Liste les VMs.
$VMs = Get-VM
$VMs | Out-GridView

#Liste les VMs allumées.
$VMs = (Get-VM).where{$_.PowerState -eq 'PoweredOn'}
$VMs | Out-GridView

#Liste les VMs commencant par.
$VMs = Get-VM -Name V*
$VMs | Out-GridView

#Liste les VMs Windows.
$VMs = (Get-VM).where{$_.Guest.OSFullName -match 'Windows'}
$VMs | Out-GridView


###### Get-VApp ######

$VAs = Get-VApp
$VAs | Out-GridView


###### Get-Host ######


#Liste les Hotes.
$Hosts = Get-VMHost
$Hosts | Out-GridView


###### Get-DataStore ######


#Liste les Datastores.
$DSs = Get-Datastore
$DSs | Out-GridView


#Liste les Datastores d'un hote en particulier.
$DSs = Get-VMHost -Name Adam | Get-Datastore
$DSs | Out-GridView

#Info d'un Datastore.
$DSs = Get-Datastore -Name DS_SEKKI_01
$DSs | Out-GridView


###### Get-SnapShot ######


#Liste les SnapShots
$SSs = (Get-VM | Get-Snapshot)
$SSs | Out-GridView


###### Get-DataCenter ######


#Liste les DataCenters
$DCs = Get-DataCenter
$DCs | Out-GridView

#Liste les VMs d'un DataCenter
$DCs = Get-DataCenter -Name PARIS | Get-VM
$DCs | Out-GridView

#Liste les Datastores d'un DataCenter
$DCs = Get-DataCenter -Name PARIS | Get-Datastore
$DCs | Out-GridView


###### End ######


Disconnect-VIServer -Server $vConn

PsToHtml

Permet de convertir un script PowerShell en Hlml pour ce Blogger.
1 - Ajoute les balises pour le bouton "code".
2 - Converti les espaces et retour chariot pour HTML.
3 - Ajoute les balises de fermeture.

Usage :

1 - Créer un fichier "in.txt".

2 - Coller le code PowerShell dans le fichier "in.txt".

3 - Exécuter le script.

4 - Copier le code Html généré dans le fichier "out.txt".

5 - Coller le code généré dans la page "Html" lors de la création de l'article.

 

 

##################################################################################
#                                                                                #
# Prepare le code Ps pour la publication Html                                    #
#                                                                                #
# Note : Le script Ps ne doit pas depacer 83 caractères en largeur (si possible).#
#                                                                                #
##################################################################################


#curpath
if ($psISE) { $curpath = Split-Path -parent $psISE.CurrentFile.Fullpath }
else        { $curpath = Split-Path $MyInvocation.MyCommand.Path }

#Fichier d'entrée / sortie.
$script = $curpath+"\in.txt"
$html   = $curpath+"\out.txt"

#Code de zone pour la copie.
$cpcode = "copy" + (date -f "yyMMddHHmmss")

#Ajoute de l'entête.
$top  = "<div id=""code"">`r`n"
$top += "<div style=""text-align: right;""><button id=""copy"" "
$top += "onclick=""CopyCode('#$($cpcode)')"">Copy</button> </div>`r`n"
$top += "<div id=""$($cpcode)"">`r`n"
$top += "<br />`r`n"

#Traitement des lignes.
$txt   = ""
$lines = Get-Content $script
Foreach ($line in $lines)
 {
   #Convertir les espaces.
   $line = $line.replace("  ","&nbsp;&nbsp;")
   #Ajoute la balise Br en fin de ligne.
   $line += "<br />`r`n"
   #Ajout au texte modifié.
   $txt += $line
 }

#Fermeture des Divs.
$bottom = "</div></div>`r`n"

#Enregistre le fichier.
$txt = $top + $txt + $bottom
Set-Content -Path $html -Value $txt

#Fin.

WaitAndClick

Wait&Click est une boucle qui envoie un clique de souris à l'endroit souhaité après un temps d'attente.

 

#Assembly.
[void][reflection.assembly]::LoadWithPartialName("System.Windows.Forms")
[void][reflection.assembly]::LoadWithPartialName("Microsoft.VisualBasic")

#Variables.
$global:X = 0
$global:Y = 0
$global:Decompte = 0
$global:Attente = 20

################################################
# Types.
################################################

#Ajoute du type : Send mouse click (Left 02 + 04 / Right 08 + 10 / Middle 20 + 40).
$signSendClick = @'
[DllImport("user32.dll",CharSet=CharSet.Auto, CallingConvention=CallingConvention.StdCall)]
public static extern void mouse_event(long dwFlags, long dx, long dy, long cButtons, long dwExtraInfo);
'@
$global:sendClick = Add-Type -memberDefinition $signSendClick -name "Win32MouseEventNew" -namespace Win32Functions -passThru

################################################
# Timer.
################################################

#Timer.
$timer1 = New-Object System.Windows.forms.timer
$timer1.Interval = (1000) #Millisecondes.
$timer1.Add_Tick({
                   $global:Decompte--
                   $global:labelA1.Text = [string]$global:Decompte

                   if ($global:Decompte -eq 0)
                     {
                       #Position courante.
                       $positon = [System.Windows.Forms.Cursor]::Position

                       #Enregistre la position si elle n'est pas initialisée.
                       if (($global:X -eq 0) -and ($global:Y -eq 0)) { $global:X = $positon.X; $global:Y = $positon.Y; $global:labelA1.BackColor = "White" }

                       #Déplace la souris.
                       [System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point($global:X, $global:Y)

                       #Envoie un clique gauche.
                       $global:sendClick::mouse_event(0x00000002, 0, 0, 0, 0)
                       $global:sendClick::mouse_event(0x00000004, 0, 0, 0, 0)

                       #Envoie un clique droit.
                       #$global:sendClick::mouse_event(0x00000008, 0, 0, 0, 0)
                       #$global:sendClick::mouse_event(0x00000010, 0, 0, 0, 0)

                       #Envoie un clique milieu.
                       #$global:sendClick::mouse_event(0x00000020, 0, 0, 0, 0)
                       #$global:sendClick::mouse_event(0x00000040, 0, 0, 0, 0)

                       #Envoie la touche "Enter".
                       #[System.Windows.Forms.SendKeys]::SendWait("TEST")
                       #[System.Windows.Forms.SendKeys]::SendWait("{ENTER}")

                       #Replace la souris.
                       [System.Windows.Forms.Cursor]::Position = $positon

                       #Relance de temps d'attente.
                       $global:Decompte = $global:Attente
                     }
                })

################################################
# Fonctions.
################################################

#Affiche une boite de dialogue.
function InputBox([string]$TEXT)
  {
    Try { $i = [int]([Microsoft.VisualBasic.Interaction]::InputBox($TEXT, "Notice",$global:Attente)) }
    Catch { $i = 20 }
    if ($i -eq 0) { Exit } #Bouton Annuler.
    if ($i -lt 5) { $i = 5 }
    return $i
  }

################################################
# Main.
################################################

#Démarrage du programme.
$global:Attente = InputBox "1 - Entrez le temps d'attente (en secondes).`r`n`r`n2 - Fermer la fenêtre en cliquant sur OK.`r`n`r`n3 - Positionnez la souris à l'emplacement à cliquer, et attendez la fin du premier décompte pour enregistre la position.`r`n`r`n"
$global:Decompte = $global:Attente

#Création d'une fenêtre.
$formA = New-Object Windows.Forms.Form
$formA.ClientSize = New-Object System.Drawing.Size(120,100)
$formA.MaximizeBox = 0
$formA.MinimizeBox = 0
$formA.ShowIcon = 0
$formA.FormBorderStyle = "Fixed3D"
$formA.text = "Wait&Click"
$formA.TopMost = 1 #Récupère le jeton TopMost.
$formA.ShowInTaskbar = 0
$formA.BackColor = "White"

#Création d'un label.
$global:labelA1 = New-Object Windows.Forms.Label
$global:labelA1.Location = New-Object Drawing.Point 0,0
$global:labelA1.Size = New-Object System.Drawing.Size 125,100
$global:labelA1.Font = New-Object System.Drawing.Font("Verdana","50",[System.Drawing.FontStyle]::Regular,3,0)
$global:labelA1.BackColor = [System.Drawing.Color]::FromArgb(255,248,203,47)
$global:labelA1.TextAlign = "MiddleCenter"
$global:labelA1.Text = "--"

#Attache le contrôle à la fenêtre.
$formA.controls.add($global:labelA1)

#Lance le timer.
$timer1.start()

#Affiche la fenêtre.
[void]$formA.ShowDialog()

#Fin.
$timer1.Stop()

PowerShell et LiteDB v5

Nous allons voir dans cet article l'utilisation de la base de données LiteDB v5 dans un environnement Windows PowerShell. La nouvelle version LiteDB v5, présenté ici, tourne dans l'environnement FrameWork 4.5. 

Attention :

Les scripts PowerShell écrits pour la version LiteDB v3 ne sont pas compatible avec la version v5. Il n'est donc pas possible de simplement remplacer la Dll "LiteDB.Dll v3" par la Dll "LiteDB.Dll v5".

Référence

Toujours à la recherche d'une base de données légère pour mes scriptes PowerShell, j'ai découvert LiteDB. Cette base de données "sans serveur" se présente sous la forme d'une simple Dll de moins de 500Ko. Elle ne nécessite ni installation, ni droit administrateur. LiteDB est donc facilement portable pour peu que le FrameWork 4.5 (ou compatible) soit installé sur le système.

Site de référence : http://www.litedb.org

Notice :

- Ouvrir le site de Litedb.org.

- Cliquer sur "Download".

- Cliquer sur "Download package" (à droite).

- Ouvrir le dossier de téléchargement.

- Ouvrir le fichier "litedb.5.0.10.nupkg" avec WinZip (ou équivalent).

- Récupérer les fichiers "LiteDB.dll" et "LiteDB.xml" qui se trouvent dans le dossier "net45".

Exemple

Dans l'exemple ci-dessous, j'utilise la version LiteDB 5.0.10.

 

################################################################
#
#               Base de données : LiteBD v5.0.10
#                     Powershell.sekki.fr
#
# 1 - Créer un dossier ldb à côté du script.
# 2 - Télécharger et copier LiteDB.dll+xml dans le dossier ldb.
#
################################################################

#Chemin courant.
$curpath = ""
if ($psISE) { $curpath = split-path -parent $psISE.CurrentFile.Fullpath }
else        { $curpath = Split-Path $MyInvocation.MyCommand.Path  }

#Charge les fonctions LiteDB.
Try   { [void][Reflection.Assembly]::LoadFile($curpath+"\ldb\LiteDB.dll") }
Catch { write-host "LiteDB.dll manquant.";Return 2 }

###Fonctions personnalisées.
#Renvoi un nombre entre 0 et 100.
function GR() { Get-Random -minimum 0 -maximum 100 }

###Fonctions personnalisées.
#Converti le résultat de la query pour l'afficher.
function BsonToObj($bsn)
 {
   #Conversion avec la version (Modifié pour LiteDB v5).
   $obj = New-Object System.Object
   $obj | Add-Member -type NoteProperty -name id    -Value $bsn["_id"].AsObjectID
   $obj | Add-Member -type NoteProperty -name date  -Value $bsn["date"].AsString
   $obj | Add-Member -type NoteProperty -name info1 -Value $bsn["Nom"].AsString
   $obj | Add-Member -type NoteProperty -name info2 -Value $bsn["Prix"].AsInt32
   $obj | Add-Member -type NoteProperty -name info3 -Value $bsn["Cat"].AsString
   $obj
 }

#Ouvrir/Créer une Base de Données.
$db = New-Object LiteDB.LiteDatabase(($curpath+"\ldb\LiteDB.db"),$null)

#Ouvrir/Créer une Collection.
$coll = $db.GetCollection("Info")

#Créer un document Bson.
$bson = New-Object LiteDB.BsonDocument

#Créer 10 enregistrements.
for($i=0;$i -le 10;$i++)
 {
   $x = GR   #Nombre aléatoire entre 0 et 100.
   if ($x -le 50) { $nom = "Sekki";   $prix = $x; $cat = "Z" }
   else           { $nom = "Jumbor";  $prix = $x; $cat = "B" }
 
   #Ajouter un enregistrement dans la base de données.
   $bson["_id"]    = [LiteDB.ObjectId]::NewObjectId()
   $bson["date"]   = date -format "dd/MM/yyyy"
   $bson["Nom"]    = [string]$nom
   $bson["Prix"]   = [int]$prix
   $bson["Cat"]    = [string]$cat
   [void]$coll.Insert($bson)   #Insére le document dans la collection.
 }

#Afficher une requête.
$query = $coll.Find([LiteDB.Query]::all())
$query | %{BsonToObj $_} | Out-GridView

################################################################
### Modifier / Supprimer.
################################################################

#Modifier un enregistrement.
$query = $coll.Find([LiteDB.Query]::eq("Nom","Sekki"))
foreach ($q in $query)
 {
   $q["Cat"] = "A"
   [void]$coll.Update($q)
 }

#Supprimer un enregistrement : Méthode 1.
$query = $coll.Find([LiteDB.Query]::eq("Nom","Sekki"))
foreach ($q in $query)
 {
   $coll.Delete($q["_id"])
 }

#Supprimer un enregistrement : Méthode 2 (Modifié pour LiteDB v5).
$nb = $coll.DeleteMany([LiteDB.Query]::eq("Nom","Jumbor"))

################################################################
### Les requêtes.
################################################################

#Renvoi les articles dont le nom exact est :
$query = $coll.Find([LiteDB.Query]::eq("Nom","Sekki"))

#Renvoi les articles dont le prix est plus grand que :
$query = $coll.Find([LiteDB.Query]::gt("Prix",30))

#Renvoi les articles dont le prix est plus petit que :
$query = $coll.Find([LiteDB.Query]::lt("Prix",30))

#Renvoi les articles dont le nom commence par :
$query = $coll.Find([LiteDB.Query]::startswith("Nom","S"))

#Renvoi tout les enregistrements :
$query = $coll.Find([LiteDB.Query]::all())

#Afficher une requête.
$query = $coll.Find([LiteDB.Query]::all())
$query | %{BsonToObj $_} | Out-GridView

################################################################
### Les fichiers (Modifié pour LiteDB v5).
################################################################

###Charger des fichiers dans la base de données.
#Insérer/remplacer un fichier dans la base de données :
$db.FileStorage.Upload("$/Fichiers/file1.jpg", $curpath+"\file1.jpg")

#Lire un fichier dans la base de données et l'enregistrer sur le disque local :
$file = $db.FileStorage.FindById("$/Fichiers/file1.jpg")
$file.SaveAs($curpath+"\file2.jpg")

#Lire un fichier dans la base de données et le charger dans une variable :
$file = $db.FileStorage.FindById("$/Fichiers/file1.jpg")
$image = [System.Drawing.Image]::FromStream($file.OpenRead())

#Supprimer un fichier dans la base de données :
$db.FileStorage.Delete("$/Fichiers/file1.jpg")

################################################################

#Pause
if (!$psISE) { Write-Host -NoNewLine "Press any key to continue..."
               $null = $Host.UI.RawUI.ReadKey("NoEcho,IncludeKeyDown") }

#Compresser la base de données (Modifié pour LiteDB v5).
[void]$db.Rebuild()

#Fermer la base de données.
$db.Dispose()

#Fin.