jeudi 1 décembre 2016

PowerShell et PostgreSQL

Dans cet article, nous allons voir l’accès aux bases PostgreSQL avec Windows PowerShell et le Data Provider "Ngpsql.dll". L'exemple suivant montre comment se connecter sur une base PostgreSQL, et utilisation des instructions Create Table, Insert, Query, Update et Drop Table.

Référence


Avant d’exécuter le script, notez que j'ai préalablement installé un serveur "PostgreSQL Portable" sur lequel j'ai créé la base de données "Base1". J'ai également créé un dossier "npgsql" au même niveau que mon script. Ce dossier contient contient les fichiers du Data Provider NpgSQL. La table et les données peuvent être créé ensuite à l'aide des exemples de requêtes SQL présent dans le script.

Liens utiles :
- Serveur PostgreSQL portable
- Data Provider NpgSQL              

Exemple



 
#Chemin courant.
$curpath = ""
Try   { $curpath = Split-Path $MyInvocation.MyCommand.Path }
Catch { $curpath = split-path -parent $psISE.CurrentFile.Fullpath }

#Assembly.
[void][Reflection.Assembly]::LoadFile($curpath+"\npgsql\Npgsql.dll")
[void][Reflection.Assembly]::LoadFile($curpath+"\npgsql\Mono.Security.dll")

#Paramêtres PostgreSQL.
$port="5432"
$server="10.151.16.234"
$user="user1"
$password="P@ssw0rd"

#Chaine de connexion.
$database = "base1"
$connexion = "Server="+$server+";Port="+$port+";User Id="+$user+";Password="+$password+";Integrated Security=true"

function postgre_SQL([string] $ps_conn, [string] $ps_base, [string] $ps_query)
 {
   #Initialisation
   $conn = $ps_conn+";Database="+$ps_base

   #Déclaration des objets.
   $DBconn = New-Object NpgSql.NpgsqlConnection($conn)
   $cmd    = New-Object Npgsql.NpgsqlCommand
   $ds     = New-Object System.Data.DataSet
   $da     = New-Object Npgsql.NpgsqlDataAdapter

   #Exécuter.
   $cmd.CommandTimeout = 30
   $cmd.Connection     = $DBconn
   $cmd.CommandText    = $ps_query
   $da.SelectCommand   = $cmd
   [void]$da.Fill($ds)

   #Ferme la connexion.
   $DBconn.Close()

   #Retour.
   return $ds.Tables[0]
 }

#---------------------------------------------------------------------------#
#Voici la liste de différentes requêtes SQL que vous pouvez essayer.
#Supprimez le # devant la requête SQL que vous souhaitez tester.
#---------------------------------------------------------------------------#
#Créer une table.
#$psQuery = "CREATE TABLE Table1(Colonne1 nchar(16) PRIMARY KEY NOT NULL, Colonne2 nchar(16));"
#Ajouter une ligne.
#$psQuery = "INSERT INTO Table1(Colonne1,Colonne2) VALUES ('Jumbor','PowerShell');"
#Lire une table.
#$psQuery = "select * from Table1;"
#Lire une ligne.
#$psQuery = "select * from Table1 WHERE Colonne1 = 'Jumbor12';"
#Modifier une valeur.
#$psQuery = "UPDATE Table1 SET Colonne2 = 'PowerShell 2.0' WHERE Colonne2 = 'PowerShell';"
#Supprimer une ligne.
#$psQuery = "DELETE FROM Table1 WHERE Colonne1 = 'Jumbor12';"
#Supprimer une table.
#$psQuery = "DROP TABLE Table1;"
#---------------------------------------------------------------------------#

#Affiche la requête exécutée.
Write-Host $psQuery

#Exécute la requête.
$datas = postgre_SQL $connexion $database $psQuery
$datas | Out-GridView

#Exécution terminé.
Write-Host "Exécution terminé."

#Fin.

vendredi 29 juillet 2016

Zone de notification.

Cet exemple montre comment mettre en place une icône dans la zone de notification (System Tray). Pour cela, nous allons construire notre l’icône avec l'object System.Windows.Forms.NotifyIcon auquel nous allons associer un menu contextuel. Le menu contextuel permettra d'afficher la fenêtre lorsque celle-ci est masquer, de simuler un popup dans la zone de notification, et de quitter l'application.

Exemple


 
#Déclaration.
[Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")

#Construction du menu contextuel.
$itemT1 = New-Object System.Windows.Forms.MenuItem -ArgumentList "Afficher Popup"
$itemT1.Add_Click({
                    #BalloonTipIcon = "None", "Info", "Warning" ou "Error".
                    #ShowBalloonTip(en millisecondes).
                    $TrayIcon.BalloonTipTitle = "Tray Icon"
                    $TrayIcon.BalloonTipText  = $textA1.Text
                    $TrayIcon.BalloonTipIcon  = "Info"  
                    $TrayIcon.ShowBalloonTip(300000)
                 })
$itemT2 = New-Object System.Windows.Forms.MenuItem -ArgumentList "Afficher Fenêtre"
$itemT2.Add_Click({  $formA.Visible = $true  })
$itemT3 = New-Object System.Windows.Forms.MenuItem -ArgumentList "Quitter"
$itemT3.Add_Click({  $formA.Close()  })
$menuT1 = New-Object System.Windows.Forms.ContextMenu
[void]$menuT1.MenuItems.Add($itemT1)
[void]$menuT1.MenuItems.Add($itemT2)
[void]$menuT1.MenuItems.Add($itemT3)

#Construction de l'icone pour la zone de notification.
#Attention : Mettre un chemin valide pour le fichier .ico.
$TrayIcon = New-Object System.Windows.Forms.NotifyIcon
$TrayIcon.Icon = "c:\xxx.ico"   #Image au format .ico.
$TrayIcon.Text = "TrayIcon"     #Texte de l'info bulle.
$TrayIcon.ContextMenu = $menuT1 #Menu contextuel.
$TrayIcon.Visible = $True

#Fenêtre.
$formA = New-Object System.Windows.Forms.form
$formA.Size = New-Object Drawing.Point 200,90
$formA.Text = "Tray Icon"   #Titre de la fenêtre.

#Masque la fenetre dans la barre de taches.
$formA.ShowInTaskbar = $false

#Bouton pour masquer la fenêtre.
$boutonA1 = New-Object Windows.Forms.Button
$boutonA1.Location = New-Object Drawing.Point 95,28
$boutonA1.Size = New-Object System.Drawing.Size(85,23)
$boutonA1.text = "Masquer"
$boutonA1.add_click({  $formA.Visible = $false  })

#Bouton pour afficher un popup dans la zone de notification.
$boutonA2 = New-Object Windows.Forms.Button
$boutonA2.Location = New-Object Drawing.Point 5,28
$boutonA2.Size = New-Object System.Drawing.Size(85,23)
$boutonA2.text = "Popup"
$boutonA2.add_click({   
                      $TrayIcon.BalloonTipTitle = "Tray Icon"
                      $TrayIcon.BalloonTipText  = $textA1.Text
                      $TrayIcon.BalloonTipIcon  = "Info"   #None,Info,Warning,Error
                      $TrayIcon.ShowBalloonTip(300000) 
                   })

#Champ texte pour changer le texte du popup.
$textA1 = New-Object Windows.Forms.TextBox
$textA1.Location = New-Object Drawing.Point 5,5
$textA1.Size = New-Object System.Drawing.Size(175,23)
$textA1.Text = "Changez moi !"

#Afficher la fenêtre.
$formA.controls.add($boutonA1)
$formA.controls.add($boutonA2)
$formA.controls.add($textA1)
[void][System.Windows.Forms.Application]::Run($formA)

#Fin.
$TrayIcon.Dispose()


Merci de remplacer le chemin "c:\xxx.ico" dans l'exemple par un chemin valide vers un fichier .ico (celui de votre choix). Sinon vous obtiendrez une erreur lors de l’exécution de l'exemple.

jeudi 23 juin 2016

PowerShell, CSharp et Global Hook

Dans cet exemple, j'utilise un script en cSharp pour récupérer les frappes clavier sur les touches F1 à F12. Puis je passe l'information au script Windows PowerShell. Cette technique me permet de déclencher une action sans avoir le focus sur l'application PowerShell (Global Hook)

Dans cet exemple, j'utilise un programme déjà publié un peu partout, mais adapté ici pour récupère que les touches de fonctions de F1 à F12. Ce programme se décomposer en deux parties. Un programme en CShape que j’intègre directement dans le script PowerShell et qui est lancé dans un RunSpace afin de ne pas bloquer mon script. Et un programme principale en PowerShell qui lance l'action lorsque la frappe est détecté. La communication entre les deux programmes n'est pas ce qu'il y a de plus simple à traiter. Après plusieurs essai, j'ai actuellement opté pour un socket réseau afin de pouvoir échanger des données entre le programme en CShape et le programme principale en Powershell. Ce n'est pas forcement l'idéal, mais c'est la solution qui m'a posé le moins de problèmes.

Exemple


 
##################################################################
# Script C# :
# Récupère les frappes aux claviers (quelques soit l'application),
# et en informe le programme en écrit en Powershell.
##################################################################
# Script PowerShell :
# Lance le script en C# dans un nouveau thread, et écoute les
# informations transmissent par le script en C#.
##################################################################

#Assembly.
[Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")

##################################################################
# Script C#
# Récupère les frappes aux claviers (F1 à F12),
# et on informe le script PS1.
##################################################################

$csharp1 = {
  Add-Type -TypeDefinition @"
  using System;
  using System.IO;
  using System.Net;
  using System.Text;
  using System.Net.Sockets;
  using System.Diagnostics;
  using System.Windows.Forms;
  using System.Runtime.InteropServices;
  namespace KL {
  
    public static class Program {
      private const int WH_KEYBOARD_LL = 13;
      private const int WM_KEYDOWN = 0x0100;
   
      private static HookProc hookProc = HookCallback;
      private static IntPtr hookId = IntPtr.Zero;
   
      public static void Main() {
                                  hookId = SetHook(hookProc);
                                  Application.Run();
                                  UnhookWindowsHookEx(hookId);
                                }
      private static IntPtr SetHook(HookProc hookProc) {
        IntPtr moduleHandle = GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName);
        return SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, moduleHandle, 0);
                                                       }
      private delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam);
      private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam) {
                                                                                    if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
                                                                                      {
                                                                                        int vkCode = Marshal.ReadInt32(lParam);
                                                                                        if ((vkCode > 111) && (vkCode < 128))
                                                                                          {
          string text = "";
          Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Dgram,ProtocolType.Udp);
          IPAddress serverAddr = IPAddress.Parse("127.0.0.1");
          IPEndPoint endPoint = new IPEndPoint(serverAddr, 12345);
          KeysConverter kc = new KeysConverter();
          text = kc.ConvertToString(vkCode);
          byte[] send_buffer = Encoding.ASCII.GetBytes(text);
          sock.SendTo(send_buffer , endPoint);
          sock.Close();
          if (vkCode == 127) { Application.ExitThread(); }
                                                                                          }
                                                                                      }
                                                                                    return CallNextHookEx(hookId, nCode, wParam, lParam);
                                                                                  }
      [DllImport("user32.dll")]
      private static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hMod, uint dwThreadId);
      [DllImport("user32.dll")]
      private static extern bool UnhookWindowsHookEx(IntPtr hhk);
      [DllImport("user32.dll")]
      private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode, IntPtr wParam, IntPtr lParam);
      [DllImport("kernel32.dll")]
      private static extern IntPtr GetModuleHandle(string lpModuleName);
    }
  }
"@ -ReferencedAssemblies System.Windows.Forms
#Lancement du programme en CShape.
[KL.Program]::Main()
}

##################################################################
# Ouverture d'un canal de communication réseau en UDP.
# Communication entre le script C# et PowerShell.
##################################################################

$global:udpport = 12345
$global:endpoint = new-object System.Net.IPEndPoint ([IPAddress]::Any,$global:udpport)
$global:udpclient = new-Object System.Net.Sockets.UdpClient $global:udpport

##################################################################
# Lance l'application C# dans un Runspace.
##################################################################

#Création du runspace.
$runspace1 = [System.Management.Automation.Runspaces.RunspaceFactory]::CreateRunspace()
$runspace1.Open()
$pipeline1 = $runspace1.CreatePipeline()
$pipeline1.Commands.AddScript($csharp1)
$pipeline1.InvokeAsync()
$running = [System.Management.Automation.Runspaces.PipelineState]::Running
if ($pipeline1.PipelineStateInfo.State -ne $running) { Exit }

##################################################################
# Timer pour écouter les retours de l'application C#
##################################################################
               
$timer1 = new-object System.Windows.forms.timer
$timer1.Interval = 250
$timer1.Add_Tick({
                   while ($global:udpclient.Available)
                    {
                      $content = $global:udpclient.Receive([ref]$global:endpoint)
                      $fxx = [Text.Encoding]::ASCII.GetString($content)
                      switch ($fxx){
                                     F1      { write-host "F1" ; break }
                                     #...
                                     F12     { write-host "F12"; break }
                                     default { write-host $fxx ; break }
                                   }
                    }
                })

##################################################################
# Script Powershell.
##################################################################

$global:formA = New-Object Windows.Forms.Form
$global:formA.text = "GlobalHook Keyboard."            
$global:formA.Size = New-Object System.Drawing.Size(250,110)
$global:formA.Add_KeyDown({
                            if ($_.KeyCode -eq "Escape")
                              { $global:formA.Close() }
                          })
$labelA1 = New-Object Windows.Forms.Label
$labelA1.Location = New-Object Drawing.Point 20,30
$labelA1.Size = New-Object Drawing.Point 210,16
$labelA1.Text = "Appuyer sur un touche de F1 à F12."
$formA.controls.add($labelA1)
$timer1.Start()
$global:formA.ShowDialog()

##################################################################
# Fermeture des ressources.
##################################################################

$timer1.Stop()                                       #Stop Timer.
[System.Windows.Forms.SendKeys]::SendWait("{F16}")   #Stop C# App.
$runspace1.Close()                                   #Stop Runspace.
$udpclient.Close()                                   #Stop Socket.


Pour éviter qu'une partie du programme continue de tourner tout seul dans son coin, il est important de bien fermer tout ce petit monde dans l'ordre. Tout d'abord il faut demander au programme CSharp de se fermer. Pour cela je simule dans mon programme PowerShell une frappe sur la touche F16. Le programme CShape est configuré pour s'arrêter lorsqu’il capture une frappe sur la touche F16. Ceci fait, je ferme mon RunSpace, puis je libérer mes ressources réseaux.

mardi 14 juin 2016

Utiliser Xml dans PowerShell

Nous allons voir dans cet article les bases permettant de gérer un fichier Xml avec Windows PowerShell. Dans les exemples suivants, nous allons lire le fichier Xml. Le premier exemple utilise la méthode de l'index pour lire les données. Le second exemple utilise la commande foreach.

Fichier XML


En premier lieu, nous allons créer un fichier texte "livres.xml". Ce fichier doit contenir les lignes de données suivantes :

<?xml version="1.0" standalone="yes"?>

<Livres>

  <Manga Edition="Kana">
    <Titre>Jumbor</Titre>
    <Numero>1</Numero>
  </Manga>

  <Manga Edition="Ki-oon">
    <Titre>Ubel Blatt</Titre>
    <Numero>1</Numero>
  </Manga>

</Livres>

Une fois le fichier enregistré (dans c:\temp par exemple), nous allons utiliser PowerShell pour le lire.

Exemple 1


#Lecture du fichier.
[xml]$xml = get-content (“c:\temp\livres.xml”)

#Je récupéré dans $Livres les données entre la balise <Livres> et </Livres>.
$Livres = $xml.Livres

#Puis j'affiche mes données.
Write-Host $Livres.Manga[0].Edition
Write-Host $Livres.Manga[0].Titre
Write-Host $Livres.Manga[0].Numero

Ici je suis obligé d'indexer $Livre.Manga[] car dans mon fichier Xml, j'ai plusieurs fois la balise <Manga>. Si la balise n'était présente qu'une seul fois, j'aurais dû écrire Write-Host $Livres.Manga.Edition (sans l'indexation). Ceci viens de l’interprétation de la commande Get-Content. Lorsqu'il rencontre plusieurs fois une même balise, il la traduit sous la forme d'un tableau. Pour éviter les problèmes d'écriture suivant le nombre d’élément répétable présent dans un document Xml, il vaut mieux passer par un Foreach :

Exemple 2


#Lecture du fichier.
[xml]$xml = get-content (“c:\temp\livres.xml”)

#Je récupéré dans $Livres les données entre la balise <Livres> et </Livres>.
$Livres = $xml.Livres

#Puis j'affiche mes données.
foreach ($m in $Livres.Manga)
 {
   Write-Host $m.Edition
   Write-Host $m.Titre
   Write-Host $m.Numero
 }

Ici, la commande foreach fonctionne quelques soit le nombre de balise <Manga> présent dans le document Xml.

vendredi 9 janvier 2015

PowerShell et FireBird

Dans cet article, nous allons voir comment utiliser les bases FireBird avec Windows PowerShell et le Data Provider "Ado.net". L'exemple suivant montre comment se connecter sur une base FireBird, et utilisation des instructions Create Table, Insert Into, Select, Update, Delete From et Drop Table.

Installer FireBird


Je cherchais une base de donnée légère et portable pour pouvoir héberger mes données et je suis tombé sur FireBird. Cette base de donnée fait moins de 20Mo, et il est possible de la rendre portable à l'aide d'une petite procédure.

Tout d'abord nous devons installer FireBird. Les sources sont ici "Download_FireBird". Téléchargez la dernière version pour Win64 "SuperServer", puis installez la base de donnée.

Il nous faudra également un connecteur pour pouvoir utiliser FireBird avec PowerShell. Les sources du connecteur sont ici "ADO.NET".

La procédure pour convertir FireBird en version portable est ici "Procédure". Bon d'accord, c'est en anglais. Je vais vous traduire ca rapidement :
- Installez FireBird (si ce n'est pas déjà fait).
- Arrêtez les services de FireBird.
- Copiez le dossier “C:\Program Files\Firebird\Firebird_2_5\” sur votre clé USB par exemple.
- Ouvrez le dossier ou vous avez copié FireBird.
- Supprimez le fichier firebird.conf (Si vous avez apporté des modifications).
- Créez un nouveau batch nommé "Start.bat".
- Editez le fichier "Start.bat", et copiez les deux lignes suivante dedans :
  cd bin
  fbserver.exe -a -p 3050 -database "localhost:..\security2.fdb" –n

- Créez également le batch "Stop.bat".
- Editez le fichier "Stop.bat", et copiez la ligne suivante dedans :
  taskkill /F /IM fbserver.exe /T
Et voila c'est fini ;)

FlameRobin


Bien que cela ne sois pas indispensable pour cet article, vous pouvez également installer FlameRobin pour l'administration graphique de la base. Je vous laisse consulter le site ici "FlameRobin".

Créer une base


Maintenant que FireBird tourne, il est temps de créer une base de donnée. Allez dans le dossier "FireBird\bin", et lancez "iSQL.exe". Tapez la commande suivante :
SQL>CREATE DATABASE 'mypath\JumborDB.fdb' page_size 8192
CON>user 'SYSDBA' password 'masterkey';
N'oubliez pas de remplacer "mypath" par un chemin valide.

Exemple


 
#############################################################
# Prérequis :
#     Installer le connecteur ADO.NET.
#     Créer la base de test "JumborDB" avec iSql.
#############################################################

#Assembly.
[Reflection.Assembly]::LoadFile("C:\Program Files (x86)\FirebirdClient\FirebirdSql.Data.FirebirdClient.dll")

#Chaine de connection.
$Connetion = "User=SYSDBA;Password=masterkey;DataSource=localhost;Port=3050;Database=JumborDB;initial catalog=mypath\\JumborDB.fdb;Dialect=3;Charset=NONE;Role=;Connection lifetime=15;Pooling=true;MinPoolSize=0;MaxPoolSize=50;Packet Size=8192;ServerType=0;"
#N'oubliez pas de remplacer "mypath" par un chemin valide.

Function FB_Query([string] $fbConn, [string] $fbQuery)
 {
   #Etablit la connexion avec la base SQL.
   $firebird = new-object FirebirdSql.Data.FirebirdClient.FbConnection($fbConn)
   $firebird.Open()

   #Exécute et récupère le résultat.
   $DataSet = New-Object System.Data.DataSet
   $Adapter = New-Object FirebirdSql.Data.FirebirdClient.FBDataAdapter($fbQuery, $firebird)
   $Adapter.Fill($DataSet)

   #Ferme la connexion avec la base SQL.
   $firebird.Close()

   #Renvoie le résultat.
   return $DataSet.Tables[0]

   #Close.
   $Adapter.Close
   $DataSet.Close
 }

######################################################################
# Voici la liste de différentes requêtes SQL que vous pouvez essayer.
# Supprimez le # devant la requête SQL que vous souhaitez tester.
######################################################################
#Créer une table.
#$myQuery = "CREATE TABLE Table1 (Colonne1 varchar(20) not null, Colonne2 varchar(20) not null)"
#Ajouter une ligne.
#$myQuery = "INSERT INTO Table1 (Colonne1,Colonne2) VALUES ('Jumbor12','PowerShell')"
#Lire une table.
#$myQuery = "SELECT * FROM Table1"
#Lire une ligne.
#$myQuery = "SELECT * FROM Table1 WHERE Colonne1 = 'Jumbor12'"
#Modifier une valeur.
#$myQuery = "UPDATE Table1 SET Colonne2 = 'PowerShell 2.0' WHERE Colonne2 = 'PowerShell'"
#Supprimer une ligne.
#$myQuery = "DELETE FROM Table1 WHERE Colonne1 = 'Jumbor12'"
#Supprimer une table.
#$myQuery = "DROP TABLE Table1"
######################################################################

#Affiche la requête exécutée.
Write-Host $myQuery

#Exécute la requête.
$rtn = FB_Query $Connetion $myQuery
foreach ($raw in $rtn)
 {
   #Ici j'affiche le retour pour les requêtes de lecture de données.
   Try { Write-Host "Line :" $raw[0] $raw[1] } catch {}
 }
Write-Host "Exécution terminé."

#Fin.

mardi 30 décembre 2014

Barre de progression

Je vais vous présenter ici un exemple de barre de progression basé sur l'objet "Forms.ProgressBar". La barre de progression prend une valeur allant de 0 (vide) à 100 (plein). Bien entendu, par défaut cette valeur est à 0. La barre de progression augmente d'une valeur définit dans la propriété ".Step" en appelant la méthode ".PerformStep()". Par exemple, si la propriété ".Step" est définit à 25, il faudra appeler 4 fois la méthode ".PerformStep()" pour remplir la barre de progression.

Exemple


 
#Assembly.
[Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")

#Ouvre une nouvelle fenêtre.
$formA = New-Object Windows.Forms.Form
$formA.FormBorderStyle = "FixedDialog"
$formA.text = "ProgressBar"
$formA.Size = New-Object Drawing.Point 300,100

#Création d'un label (Label).
$labelA1 = New-Object Windows.Forms.Label
$labelA1.Location = New-Object Drawing.Point 20,12
$labelA1.Size = New-Object System.Drawing.Size(250,16)
$labelA1.text = "Traitement en cours ..."

#Barre de progression (Progress bar).
$progressA1 = new-object System.Windows.Forms.ProgressBar
$progressA1.Location = new-object System.Drawing.Point 20,32
$progressA1.Size = new-object System.Drawing.Size(250,23)
$progressA1.Step = 1

#Timer.
#Le timer va me permettre de lancer automatiquement le traitement
#1 seconde après l'ouverture de la fenêtre.
$timer1 = new-object System.Windows.forms.timer
$timer1.Interval = 1000   #Initialement je lance le timer au bout d'une seconde.
$timer1.Enabled  = $true
$timer1.add_Tick({
                   #Initialisation.
                   #Pour éviter de lancer 2 fois le traitement je change
                   # l'intervalle d'exécution du timer.
                   $timer1.Interval = 999999

                   #Boucle de traitement.
                   for ($i=0;$i -le 100;$i++)
                    {
                      #Force l'exécution des events de la fenêtre.
                      [System.Windows.Forms.Application]::DoEvents()

                      #Mise à jour de la bar de progression.
                      $progressA1.PerformStep()

                      #Traitement de votre choix.
                      Sleep -Milliseconds 50
                    }

                   #Arrête le timer et ferme la fenêtre.
                   $timer1.Stop()
                   $formA.Close()
                })

#Attache les contrôles à la fenêtre.
$formA.controls.add($labelA1)
$formA.controls.add($progressA1)

#Lance le timer.
$timer1.Start()

#Affiche fenêtre.
$formA.ShowDialog()

#Fin.