Réaliser une image ronde.

Je vais revenir un peu sur les graphismes dans cet article. Nous allons voir comment créer une image d'avatar tout ronde avec PowerShell. Dans l'exemple suivant, je crée une fenêtre transparente dans laquelle j'affiche une image toute ronde à partir d'un fichier contenant une image classique. Pour des raisons pratiques, j'ai ajouté une fonction "Escape" pour pouvoir sortir facilement du programme.

 

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

#Defini le chemin courant.
$curpath = ""
if ($psISE) { $curpath = Split-Path -parent $psISE.CurrentFile.Fullpath }
else        { $curpath = Split-Path $MyInvocation.MyCommand.Path }
 
#Ouvre une fenêtre transparente sans bord ni fond.
$formA = New-Object Windows.Forms.Form
$formA.StartPosition = [System.Windows.Forms.FormStartPosition]::CenterScreen
$formA.Size = New-Object System.Drawing.Size(100,100)
$formA.FormBorderStyle = "None"
$formA.TopMost = 1
$formA.BackColor = [System.Drawing.Color]::FromArgb(255,1,2,3)
$formA.TransparencyKey = [System.Drawing.Color]::FromArgb(255,1,2,3)

#Crée un contrôle image.
$imageA1 = New-Object System.Windows.Forms.pictureBox
$imageA1.Location = New-Object Drawing.Point 0,0
$imageA1.Size = New-Object System.Drawing.Size(60,60)

#Charge le fichier image à traiter.
#Il doit être au même endroit que le script.
#Notre fichier contient une image classique rectangulaire.
Try   { $file = New-Object System.Drawing.Bitmap($curpath+"\av.png") }
Catch { Exit }

#Créer un Bitmap.
#Correspond ici à une feuille vierge (transparente).
$cgdata = New-Object System.Drawing.Bitmap(60,60)

#Créer un objet Graphics.
#Cet objet nous permettra de dessiner sur notre feuille.
$graphic = [System.Drawing.Graphics]::FromImage($cgdata)

#Nous allons redimensionné l'image.
#Pour obtenir une meilleur qualité, nous allons utiliser l'option suivante.
$graphic.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::HighQualityBicubic

#Nous allons maintenant définir une zone de dessin sur notre feuille.
#Ici, ma zone est un cercle de 60px sur 60px. Une fois appliqué, seule
#la zones définit sera dessinable. Rien ne sera modifié en dehors de la zone.
$grpath = New-Object System.Drawing.Drawing2D.GraphicsPath(0)
$grpath.AddEllipse(0, 0, 60, 60)
$graphic.SetClip($grpath)

#Copie l'image ac.png dans la zone dessinable sur la feuille.
#J'utilise ici DrawImage pour forcer le redimensionnement
#de l'image à la taille de ma feuille.
$graphic.DrawImage($file, 0, 0, 60, 60)
        
#Puis j'applique le dessin obtenu au contrôle image.
$imageA1.Image = $cgdata
$graphic.Dispose()

#Fermer la fenêtre lorsque l'on appuie sur la touche "Escape".
$formA.add_KeyDown({ If ($_.KeyCode -eq "Escape") { $formA.Close() } })

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

#Affiche le tout.
[void]$formA.ShowDialog()

Dism - Install roles and features

DISM (Deployment Image Servicing and Management) est un outil en ligne de commande permettant de modifier l'image Windows. Dans cet article, nous allons voir comment activer et désactiver des rôles et des fonctionnalités Windows en ligne de commande avec la commande DISM.

Installer un rôle ou une fonctionnalité

Installation simple sur l'OS en cours :

DISM /Online /Enable-Feature /All /FeatureName:TFTP

Installation en spécifiant la source :

DISM /Online /Enable-Feature /FeatureName:TFTP /Source:Z:\sources\SxS /LimitAccess

/Online : Indique que l'opération se déroule sur un Système en cours d’exécution.
/Enable-Feature : Installe le rôle ou la fonctionnalité indiqué avec /FeatureName.
/FeatureName : Nom du rôle ou de la fonctionnalité.
/LimitAccess : Empêche Dism d'utiliser Windows Update comme source.
/Source : Indique le chemin de la source à utiliser pour l'installation.
/All : Indique qu'il faut installer toutes les dépendances et les fonctionnalités liées.

Désinstaller un rôle ou une fonctionnalité

Désinstallation simple sur l'OS en cours :

DISM /Online /Disable-Feature /FeatureName:TFTP

/Online : Indique que l'opération se déroule sur un Système en cours d’exécution.
/Disable-Feature : Désinstalle le rôle ou la fonctionnalité indiqué avec /FeatureName.
/FeatureName : Nom du rôle ou de la fonctionnalité.

Lister tout les rôles et fonctionnalités disponible

Liste simple sur l'OS en cours :

Dism /Online /Get-Features

/Online : Indique que l'opération se déroule sur un Système en cours d’exécution.
/Get-Feature : Liste les rôles et les fonctionnalités, et affiche si ils sont activé ou non.

Liste des noms à utiliser avec FeatureName

Get-WindowsFeature

Rôle (FeatureName)

Nom affiché

RemoteAccess NetworkController ServerEssentialsRole Hyper-V MultiPointServerRole Fax DHCP DNS Web-Server Web-WebServer Web-Static-Content Web-Default-Doc Web-Http-Errors Web-Dir-Browsing Web-Http-Redirect Web-Http-Logging Web-Request-Monitor Web-Log-Libraries Web-Http-Tracing Web-Stat-Compression Web-Dyn-Compression Web-Filtering Web-Basic-Auth Web-Digest-Auth Web-Client-Auth Web-Windows-Auth Web-CertProvider Web-Asp-Net45 Web-CGI Web-Net-Ext45 Web-ISAPI-Ext Web-ISAPI-Filter Web-Mgmt-Console Web-Metabase Web-Scripting-Tools Web-Ftp-Service HostGuardianServiceRole AD-Domain-Services ADLDS ADRMS Remote-Desktop-Services VolumeActivation Print-Services AD-Certificate WDS ADFS-Federation FS-FileServer FS-Data-Deduplication Storage-Services NPAS UpdateServices ...

Accès à distance Contrôleur de réseau Expérience Windows Server Essentials Hyper-V MultiPoint Services Serveur de télécopie Serveur DHCP Serveur DNS Serveur Web (IIS) Serveur Web Contenu statique Document par défaut Erreurs HTTP Exploration de répertoire Redirection HTTP Journalisation HTTP Observateur de demandes Outils de journalisation Suivi de traces Compression du contenu statique Compression de contenu dynamique Filtrage des demandes Authentification de base Authentification Digest Authentification par mappage de certificat Authentification Windows Prise en charge centralisée des certificat ASP.NET 4.6 CGI Extensibilité .NET 4.6 Extensions ISAPI Filtres ISAPI Console de gestion IIS Compatibilité de métadonnées IIS 6 Scripts et outils de gestion IIS Service FTP Service Guardian hôte Services AD DS Services AD LDS Services AD RMS Services Bureau à distance Services d’activation en volume Services d’impression et de numérisation Services de certificats Active Directory Services de déploiement Windows Services de fédération Active Directory Serveur de fichiers Déduplication des données Services de stockage Services de stratégie et d’accès réseau Services WSUS ...

Annonce - Eco7 v1.4.0

Avec Eco7 version 1.4.0, j'ai pratiquement réécris l'ensemble de l'application. Si le concept reste inchangé, il n'y a pas une seul fonction qui n'a pas du être remanié ou optimisé. C'est un gros travail qui m'a longtemps refroidi. Mais j'ai finalement sauté le pas ^^.

Les principales modifications sont l’intégration de Lite-DB dans Eco7 pour stocker les données et les journaux. L'apport de la base de données permet de travailler directement sur la base de données au lieu de charger un fichier en mémoire et de sauvegarder à la fermeture du programme. Cela apporte plus de fiabilité mais aussi plus de rapidité dans le traitement des informations.

J'ai ajouté une nouvelle fonctionnalités afin d'afficher un rapport de surveillance pour chaque icône. Ceci permet d'avoir un tableau plus simple à lire et avec des alarmes plus détaillé.

J'ai ajouté la possibilité de surveiller de décalage des horloges des serveurs Windows par rapport à un serveur NTP de référence lorsque l'option Wmi est activé. Actuellement, j'utilise les seuils suivant : Inférieur à 1s = vert, de 1-5s = jaune, 5-60s = orange, plus de 60s = rouge.

N'hésitez pas à vous rendre sur la page d'Eco7 pour avoir plus d'information.

Spoiler : Pour la prochaine version, je travaille sur l'intégration de SharpSnmpLib dans Eco7.

Powershell et SNMP

Pour récupérer des informations SNMP avec Windows Powershell, j'utilise dans cet article SharpSnmpLib.dll. L'exemple proposé ici montre en particulier comment utiliser les commandes SnmpWalker et SnmpGet avec Windows Powershell.

Principe général du protocole SNMP

Le SNMP est un protocole client serveur utilisé pour transmettre l'état des services et applications d'un serveurs vers une console de surveillance. Le protocole SNMP se divise en deux principes de communication. Le mode Pull à l'initiative du client et le mode Push, à l'initiative du serveur. Dans le mode Pull le client va lire les informations mis à disposition par le serveur (snmpwalk, snmpget). Dans le mode Push, le client va écouté les informations envoyé par le serveur (snmptrap, snmptrapd).

Référence

J'ai testé un article très intéressant sur la façon de récupérer des informations SNMP en PowerShell. Si vous maitrisez un minimum l'anglais, je vous invite à le lire l'article en référence. Vous trouverez le lien du site ci-dessous. Par contre j'ai eu un peu de mal à récupérer le fichier "SharpSnmpLib.dll". Je vais donc ajouter un lien avec la source. L'exemple que je vous propose aujourd'hui est une donc une version légèrement remanier en français.

Site de référence : https://vwiki.co.uk/SNMP_and_PowerShell
Télécharger la Dll : SharpSnmpLib.dll

Exemple

Dans cet exemple j'utilise le mode SNMP Pull pour lire les information mis à disposition sur un système distant. Pour cet exemple, il faut créer un dossier "lib" au même niveau que le script, et y décompresser l'archive téléchargée ci-dessus.

 

############################################################
# Snmp : SharpSnmpLib v7.6
# Powershell : Version 2.0
############################################################

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

#Chargement des librairies.
[Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")
Try   { [void][Reflection.Assembly]::LoadFile($curpath+"\lib\SharpSnmpLib.dll") }
Catch { write-host "SharpSnmpLib.dll manquant.";Return }

############################################################
# Fonctions SNMP
############################################################

#Fonction - Créer un type générique.
function Snmp-GenericObject ([string]$typeName,[string[]]$typeParams,[object[]]$constructorParams)
 {
   #Créer le nom du type générique.
   $genericTypeName = $typeName + "``" + $typeParams.Count
   $genericType = [Type] $genericTypeName
   if (!$genericType) { throw "Impossible de trouver le type générique $genericTypeName" }

   #Lier les parametres de type à celui-ci.
   [type[]] $typedParams = $typeParams
   $closedType = $genericType.MakeGenericType($typedParams)
   if (!$closedType) { throw "Impossible de finaliser le type $genericType" }

   #Créer la version final du type générique.
   ,[Activator]::CreateInstance($closedType, $constructorParams)
}

#Fonction - SnmpWalker.
function Snmp-Walker ([string]$sIP, $sOIDstart, [string]$Community = "public", [int]$UDPport = 161, [int]$TimeOut=3000)
 {
   #$TimeOut est en msec, 0 ou -1 pour infini.
   #Créer un objet OID.
   $oid = New-Object Lextm.SharpSnmpLib.ObjectIdentifier ($sOIDstart)
   
   #Créer la liste pour les résultats (compatible powershell v2).
   $results = Snmp-GenericObject System.Collections.Generic.List Lextm.SharpSnmpLib.Variable
   
   #Créer un point de terminaison pour le serveur SNMP.
   $ip = [System.Net.IPAddress]::Parse($sIP)
   $svr = New-Object System.Net.IpEndPoint ($ip, 161)

   #Utiliser SNMP v2 avec le mode "WithinSubTree".
   $ver = [Lextm.SharpSnmpLib.VersionCode]::V2
   $walkMode = [Lextm.SharpSnmpLib.Messaging.WalkMode]::WithinSubtree

   #Lancer le requête SNMP.
   Try   { $null = [Lextm.SharpSnmpLib.Messaging.Messenger]::Walk($ver, $svr, $Community, $oid, $results, $TimeOut, $walkMode) }
   Catch { Write-Host "Erreur SNMP : $_"; Return }

   #Dans cet exemple j'ai changé le format de sortie pour un tableau d'objet.
   $rtn = @()
   foreach ($var in $results)
    {
      $obj = New-Object System.Object
      $obj | Add-Member -type NoteProperty -name OID  -Value ([string]$var.Id)
      $obj | Add-Member -type NoteProperty -name Data -Value ([string]$var.Data)
      $rtn += $obj
    }
   #Résultats.
   $rtn
 }

#Fonction - GetSnmp.
function Snmp-Get ([string]$sIP, $sOIDs, [string]$Community = "public", [int]$UDPport = 161, [int]$TimeOut=3000)
 {
   #$TimeOut est en msec, 0 ou -1 pour infini.
   #Créer une liste de variables OID (compatible powershell v2).
   $vList = Snmp-GenericObject System.Collections.Generic.List Lextm.SharpSnmpLib.Variable
   foreach ($sOID in $sOIDs)
    {
      $oid = New-Object Lextm.SharpSnmpLib.ObjectIdentifier ($sOID)
      $vList.Add($oid)
    }
   
   #Créer un point de terminaison pour le serveur SNMP.
   $ip = [System.Net.IPAddress]::Parse($sIP)
   $svr = New-Object System.Net.IpEndPoint ($ip, 161)
   
   #Utiliser SNMP v2.<
   $ver = [Lextm.SharpSnmpLib.VersionCode]::V2
   
   #Lancer le requête SNMP.
   Try   { $msg = [Lextm.SharpSnmpLib.Messaging.Messenger]::Get($ver, $svr, $Community, $vList, $TimeOut) }
   Catch { Write-Host "SNMP Get error: $_"; Return }

   #Dans cet exemple j'ai changé le format de sortie pour un tableau d'objet.   
   $rtn = @()
   foreach ($var in $msg)
    {
      $obj = New-Object System.Object
      $obj | Add-Member -type NoteProperty -name OID  -Value ([string]$var.Id)
      $obj | Add-Member -type NoteProperty -name Data -Value ([string]$var.Data)
      $rtn += $obj
    }
   #Résultats.
   $rtn
 }

############################################################
# Zone de test.
#
# Usage :
# Snmp-Walker IP OIDSTART [Community] [Port] [Timeout]
# Snmp-Get    IP OID      [Community] [Port] [Timeout]
############################################################

#Snmp Walker.
#Remplacer l'adresse ip par une adresse valide.
Snmp-Walker "127.0.0.1" ".1.3.6.1.2.1" | Out-String
Snmp-Walker "127.0.0.1" ".1.3.6.1.2.1" | Out-GridView

#Snmp Get.
#Remplacer l'adresse ip par une adresse valide.
Snmp-Get "127.0.0.1" ".1.3.6.1.2.1.1.5.0" | Out-String
Snmp-Get "127.0.0.1" ".1.3.6.1.2.1.1.5.0" | Out-GridView

#Fin.

Expressions régulières (RegEx)

Windows PowerShell utilise les expressions régulières (RegEx) pour déterminer si une chaine de caractères est conforme au format définit par l'expression régulière. Pour comparer une chaine de caractères avec une RegEx, Windows PowerShell utilise -match -notmatch, -cmatch, -notcmatch.

Principe du RegEx.

Une expression régulière est une chaîne de caractères représentant un ensemble de chaîne de caractères possibles. Dit comme ça ce ne parle pas forcement à tout le monde. Je vais essayer d'expliquer ça plus simplement. Imaginez que vous voulez rechercher le fichier "toto.txt"sur votre disque. Dans le champ de recherche vous utilisez le caractères génériques * pour dire au système de trouver tout les fichiers commençant par "toto" (ex : toto*). Le système va alors afficher des fichiers commençant par "toto" comme "toto1.txt", "toto.xml", etc. Le RegEx c'est pareil, mais avec des caractères génériques infiniment plus élaborés.

Note : Oui je sais, le caractère générique * n'est pas interprété pareil dans la recherche de fichier que dans le RegEx, mais c'est pour l'explication du principe de base ... "Il écoute vraiment rien Hervé" ^^.

Les bases de l'expression régulière.

^ = En début de chaine signifie "commence par".
^ = En milieu de chaine ce symbole représente la négation.
$ = En fin de chaine signifie "se termine par".
\w = [a-zA-Z0-9_]
\d = Contient au moins 1 chiffre.
\s = Contient au moins 1 espace.
\D = Ne contient aucun chiffre.
\S = Ne contient aucun espace.
[] = Liste ou range de caractère ex: [a-z] tout les caractères de "a" à "z".
{} = Longueur de la chaine à valider ex: {1,5} = 1 à 5 caractères.
{5} = Longueur exacte de la chaine (ici 5 caractère).
{5,} = Longueur au moins de 5 caractères (de 5 à n).
{5,9} = Longueur de 5 à 9 caractères.
* = N'importe quel longueur de 0 à n caractères.
+ = N'importe quel longueur de 1 à n caractères.
? = Indique que la condition précédente est optionnel.
| = Indique le choix entre deux conditions (Ou).

Exemples :
[a-z]* = Chaine alphabétique de longueur de 0 à n caractères.
[a-z]+ = Chaine alphabétique de longueur de 1 à n caractères.
[a-z]{1,12} = Chaine alphabétique de longueur de 1 à 12 caractères.
\d{1,6} = Nombre de 0 à 999999.
[:;,.] = Liste de caractères.
([a-z]+\d{1,4})+ = Le (...)+ indique une structure répétable de 1 à n fois.

Les comparaisons :
-match = Correspond à ... (insensible à la casse).
-notmatch = Ne correspond pas à ... (insensible à la casse).
-cmatch = Correspond à ... (sensible à la casse).
-cnotmatch = Ne correspond pas à ... (sensible à la casse).

Caractère d'échappement :

En dehors des cas vu précédemment, la barre oblique inverse "\" est utilisée dans une expression régulière pour indiquer que le caractère suivant doit être interprété littéralement. Par exemple :

\\ = \
\. = .
\+ = +
\* = *

Exemples classiques.

Texte avec caractères alphabétiques :

$texte = "Jumbor"
$texte -match  "^[a-z]*$"
$texte -cmatch "^[a-zA-Z]*$"

Texte en minuscule uniquement :

$texte = "jumbor"
$texte -cmatch "^[a-z]*$"

Texte en majuscule uniquement :

$texte = "JUMBOR"
$texte -cmatch "^[A-Z]*$"

Texte de 1 à 12 caractères alphabétiques :

$texte = "Jumbor"
$texte -match "^[a-z]{1,12}$"

Texte commençant par une majuscule, et de 1 à 12 caractères alphabétiques :

$texte = "Jumbor"
$texte -cmatch "^[A-Z]{1}[a-zA-Z]{0,11}$"

Texte de 1 à 12 caractères sans espace et sans chiffre :

$texte = "Jumbor"
$texte -match "^\S\D{1,12}$"

Chiffre de 0 à 99999 :

$texte = "12"
$texte -match "^\d{1,5}$"

Ne contient pas ces caractères :

$texte = "Jumbor"
$texte -notmatch "[:;,.]"

Contient que des chiffres et lettres :

$texte = "Jumbor12"
$texte -match "^[0-9a-z]*$"
$texte -cmatch "^[0-9a-zA-Z]*$"

Exemples avancés.

Vérifier le format "Prénom NOM" avec des prénoms simples :

$texte = "Barus CROW"
$texte -cmatch "^[A-Z]{1}[a-zA-Z]* [A-Z]*$"

Idem en ajoutant des prénoms composés en "Prénom-Prénom" :

$texte = "Jean-Pierre CROW"
$texte -cmatch "^(([A-Z]{1}[a-z]*)|([A-Z]{1}[a-z]*-[A-Z]{1}[a-z]*)) [A-Z]*$"

Idem en ajoutant des caractères accentué :

$texte = "Loïc CROW"
$texte -cmatch "^(([A-Z]{1}[éïëèa-z]*)|([A-Z]{1}[éïëèa-z]*-[A-Z]{1}[éïëèa-z]*)) [A-Z]*$"

Vérifier une adresse ip4 :

$ip = "192.168.1.1"
$ip -match "\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"

Vérifier une adresse ip4 plus précisément :

$ip = "192.168.1.1"
$ip -match "((\b(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b)"

Vérifier une adresse email en particulier :

$email = "Jumbor@sekki.fr"
$email -match "^(([a-z]+)|([a-z]+\.[a-z]+))@sekki.fr$"

Vérifier une adresse mail générique :

$email = "Jumbor@sekki.fr"
$email -match "^(([a-z]+)|([a-z]+\.[a-z]+))@[a-z]+\.[a-z]+$"

Vérifier une adresse DNS simple :

$dns = "powershell.sekki.fr"
$site -match $dns -match "^([a-z]+\.)*([a-z]+)$"

Vérifier un site web :

$site = "http://powershell.sekki.fr"
$site -match "^(http://|https://|ftp://)([a-z]+\.)*([a-z]+)$"

Extraire une chaine en RegEx.

Exemple 1 :

$text = "Mon numéro de téléphone n'est pas le 06-11-22-33-44 !!!"
$phone = [regex]::match($text,'((\d{2}(-|\.){0,1}){5})').Value

Remplacer une chaine en RegEx.

Remplace une Ip dans le texte :

$text = "Serveur;Site;10.112.120.6;Type"
$rtn = [regex]::replace($text,'((\d{1,3}(\.){0,1}){4})','xxx.xxx.xxx.xxx')

#Remplace le début d'une Ip dans le texte :

$text = "Serveur;Site;10.112.120.6;Type"
$ip1 = [regex]::match($text,'((\d{1,3}(\.){0,1}){4})').Value
$ip2 = [regex]::replace($ip1,'^(\d{1,3}(\.))','xxx.')
$rtn = [regex]::replace($text,'((\d{1,3}(\.){0,1}){4})',$($ip2))

Bouton Parcourir (OpenFileDialog)

Dans cet article, nous allons utiliser Windows PowerShell pour ouvrir une fenêtre (Form) et y ajouter le bouton de sélection de fichier "Parcourir" (OpenFileDialog). L'objet OpenFileDialog gère à la fois la création de la fenêtre de sélection, l'exploration des fichiers, et la sélection du fichier. Il ne nous reste plus qu'à configurer quelques options, lancer l'ouverture de la fenêtre, et récupérer le nom du fichier choisi.

 

#Menu contextuel sur un contrôle.
[Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")

#Ouvre une fenêtre.
[Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")
$form = New-Object Windows.Forms.Form
$form.text = "Ouvrir un fichier"            
$form.Size = New-Object System.Drawing.Size(250,150)

#Création d'un label (Label).
$label1 = New-Object Windows.Forms.Label
$label1.Location = New-Object Drawing.Point 20,30
$label1.Size = New-Object Drawing.Point 150,16
$label1.text = "Sélectionner un fichier."

#Création d'une zone texte (TextBox).
$texte1 = New-Object Windows.Forms.TextBox
$texte1.Location = New-Object Drawing.Point 20,50
$texte1.Size = New-Object Drawing.Point 140,30
$texte1.Text = ""

#Création d'un bouton parcourir (Button + OpenFileDialog).
$bouton1 = New-Object Windows.Forms.Button
$bouton1.Location = New-Object Drawing.Point 160,49
$bouton1.Size = New-Object Drawing.Point 65,21
$bouton1.text = "Parcourir"
$bouton1.add_click({
                     #Création d'un objet "ouverture de fichier".
                     $ouvrir1 = New-Object System.Windows.Forms.OpenFileDialog

                     #Initialisation du chemin par défaut.
                     $ouvrir1.initialDirectory = "C:\"

                     #Ici on va afficher que les fichiers en ".txt".
                     $ouvrir1.filter = "TXT Files (*.txt)| *.txt"

                     #Affiche la fenêtre d'ouverture de fichier.
                     $retour1 = $ouvrir1.ShowDialog()

                     #Traitement du retour.
                     #Si "OK" on affiche le fichier sélectionné dans la TextBox.
                     #Sinon on afficher un fichier par défaut.
                     if ($retour1 -eq "OK") { $texte1.Text = $ouvrir1.filename }
                     else { $texte1.Text = "C:\jumbor12.txt" }
                  })

#Attache le contrôle à la fenêtre.
$form.controls.add($label1)
$form.controls.add($texte1)
$form.controls.add($bouton1)#Affiche le tout.
$form.ShowDialog()

#Fin.

Dans notre exemple, nous n'avons pas intégré la vérification de l'existence du fichier en cas de saisi manuel dans la TextBox. Pour faire cette vérification, nous pouvons utiliser la commande "Test-Path" :

$fichier1 = "C:\jumpor12.jpg"
$test1 = Test-Path $fichier1
if ($test1 -ne "True") { Write-Host "Fichier absent."  }
else                   { Write-Host "Fichier présent." }